Update @types/mdast

Author: wooorm

lib/index.js

@@ -1,7 +1,7 @@
 /**
- * @typedef {import('mdast').Content} Content
  * @typedef {import('mdast').Heading} Heading
  * @typedef {import('mdast').Root} Root
+ * @typedef {import('mdast').RootContent} RootContent
  * @typedef {import('unist').Node} UnistNode
  * @typedef {import('unist').Parent} UnistParent
  */
@@ -95,13 +95,13 @@
  *   Callback called when a section is found.
  * @param {Heading} start
  *   Start of section (a heading node matching `test`).
- * @param {Array<Content>} between
+ * @param {Array<RootContent>} between
  *   Nodes between `start` and `end`.
- * @param {Content | undefined} end
+ * @param {RootContent | undefined} end
  *   End of section, if any.
  * @param {Info} scope
  *   Extra info.
- * @returns {Array<Content | null | undefined> | null | undefined | void}
+ * @returns {Array<RootContent | null | undefined> | null | undefined | void}
  *   Results.
  *
  *   If nothing is returned, nothing will be changed.
@@ -247,7 +247,7 @@ export function headingRange(tree, options, handler) {
     if (nodes) {
       // Ensure no empty nodes are inserted.
       // This could be the case if `end` is in `nodes` but no `end` node exists.
-      /** @type {Array<Content>} */
+      /** @type {Array<RootContent>} */
       const result = []
       let index = -1
 

package.json

@@ -33,10 +33,10 @@
     "index.js"
   ],
   "dependencies": {
-    "@types/mdast": "^3.0.0",
-    "@types/unist": "^2.0.0",
+    "@types/mdast": "^4.0.0",
+    "@types/unist": "^3.0.0",
     "devlop": "^1.1.0",
-    "mdast-util-to-string": "^3.0.0"
+    "mdast-util-to-string": "^4.0.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

test.js

@@ -11,6 +11,8 @@ import {fromMarkdown} from 'mdast-util-from-markdown'
 import {toMarkdown} from 'mdast-util-to-markdown'
 import {headingRange} from 'mdast-util-heading-range'
 
+// To do: remove casts when `from-markdown` is released.
+
 test('headingRange', async function (t) {
   await t.test('should expose the public api', async function () {
     assert.deepEqual(
@@ -157,13 +159,16 @@ test('headingRange', async function (t) {
   await t.test(
     'should not remove anything when `null` is given',
     async function () {
-      const tree = fromMarkdown(['Foo', '', '## Foo', '', 'Bar', ''].join('\n'))
+      const tree = /** @type {Root} */ (
+        fromMarkdown(['Foo', '', '## Foo', '', 'Bar', ''].join('\n'))
+      )
 
       headingRange(tree, 'foo', function () {
         return null
       })
 
       assert.equal(
+        // @ts-expect-error: remove when `to-markdown` is released.
         toMarkdown(tree),
         ['Foo', '', '## Foo', '', 'Bar', ''].join('\n')
       )
@@ -173,35 +178,46 @@ test('headingRange', async function (t) {
   await t.test(
     'should replace all previous nodes otherwise',
     async function () {
-      const tree = fromMarkdown(['Foo', '', '## Foo', '', 'Bar', ''].join('\n'))
+      const tree = /** @type {Root} */ (
+        fromMarkdown(['Foo', '', '## Foo', '', 'Bar', ''].join('\n'))
+      )
 
       headingRange(tree, 'foo', function () {
         return []
       })
 
-      assert.equal(toMarkdown(tree), ['Foo', ''].join('\n'))
+      assert.equal(
+        // @ts-expect-error: remove when `to-markdown` is released.
+        toMarkdown(tree),
+        ['Foo', ''].join('\n')
+      )
     }
   )
 
   await t.test('should insert all returned nodes', async function () {
-    const tree = fromMarkdown(
-      ['Foo', '', '## Foo', '', 'Bar', '', '## Baz', ''].join('\n')
+    const tree = /** @type {Root} */ (
+      fromMarkdown(
+        ['Foo', '', '## Foo', '', 'Bar', '', '## Baz', ''].join('\n')
+      )
     )
 
     headingRange(tree, 'foo', function (start, _, end) {
       return [start, {type: 'thematicBreak'}, end]
     })
 
     assert.equal(
+      // @ts-expect-error: remove when `to-markdown` is released.
       toMarkdown(tree),
       ['Foo', '', '## Foo', '', '***', '', '## Baz', ''].join('\n')
     )
   })
 
   await t.test('should not insert an empty `end`', async function () {
-    const tree = fromMarkdown(
-      ['# Alpha', '', '## Foo', '', 'one', '', 'two', '', 'three', ''].join(
-        '\n'
+    const tree = /** @type {Root} */ (
+      fromMarkdown(
+        ['# Alpha', '', '## Foo', '', 'one', '', 'two', '', 'three', ''].join(
+          '\n'
+        )
       )
     )
 
@@ -211,6 +227,7 @@ test('headingRange', async function (t) {
     })
 
     assert.equal(
+      // @ts-expect-error: remove when `to-markdown` is released.
       toMarkdown(tree),
       ['# Alpha', '', '## Foo', '', 'one', '', 'two', '', 'three', ''].join(
         '\n'
@@ -335,7 +352,7 @@ test('headingRange', async function (t) {
  *   Output markdown.
  */
 function checkAndRemove(value, options) {
-  const tree = fromMarkdown(value)
+  const tree = /** @type {Root} */ (fromMarkdown(value))
 
   headingRange(tree, options, function (start, _, end, scope) {
     assert.equal(typeof scope.start, 'number')
@@ -344,5 +361,6 @@ function checkAndRemove(value, options) {
     return [start, end]
   })
 
+  // @ts-expect-error: remove when `to-markdown` is released.
   return toMarkdown(tree)
 }