Update @types/hast, utilities

Author: wooorm

lib/index.js

@@ -1,9 +1,7 @@
 /**
- * @typedef {import('hast').Root} Root
- * @typedef {import('hast').Content} Content
+ * @typedef {import('hast').Nodes} Nodes
  * @typedef {import('hast').Element} Element
  * @typedef {import('hast').Properties} Properties
- * @typedef {Content | Root} Node
  *
  * @typedef {Properties[string]} PropertyValue
  *   Possible property values.
@@ -218,7 +216,7 @@
  *
  * @typedef {(schema: Schema, value: any, node: any, stack: Array<string>) => unknown} Handler
  * @typedef {Record<string, Handler>} NodeDefinition
- * @typedef {((schema: Schema, node: Node) => NodeDefinition | undefined)} NodeDefinitionGetter
+ * @typedef {((schema: Schema, node: Nodes) => NodeDefinition | undefined)} NodeDefinitionGetter
  * @typedef {Record<string, NodeDefinition | NodeDefinitionGetter>} NodeSchema
  */
 
@@ -243,15 +241,15 @@ const nodeSchema = {
 /**
  * Sanitize a tree.
  *
- * @param {Node} node
+ * @param {Nodes} node
  *   Tree to clean.
  * @param {Schema | null | undefined} [schema]
  *   Schema defining how to sanitize.
- * @returns {Node}
+ * @returns {Nodes}
  *   New, sanitized, tree.
  */
 export function sanitize(node, schema) {
-  /** @type {Node} */
+  /** @type {Nodes} */
   let ctx = {type: 'root', children: []}
 
   if (node && typeof node === 'object' && node.type) {
@@ -282,13 +280,13 @@ export function sanitize(node, schema) {
  * Sanitize `node`.
  *
  * @param {Schema} schema
- * @param {Node} node
+ * @param {Nodes} node
  * @param {Array<string>} stack
- * @returns {Node | Array<Node> | undefined}
+ * @returns {Nodes | Array<Nodes> | undefined}
  */
 function one(schema, node, stack) {
   const type = node && node.type
-  /** @type {Node} */
+  /** @type {Nodes} */
   // @ts-expect-error rest of props added later.
   const replacement = {type: node.type}
   /** @type {boolean | undefined} */
@@ -347,12 +345,12 @@ function one(schema, node, stack) {
  * Sanitize `children`.
  *
  * @type {Handler}
- * @param {Array<Node>} children
- * @param {Node} node
- * @returns {Array<Node>}
+ * @param {Array<Nodes>} children
+ * @param {Nodes} node
+ * @returns {Array<Nodes>}
  */
 function all(schema, children, node, stack) {
-  /** @type {Array<Node>} */
+  /** @type {Array<Nodes>} */
   const results = []
 
   if (Array.isArray(children)) {
@@ -467,7 +465,7 @@ function handleDoctypeName() {
  *
  * @param {Schema} schema
  * @param {string} tagName
- * @param {Node} _
+ * @param {Nodes} _
  * @param {Array<string>} stack
  * @returns {string | false}
  */

package.json

@@ -36,20 +36,20 @@
     "index.js"
   ],
   "dependencies": {
-    "@types/hast": "^2.0.0"
+    "@types/hast": "^3.0.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
     "c8": "^8.0.0",
     "deepmerge": "^4.0.0",
     "hast-util-to-html": "^8.0.0",
-    "hastscript": "^7.0.0",
+    "hastscript": "^8.0.0",
     "prettier": "^3.0.0",
     "remark-cli": "^11.0.0",
     "remark-preset-wooorm": "^9.0.0",
     "type-coverage": "^2.0.0",
     "typescript": "^5.0.0",
-    "unist-builder": "^3.0.0",
+    "unist-builder": "^4.0.0",
     "xo": "^0.55.0"
   },
   "scripts": {

test.js

@@ -29,8 +29,10 @@ test('sanitize()', async (t) => {
 
   await t.test('unknown nodes', () => {
     assert.equal(
-      // @ts-expect-error runtime.
-      toHtml(sanitize(u('unknown', '<xml></xml>'))),
+      toHtml(
+        // @ts-expect-error runtime.
+        sanitize(u('unknown', '<xml></xml>'))
+      ),
       '',
       'should ignore unknown nodes'
     )
@@ -47,8 +49,10 @@ test('sanitize()', async (t) => {
     )
 
     assert.equal(
-      // @ts-expect-error runtime.
-      toHtml(sanitize(u('directive', {name: '!alpha'}, '!alpha bravo'))),
+      toHtml(
+        // @ts-expect-error: no longer a hast node.
+        sanitize(u('directive', {name: '!alpha'}, '!alpha bravo'))
+      ),
       '',
       'should ignore declaration `directive`s'
     )
@@ -70,12 +74,14 @@ test('sanitize()', async (t) => {
 
   await t.test('`comment`', () => {
     assert.equal(
+      // @ts-expect-error: remove when `hast-util-to-html` updates.
       toHtml(sanitize(u('comment', 'alpha'))),
       '',
       'should ignore `comment`s by default'
     )
 
     assert.equal(
+      // @ts-expect-error: remove when `hast-util-to-html` updates.
       toHtml(sanitize(u('comment', 'alpha'), {allowComments: true})),
       '<!--alpha-->',
       'should allow `comment`s with `allowComments: true`'
@@ -90,6 +96,7 @@ test('sanitize()', async (t) => {
 
     assert.equal(
       toHtml(
+        // @ts-expect-error: remove when `hast-util-to-html` updates.
         sanitize(u('comment', 'alpha--><script>alert(1)</script><!--bravo'), {
           allowComments: true
         })
@@ -101,13 +108,15 @@ test('sanitize()', async (t) => {
 
   await t.test('`doctype`', () => {
     assert.equal(
+      // @ts-expect-error: remove when `hast-util-to-html` updates.
       toHtml(sanitize(u('doctype', {name: 'html'}, 'alpha'))),
       '',
       'should ignore `doctype`s by default'
     )
 
     assert.equal(
       toHtml(
+        // @ts-expect-error: remove when `hast-util-to-html` updates.
         sanitize(u('doctype', {name: 'html'}, 'alpha'), {allowDoctypes: true})
       ),
       '<!doctype html>',
@@ -144,6 +153,7 @@ test('sanitize()', async (t) => {
     )
 
     assert.equal(
+      // @ts-expect-error: remove when `hast-util-to-html` updates.
       toHtml(sanitize(u('text', 'alert(1)'))),
       'alert(1)',
       'should allow `text`'
@@ -157,12 +167,14 @@ test('sanitize()', async (t) => {
     )
 
     assert.equal(
+      // @ts-expect-error: remove when `hast-util-to-html` updates.
       toHtml(sanitize(h('script', u('text', 'alert(1)')))),
       '',
       'should ignore `text` in `script` elements'
     )
 
     assert.equal(
+      // @ts-expect-error: remove when `hast-util-to-html` updates.
       toHtml(sanitize(h('style', u('text', 'alert(1)')))),
       'alert(1)',
       'should show `text` in `style` elements'