Use Node test runner

Author: wooorm

.github/workflows/main.yml

@@ -17,5 +17,5 @@ jobs:
     strategy:
       matrix:
         node:
-          - lts/fermium
+          - lts/gallium
           - node

lib/index.js

@@ -50,6 +50,7 @@ export function definitions(tree) {
   /** @type {GetDefinition} */
   function definition(identifier) {
     const id = clean(identifier)
+    // To do: next major: return `undefined` when not found.
     return id && own.call(cache, id) ? cache[id] : null
   }
 }

package.json

@@ -41,13 +41,12 @@
     "unist-util-visit": "^4.0.0"
   },
   "devDependencies": {
-    "@types/tape": "^4.0.0",
+    "@types/node": "^18.0.0",
     "c8": "^7.0.0",
+    "mdast-util-from-markdown": "^1.0.0",
     "prettier": "^2.0.0",
-    "remark": "^14.0.0",
     "remark-cli": "^11.0.0",
     "remark-preset-wooorm": "^9.0.0",
-    "tape": "^5.0.0",
     "type-coverage": "^2.0.0",
     "typescript": "^4.0.0",
     "xo": "^0.53.0"

test.js

@@ -1,16 +1,10 @@
-/**
- * @typedef {import('mdast').Root|import('mdast').Content} Node
- */
-
-import test from 'tape'
-import {remark} from 'remark'
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import {fromMarkdown} from 'mdast-util-from-markdown'
 import {definitions} from './index.js'
 
-test('mdast-util-definitions', (t) => {
-  /** @type {Node} */
-  let tree
-
-  t.throws(
+test('mdast-util-definitions', () => {
+  assert.throws(
     () => {
       // @ts-expect-error runtime
       definitions()
@@ -19,12 +13,10 @@ test('mdast-util-definitions', (t) => {
     'should fail without node'
   )
 
-  tree = /** @type {Node} */ (
-    remark().parse('[example]: https://example.com "Example"')
-  )
-
-  t.deepLooseEqual(
-    definitions(tree)('example'),
+  assert.deepEqual(
+    definitions(fromMarkdown('[example]: https://example.com "Example"'))(
+      'example'
+    ),
     {
       type: 'definition',
       identifier: 'example',
@@ -39,14 +31,18 @@ test('mdast-util-definitions', (t) => {
     'should return a definition'
   )
 
-  t.equal(definitions(tree)('foo'), null, 'should return null when not found')
-
-  tree = /** @type {Node} */ (
-    remark().parse('[__proto__]: https://proto.com "Proto"')
+  assert.equal(
+    definitions(fromMarkdown('[example]: https://example.com "Example"'))(
+      'foo'
+    ),
+    null,
+    'should return null when not found'
   )
 
-  t.deepLooseEqual(
-    definitions(tree)('__proto__'),
+  assert.deepEqual(
+    definitions(fromMarkdown('[__proto__]: https://proto.com "Proto"'))(
+      '__proto__'
+    ),
     {
       type: 'definition',
       identifier: '__proto__',
@@ -64,32 +60,32 @@ test('mdast-util-definitions', (t) => {
   /* eslint-disable no-use-extend-native/no-use-extend-native */
   // @ts-expect-error: yes.
   // type-coverage:ignore-next-line
-  t.equal({}.type, undefined, 'should not polute the prototype')
+  assert.equal({}.type, undefined, 'should not polute the prototype')
   /* eslint-enable no-use-extend-native/no-use-extend-native */
 
-  t.deepEqual(
-    definitions(tree)('toString'),
+  assert.deepEqual(
+    definitions(fromMarkdown('[__proto__]: https://proto.com "Proto"'))(
+      'toString'
+    ),
     null,
     'should work on weird identifiers when not found'
   )
 
-  tree = /** @type {Node} */ (
-    remark().parse('[example]: https://one.com\n[example]: https://two.com')
-  )
-
-  const example = definitions(tree)('example')
+  const example = definitions(
+    fromMarkdown('[example]: https://one.com\n[example]: https://two.com')
+  )('example')
 
-  t.deepEqual(
+  assert.deepEqual(
     example && example.url,
     'https://one.com',
     'should prefer the first of duplicate definitions'
   )
 
-  t.deepEqual(
-    definitions(tree)(''),
+  assert.deepEqual(
+    definitions(
+      fromMarkdown('[example]: https://one.com\n[example]: https://two.com')
+    )(''),
     null,
     'should not return something for a missing identifier'
   )
-
-  t.end()
 })