Refactor code-style

Author: wooorm

lib/index.js

@@ -10,4 +10,12 @@ import {convertElement} from 'hast-util-is-element'
  *
  *   The elements `script` and `template` are script-supporting.
  */
-export const scriptSupporting = convertElement(['script', 'template'])
+export const scriptSupporting = convertElement(
+  /**
+   * @param element
+   * @returns {element is import('hast').Element & {tagName: 'script' | 'template'}}}
+   */
+  function (element) {
+    return element.tagName === 'script' || element.tagName === 'template'
+  }
+)

test.js

@@ -1,53 +1,63 @@
 import assert from 'node:assert/strict'
 import test from 'node:test'
 import {scriptSupporting} from './index.js'
-import * as mod from './index.js'
 
-test('scriptSupporting', () => {
-  assert.deepEqual(
-    Object.keys(mod).sort(),
-    ['scriptSupporting'],
-    'should expose the public api'
-  )
+test('scriptSupporting', async function (t) {
+  await t.test('should expose the public api', async function () {
+    assert.deepEqual(Object.keys(await import('./index.js')).sort(), [
+      'scriptSupporting'
+    ])
+  })
 
-  assert.equal(scriptSupporting(), false, 'should return `false` without node')
+  await t.test('should return `false` without node', async function () {
+    // @ts-expect-error `node` should be given.
+    assert.equal(scriptSupporting(), false)
+  })
 
-  assert.equal(
-    scriptSupporting(null),
-    false,
-    'should return `false` with `null`'
-  )
+  await t.test('should return `false` with `null`', async function () {
+    assert.equal(scriptSupporting(null), false)
+  })
 
-  assert.equal(
-    scriptSupporting({type: 'text'}),
-    false,
-    'should return `false` when without `element`'
+  await t.test(
+    'should return `false` when without `element`',
+    async function () {
+      assert.equal(scriptSupporting({type: 'text'}), false)
+    }
   )
 
-  assert.equal(
-    scriptSupporting({type: 'element'}),
-    false,
-    'should return `false` when with invalid `element`'
+  await t.test(
+    'should return `false` when with invalid `element`',
+    async function () {
+      assert.equal(scriptSupporting({type: 'element'}), false)
+    }
   )
 
-  assert.equal(
-    scriptSupporting({
-      type: 'element',
-      tagName: 'a',
-      properties: {href: '#alpha', title: 'Bravo'},
-      children: [{type: 'text', value: 'Charlie'}]
-    }),
-    false,
-    'should return `false` when without not script-supporting'
+  await t.test(
+    'should return `false` when without not script-supporting',
+    async function () {
+      assert.equal(
+        scriptSupporting({
+          type: 'element',
+          tagName: 'a',
+          properties: {href: '#alpha', title: 'Bravo'},
+          children: [{type: 'text', value: 'Charlie'}]
+        }),
+        false
+      )
+    }
   )
 
-  assert.equal(
-    scriptSupporting({
-      type: 'element',
-      tagName: 'template',
-      children: [{type: 'text', value: 'Delta'}]
-    }),
-    true,
-    'should return `true` when with script-supporting'
+  await t.test(
+    'should return `true` when with script-supporting',
+    async function () {
+      assert.equal(
+        scriptSupporting({
+          type: 'element',
+          tagName: 'template',
+          children: [{type: 'text', value: 'Delta'}]
+        }),
+        true
+      )
+    }
   )
 })