Use @types/nlcst

Author: wooorm

index.js

@@ -1,32 +1,31 @@
 /**
- * @typedef {import('unist').Node} Node
+ * @typedef {import('nlcst').Content} Content
+ * @typedef {import('nlcst').Root} Root
  */
 
 /**
  * Stringify one nlcst node or list of nodes.
  *
- * @param {unknown} node
+ * @param {Root|Content|Content[]} node
  * @param {string} [separator='']
  * @returns {string}
  */
 export function toString(node, separator = '') {
   let index = -1
 
-  // @ts-expect-error Looks like an object.
   if (!node || (!Array.isArray(node) && !node.type)) {
     throw new Error('Expected node, not `' + node + '`')
   }
 
   // @ts-expect-error Looks like a literal.
   if (typeof node.value === 'string') return node.value
 
-  /** @type {Array.<Node>} */
+  /** @type {Array.<Content|Root>} */
   // @ts-expect-error Looks like a list of nodes or parent.
   const children = (Array.isArray(node) ? node : node.children) || []
 
   // Shortcut: This is pretty common, and a small performance win.
   if (children.length === 1 && 'value' in children[0]) {
-    // @ts-expect-error Looks like a literal.
     return children[0].value
   }
 

package.json

@@ -33,7 +33,7 @@
     "index.js"
   ],
   "dependencies": {
-    "@types/unist": "^2.0.0"
+    "@types/nlcst": "^1.0.0"
   },
   "devDependencies": {
     "@types/tape": "^4.0.0",

test.js

@@ -14,44 +14,62 @@ test('toString()', (t) => {
 
   t.throws(
     () => {
+      // @ts-expect-error: missing `type`.
       toString({value: 'foo'})
     },
     /\[object Object]/,
     'should throw when not given a node (#2)'
   )
 
-  t.equal(toString(u('foo', 'AT')), 'AT', 'should support texts')
+  t.equal(toString(u('TextNode', 'AT')), 'AT', 'should support texts')
 
   t.equal(
-    toString(u('foo', [u('bar', 'AT'), u('bar', '&'), u('bar', 'T')])),
+    toString(
+      u('WordNode', [
+        u('TextNode', 'AT'),
+        u('SymbolNode', '&'),
+        u('TextNode', 'T')
+      ])
+    ),
     'AT&T',
     'should support parents'
   )
 
   t.equal(
-    toString([u('bar', 'AT'), u('bar', '&'), u('bar', 'T')]),
+    toString([u('TextNode', 'AT'), u('SymbolNode', '&'), u('TextNode', 'T')]),
     'AT&T',
     'should support nodes'
   )
 
   t.equal(
     toString(
-      u('foo', [u('bar', 'AT'), u('foo', [u('bar', '&')]), u('bar', 'T')])
+      // @ts-expect-error: custom.
+      u('WordNode', [
+        u('TextNode', 'AT'),
+        u('SomeNode', [u('TextNode', '&')]),
+        u('TextNode', 'T')
+      ])
     ),
     'AT&T',
     'should support parents with mixed children'
   )
 
   t.equal(
     toString(
-      u('foo', [u('bar', 'AT'), u('foo', [u('bar', '&')]), u('bar', 'T')]),
+      // @ts-expect-error: custom.
+      u('WordNode', [
+        u('TextNode', 'AT'),
+        u('WordNode', [u('TextNode', '&')]),
+        u('TextNode', 'T')
+      ]),
       ','
     ),
     'AT,&,T',
     'should support separators'
   )
 
-  t.equal(toString(u('foo')), '', 'should support voids')
+  // @ts-expect-error: custom node.
+  t.equal(toString(u('VoidNode')), '', 'should support voids')
 
   t.end()
 })