Use Node test runner

Author: wooorm

.github/workflows/main.yml

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

package.json

@@ -40,12 +40,11 @@
     "hastscript": "^7.0.0"
   },
   "devDependencies": {
-    "@types/tape": "^4.0.0",
+    "@types/node": "^18.0.0",
     "c8": "^7.0.0",
     "prettier": "^2.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",
     "unist-builder": "^3.0.0",

test.js

@@ -1,164 +1,181 @@
-import test from 'tape'
+import assert from 'node:assert/strict'
+import test from 'node:test'
 import {h, s} from 'hastscript'
 import {fromSelector} from './index.js'
 
-test('fromSelector()', (t) => {
-  t.throws(
+test('fromSelector()', () => {
+  assert.throws(
     () => {
       fromSelector('@supports (transform-origin: 5% 5%) {}')
     },
     /Error: Rule expected but "@" found/,
     'should throw w/ invalid selector'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromSelector('a, b')
     },
     /Error: Cannot handle selector list/,
     'should throw w/ multiple selector'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromSelector('a + b')
     },
     /Error: Cannot handle sibling combinator `\+` at root/,
     'should throw w/ next-sibling combinator at root'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromSelector('a ~ b')
     },
     /Error: Cannot handle sibling combinator `~` at root/,
     'should throw w/ subsequent-sibling combinator at root'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromSelector('[foo%=bar]')
     },
     /Error: Expected "=" but "%" found./,
     'should throw w/ attribute modifiers'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromSelector('[foo~=bar]')
     },
     /Error: Cannot handle attribute equality modifier `~=`/,
     'should throw w/ attribute modifiers'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromSelector(':active')
     },
     /Error: Cannot handle pseudo-selector `active`/,
     'should throw on pseudo classes'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromSelector(':nth-foo(2n+1)')
     },
     /Error: Cannot handle pseudo-selector `nth-foo`/,
     'should throw on pseudo class “functions”'
   )
 
-  t.throws(
+  assert.throws(
     () => {
       fromSelector('::before')
     },
     /Error: Cannot handle pseudo-element or empty pseudo-class/,
     'should throw on invalid pseudo elements'
   )
 
-  t.deepEqual(fromSelector(), h(''), 'should support no selector')
-  t.deepEqual(fromSelector(''), h(''), 'should support the empty string')
-  t.deepEqual(fromSelector(' '), h(''), 'should support whitespace only')
-  t.deepEqual(fromSelector('*'), h(''), 'should support the universal selector')
+  assert.deepEqual(fromSelector(), h(''), 'should support no selector')
+  assert.deepEqual(fromSelector(''), h(''), 'should support the empty string')
+  assert.deepEqual(fromSelector(' '), h(''), 'should support whitespace only')
+  assert.deepEqual(
+    fromSelector('*'),
+    h(''),
+    'should support the universal selector'
+  )
 
-  t.deepEqual(
+  assert.deepEqual(
     fromSelector('p i s'),
     h('p', h('i', h('s'))),
     'should support the descendant combinator'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     fromSelector('p > i > s'),
     h('p', h('i', h('s'))),
     'should support the child combinator'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     fromSelector('p i + s'),
     h('p', [h('i'), h('s')]),
     'should support the next-sibling combinator'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     fromSelector('p i ~ s'),
     h('p', [h('i'), h('s')]),
     'should support the subsequent-sibling combinator'
   )
 
-  t.deepEqual(fromSelector('a'), h('a'), 'should support a tag name')
-  t.deepEqual(fromSelector('.a'), h('.a'), 'should support a class')
-  t.deepEqual(fromSelector('a.b'), h('a.b'), 'should support a tag and a class')
-  t.deepEqual(fromSelector('#b'), h('#b'), 'should support an id')
-  t.deepEqual(fromSelector('a#b'), h('a#b'), 'should support a tag and an id')
-  t.deepEqual(
+  assert.deepEqual(fromSelector('a'), h('a'), 'should support a tag name')
+  assert.deepEqual(fromSelector('.a'), h('.a'), 'should support a class')
+  assert.deepEqual(
+    fromSelector('a.b'),
+    h('a.b'),
+    'should support a tag and a class'
+  )
+  assert.deepEqual(fromSelector('#b'), h('#b'), 'should support an id')
+  assert.deepEqual(
+    fromSelector('a#b'),
+    h('a#b'),
+    'should support a tag and an id'
+  )
+  assert.deepEqual(
     fromSelector('a#b.c.d'),
     h('a#b.c.d'),
     'should support all together'
   )
-  t.deepEqual(fromSelector('a#b#c'), h('a#c'), 'should use the last id')
-  t.deepEqual(fromSelector('A').tagName, 'a', 'should normalize casing')
+  assert.deepEqual(fromSelector('a#b#c'), h('a#c'), 'should use the last id')
+  assert.deepEqual(fromSelector('A').tagName, 'a', 'should normalize casing')
 
-  t.deepEqual(
+  assert.deepEqual(
     fromSelector('[a]'),
     h('', {a: true}),
     'should support attributes (#1)'
   )
-  t.deepEqual(
+  assert.deepEqual(
     fromSelector('[a=b]'),
     h('', {a: 'b'}),
     'should support attributes (#2)'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     fromSelector('.a.b[class=c]'),
     h('.a.b.c'),
     'should support class and class attributes'
   )
 
-  t.deepEqual(fromSelector('altGlyph').tagName, 'altglyph', 'space (#1)')
+  assert.deepEqual(fromSelector('altGlyph').tagName, 'altglyph', 'space (#1)')
 
-  t.deepEqual(fromSelector('altGlyph', 'svg').tagName, 'altGlyph', 'space (#2)')
+  assert.deepEqual(
+    fromSelector('altGlyph', 'svg').tagName,
+    'altGlyph',
+    'space (#2)'
+  )
 
-  t.deepEqual(
+  assert.deepEqual(
     fromSelector('altGlyph', {space: 'svg'}).tagName,
     'altGlyph',
     'space (#3)'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     // @ts-expect-error: fine.
     fromSelector('svg altGlyph').children[0].tagName,
     'altGlyph',
     'space (#4)'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     // @ts-expect-error: fine.
     fromSelector('div svg + altGlyph').children[1].tagName,
     'altglyph',
     'space (#5)'
   )
 
-  t.deepEqual(
+  assert.deepEqual(
     fromSelector(
       'p svg[viewbox=0 0 10 10] circle[cx=10][cy=10][r=10] altGlyph'
     ),
@@ -169,6 +186,4 @@ test('fromSelector()', (t) => {
     ]),
     'space (#6)'
   )
-
-  t.end()
 })