Refactor routing in App component to enhance navigation and improve error handling by integrating dynamic routes and updating the NotFound route.

node_modules/mdast-util-to-hast/lib/footer.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Generate the default content that GitHub uses on backreferences.
+ *
+ * @param {number} _
+ *   Index of the definition in the order that they are first referenced,
+ *   0-indexed.
+ * @param {number} rereferenceIndex
+ *   Index of calls to the same definition, 0-indexed.
+ * @returns {Array<ElementContent>}
+ *   Content.
+ */
+export function defaultFootnoteBackContent(_: number, rereferenceIndex: number): Array<ElementContent>;
+/**
+ * Generate the default label that GitHub uses on backreferences.
+ *
+ * @param {number} referenceIndex
+ *   Index of the definition in the order that they are first referenced,
+ *   0-indexed.
+ * @param {number} rereferenceIndex
+ *   Index of calls to the same definition, 0-indexed.
+ * @returns {string}
+ *   Label.
+ */
+export function defaultFootnoteBackLabel(referenceIndex: number, rereferenceIndex: number): string;
+/**
+ * Generate a hast footer for called footnote definitions.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @returns {Element | undefined}
+ *   `section` element or `undefined`.
+ */
+export function footer(state: State): Element | undefined;
+export type Element = import("hast").Element;
+export type ElementContent = import("hast").ElementContent;
+export type State = import("./state.js").State;
+/**
+ * Generate content for the backreference dynamically.
+ *
+ * For the following markdown:
+ *
+ * ```markdown
+ * Alpha[^micromark], bravo[^micromark], and charlie[^remark].
+ *
+ * [^remark]: things about remark
+ * [^micromark]: things about micromark
+ * ```
+ *
+ * This function will be called with:
+ *
+ * *  `0` and `0` for the backreference from `things about micromark` to
+ *  `alpha`, as it is the first used definition, and the first call to it
+ * *  `0` and `1` for the backreference from `things about micromark` to
+ *  `bravo`, as it is the first used definition, and the second call to it
+ * *  `1` and `0` for the backreference from `things about remark` to
+ *  `charlie`, as it is the second used definition
+ */
+export type FootnoteBackContentTemplate = (referenceIndex: number, rereferenceIndex: number) => Array<ElementContent> | ElementContent | string;
+/**
+ * Generate a back label dynamically.
+ *
+ * For the following markdown:
+ *
+ * ```markdown
+ * Alpha[^micromark], bravo[^micromark], and charlie[^remark].
+ *
+ * [^remark]: things about remark
+ * [^micromark]: things about micromark
+ * ```
+ *
+ * This function will be called with:
+ *
+ * *  `0` and `0` for the backreference from `things about micromark` to
+ *  `alpha`, as it is the first used definition, and the first call to it
+ * *  `0` and `1` for the backreference from `things about micromark` to
+ *  `bravo`, as it is the first used definition, and the second call to it
+ * *  `1` and `0` for the backreference from `things about remark` to
+ *  `charlie`, as it is the second used definition
+ */
+export type FootnoteBackLabelTemplate = (referenceIndex: number, rereferenceIndex: number) => string;

node_modules/mdast-util-to-hast/lib/footer.js

@@ -0,0 +1,252 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').ElementContent} ElementContent
+ *
+ * @typedef {import('./state.js').State} State
+ */
+
+/**
+ * @callback FootnoteBackContentTemplate
+ *   Generate content for the backreference dynamically.
+ *
+ *   For the following markdown:
+ *
+ *   ```markdown
+ *   Alpha[^micromark], bravo[^micromark], and charlie[^remark].
+ *
+ *   [^remark]: things about remark
+ *   [^micromark]: things about micromark
+ *   ```
+ *
+ *   This function will be called with:
+ *
+ *   *  `0` and `0` for the backreference from `things about micromark` to
+ *      `alpha`, as it is the first used definition, and the first call to it
+ *   *  `0` and `1` for the backreference from `things about micromark` to
+ *      `bravo`, as it is the first used definition, and the second call to it
+ *   *  `1` and `0` for the backreference from `things about remark` to
+ *      `charlie`, as it is the second used definition
+ * @param {number} referenceIndex
+ *   Index of the definition in the order that they are first referenced,
+ *   0-indexed.
+ * @param {number} rereferenceIndex
+ *   Index of calls to the same definition, 0-indexed.
+ * @returns {Array<ElementContent> | ElementContent | string}
+ *   Content for the backreference when linking back from definitions to their
+ *   reference.
+ *
+ * @callback FootnoteBackLabelTemplate
+ *   Generate a back label dynamically.
+ *
+ *   For the following markdown:
+ *
+ *   ```markdown
+ *   Alpha[^micromark], bravo[^micromark], and charlie[^remark].
+ *
+ *   [^remark]: things about remark
+ *   [^micromark]: things about micromark
+ *   ```
+ *
+ *   This function will be called with:
+ *
+ *   *  `0` and `0` for the backreference from `things about micromark` to
+ *      `alpha`, as it is the first used definition, and the first call to it
+ *   *  `0` and `1` for the backreference from `things about micromark` to
+ *      `bravo`, as it is the first used definition, and the second call to it
+ *   *  `1` and `0` for the backreference from `things about remark` to
+ *      `charlie`, as it is the second used definition
+ * @param {number} referenceIndex
+ *   Index of the definition in the order that they are first referenced,
+ *   0-indexed.
+ * @param {number} rereferenceIndex
+ *   Index of calls to the same definition, 0-indexed.
+ * @returns {string}
+ *   Back label to use when linking back from definitions to their reference.
+ */
+
+import structuredClone from '@ungap/structured-clone'
+import {normalizeUri} from 'micromark-util-sanitize-uri'
+
+/**
+ * Generate the default content that GitHub uses on backreferences.
+ *
+ * @param {number} _
+ *   Index of the definition in the order that they are first referenced,
+ *   0-indexed.
+ * @param {number} rereferenceIndex
+ *   Index of calls to the same definition, 0-indexed.
+ * @returns {Array<ElementContent>}
+ *   Content.
+ */
+export function defaultFootnoteBackContent(_, rereferenceIndex) {
+  /** @type {Array<ElementContent>} */
+  const result = [{type: 'text', value: '↩'}]
+
+  if (rereferenceIndex > 1) {
+    result.push({
+      type: 'element',
+      tagName: 'sup',
+      properties: {},
+      children: [{type: 'text', value: String(rereferenceIndex)}]
+    })
+  }
+
+  return result
+}
+
+/**
+ * Generate the default label that GitHub uses on backreferences.
+ *
+ * @param {number} referenceIndex
+ *   Index of the definition in the order that they are first referenced,
+ *   0-indexed.
+ * @param {number} rereferenceIndex
+ *   Index of calls to the same definition, 0-indexed.
+ * @returns {string}
+ *   Label.
+ */
+export function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {
+  return (
+    'Back to reference ' +
+    (referenceIndex + 1) +
+    (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')
+  )
+}
+
+/**
+ * Generate a hast footer for called footnote definitions.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @returns {Element | undefined}
+ *   `section` element or `undefined`.
+ */
+// eslint-disable-next-line complexity
+export function footer(state) {
+  const clobberPrefix =
+    typeof state.options.clobberPrefix === 'string'
+      ? state.options.clobberPrefix
+      : 'user-content-'
+  const footnoteBackContent =
+    state.options.footnoteBackContent || defaultFootnoteBackContent
+  const footnoteBackLabel =
+    state.options.footnoteBackLabel || defaultFootnoteBackLabel
+  const footnoteLabel = state.options.footnoteLabel || 'Footnotes'
+  const footnoteLabelTagName = state.options.footnoteLabelTagName || 'h2'
+  const footnoteLabelProperties = state.options.footnoteLabelProperties || {
+    className: ['sr-only']
+  }
+  /** @type {Array<ElementContent>} */
+  const listItems = []
+  let referenceIndex = -1
+
+  while (++referenceIndex < state.footnoteOrder.length) {
+    const definition = state.footnoteById.get(
+      state.footnoteOrder[referenceIndex]
+    )
+
+    if (!definition) {
+      continue
+    }
+
+    const content = state.all(definition)
+    const id = String(definition.identifier).toUpperCase()
+    const safeId = normalizeUri(id.toLowerCase())
+    let rereferenceIndex = 0
+    /** @type {Array<ElementContent>} */
+    const backReferences = []
+    const counts = state.footnoteCounts.get(id)
+
+    // eslint-disable-next-line no-unmodified-loop-condition
+    while (counts !== undefined && ++rereferenceIndex <= counts) {
+      if (backReferences.length > 0) {
+        backReferences.push({type: 'text', value: ' '})
+      }
+
+      let children =
+        typeof footnoteBackContent === 'string'
+          ? footnoteBackContent
+          : footnoteBackContent(referenceIndex, rereferenceIndex)
+
+      if (typeof children === 'string') {
+        children = {type: 'text', value: children}
+      }
+
+      backReferences.push({
+        type: 'element',
+        tagName: 'a',
+        properties: {
+          href:
+            '#' +
+            clobberPrefix +
+            'fnref-' +
+            safeId +
+            (rereferenceIndex > 1 ? '-' + rereferenceIndex : ''),
+          dataFootnoteBackref: '',
+          ariaLabel:
+            typeof footnoteBackLabel === 'string'
+              ? footnoteBackLabel
+              : footnoteBackLabel(referenceIndex, rereferenceIndex),
+          className: ['data-footnote-backref']
+        },
+        children: Array.isArray(children) ? children : [children]
+      })
+    }
+
+    const tail = content[content.length - 1]
+
+    if (tail && tail.type === 'element' && tail.tagName === 'p') {
+      const tailTail = tail.children[tail.children.length - 1]
+      if (tailTail && tailTail.type === 'text') {
+        tailTail.value += ' '
+      } else {
+        tail.children.push({type: 'text', value: ' '})
+      }
+
+      tail.children.push(...backReferences)
+    } else {
+      content.push(...backReferences)
+    }
+
+    /** @type {Element} */
+    const listItem = {
+      type: 'element',
+      tagName: 'li',
+      properties: {id: clobberPrefix + 'fn-' + safeId},
+      children: state.wrap(content, true)
+    }
+
+    state.patch(definition, listItem)
+
+    listItems.push(listItem)
+  }
+
+  if (listItems.length === 0) {
+    return
+  }
+
+  return {
+    type: 'element',
+    tagName: 'section',
+    properties: {dataFootnotes: true, className: ['footnotes']},
+    children: [
+      {
+        type: 'element',
+        tagName: footnoteLabelTagName,
+        properties: {
+          ...structuredClone(footnoteLabelProperties),
+          id: 'footnote-label'
+        },
+        children: [{type: 'text', value: footnoteLabel}]
+      },
+      {type: 'text', value: '\n'},
+      {
+        type: 'element',
+        tagName: 'ol',
+        properties: {},
+        children: state.wrap(listItems, true)
+      },
+      {type: 'text', value: '\n'}
+    ]
+  }
+}

node_modules/mdast-util-to-hast/lib/handlers/blockquote.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Turn an mdast `blockquote` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Blockquote} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function blockquote(state: State, node: Blockquote): Element;
+export type Element = import("hast").Element;
+export type Blockquote = import("mdast").Blockquote;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/blockquote.js

@@ -0,0 +1,30 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Blockquote} Blockquote
+ * @typedef {import('../state.js').State} State
+ */
+
+// Make VS Code show references to the above types.
+''
+
+/**
+ * Turn an mdast `blockquote` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Blockquote} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function blockquote(state, node) {
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'blockquote',
+    properties: {},
+    children: state.wrap(state.all(node), true)
+  }
+  state.patch(node, result)
+  return state.applyData(node, result)
+}

node_modules/mdast-util-to-hast/lib/handlers/break.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Turn an mdast `break` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Break} node
+ *   mdast node.
+ * @returns {Array<Element | Text>}
+ *   hast element content.
+ */
+export function hardBreak(state: State, node: Break): Array<Element | Text>;
+export type Element = import("hast").Element;
+export type Text = import("hast").Text;
+export type Break = import("mdast").Break;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/break.js

@@ -0,0 +1,26 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').Text} Text
+ * @typedef {import('mdast').Break} Break
+ * @typedef {import('../state.js').State} State
+ */
+
+// Make VS Code show references to the above types.
+''
+
+/**
+ * Turn an mdast `break` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Break} node
+ *   mdast node.
+ * @returns {Array<Element | Text>}
+ *   hast element content.
+ */
+export function hardBreak(state, node) {
+  /** @type {Element} */
+  const result = {type: 'element', tagName: 'br', properties: {}, children: []}
+  state.patch(node, result)
+  return [state.applyData(node, result), {type: 'text', value: '\n'}]
+}

node_modules/mdast-util-to-hast/lib/handlers/code.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Turn an mdast `code` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Code} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function code(state: State, node: Code): Element;
+export type Element = import("hast").Element;
+export type Properties = import("hast").Properties;
+export type Code = import("mdast").Code;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/code.js

@@ -0,0 +1,50 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').Code} Code
+ * @typedef {import('../state.js').State} State
+ */
+
+// Make VS Code show references to the above types.
+''
+
+/**
+ * Turn an mdast `code` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Code} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function code(state, node) {
+  const value = node.value ? node.value + '\n' : ''
+  /** @type {Properties} */
+  const properties = {}
+
+  if (node.lang) {
+    properties.className = ['language-' + node.lang]
+  }
+
+  // Create `<code>`.
+  /** @type {Element} */
+  let result = {
+    type: 'element',
+    tagName: 'code',
+    properties,
+    children: [{type: 'text', value}]
+  }
+
+  if (node.meta) {
+    result.data = {meta: node.meta}
+  }
+
+  state.patch(node, result)
+  result = state.applyData(node, result)
+
+  // Create `<pre>`.
+  result = {type: 'element', tagName: 'pre', properties: {}, children: [result]}
+  state.patch(node, result)
+  return result
+}

node_modules/mdast-util-to-hast/lib/handlers/delete.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Turn an mdast `delete` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Delete} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function strikethrough(state: State, node: Delete): Element;
+export type Element = import("hast").Element;
+export type Delete = import("mdast").Delete;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/delete.js

@@ -0,0 +1,30 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Delete} Delete
+ * @typedef {import('../state.js').State} State
+ */
+
+// Make VS Code show references to the above types.
+''
+
+/**
+ * Turn an mdast `delete` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Delete} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function strikethrough(state, node) {
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'del',
+    properties: {},
+    children: state.all(node)
+  }
+  state.patch(node, result)
+  return state.applyData(node, result)
+}

node_modules/mdast-util-to-hast/lib/handlers/emphasis.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Turn an mdast `emphasis` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Emphasis} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function emphasis(state: State, node: Emphasis): Element;
+export type Element = import("hast").Element;
+export type Emphasis = import("mdast").Emphasis;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/emphasis.js

@@ -0,0 +1,30 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Emphasis} Emphasis
+ * @typedef {import('../state.js').State} State
+ */
+
+// Make VS Code show references to the above types.
+''
+
+/**
+ * Turn an mdast `emphasis` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Emphasis} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function emphasis(state, node) {
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'em',
+    properties: {},
+    children: state.all(node)
+  }
+  state.patch(node, result)
+  return state.applyData(node, result)
+}

node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Turn an mdast `footnoteReference` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {FootnoteReference} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function footnoteReference(state: State, node: FootnoteReference): Element;
+export type Element = import("hast").Element;
+export type FootnoteReference = import("mdast").FootnoteReference;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js

@@ -0,0 +1,70 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').FootnoteReference} FootnoteReference
+ * @typedef {import('../state.js').State} State
+ */
+
+import {normalizeUri} from 'micromark-util-sanitize-uri'
+
+/**
+ * Turn an mdast `footnoteReference` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {FootnoteReference} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function footnoteReference(state, node) {
+  const clobberPrefix =
+    typeof state.options.clobberPrefix === 'string'
+      ? state.options.clobberPrefix
+      : 'user-content-'
+  const id = String(node.identifier).toUpperCase()
+  const safeId = normalizeUri(id.toLowerCase())
+  const index = state.footnoteOrder.indexOf(id)
+  /** @type {number} */
+  let counter
+
+  let reuseCounter = state.footnoteCounts.get(id)
+
+  if (reuseCounter === undefined) {
+    reuseCounter = 0
+    state.footnoteOrder.push(id)
+    counter = state.footnoteOrder.length
+  } else {
+    counter = index + 1
+  }
+
+  reuseCounter += 1
+  state.footnoteCounts.set(id, reuseCounter)
+
+  /** @type {Element} */
+  const link = {
+    type: 'element',
+    tagName: 'a',
+    properties: {
+      href: '#' + clobberPrefix + 'fn-' + safeId,
+      id:
+        clobberPrefix +
+        'fnref-' +
+        safeId +
+        (reuseCounter > 1 ? '-' + reuseCounter : ''),
+      dataFootnoteRef: true,
+      ariaDescribedBy: ['footnote-label']
+    },
+    children: [{type: 'text', value: String(counter)}]
+  }
+  state.patch(node, link)
+
+  /** @type {Element} */
+  const sup = {
+    type: 'element',
+    tagName: 'sup',
+    properties: {},
+    children: [link]
+  }
+  state.patch(node, sup)
+  return state.applyData(node, sup)
+}

node_modules/mdast-util-to-hast/lib/handlers/heading.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Turn an mdast `heading` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Heading} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function heading(state: State, node: Heading): Element;
+export type Element = import("hast").Element;
+export type Heading = import("mdast").Heading;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/heading.js

@@ -0,0 +1,30 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Heading} Heading
+ * @typedef {import('../state.js').State} State
+ */
+
+// Make VS Code show references to the above types.
+''
+
+/**
+ * Turn an mdast `heading` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Heading} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function heading(state, node) {
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'h' + node.depth,
+    properties: {},
+    children: state.all(node)
+  }
+  state.patch(node, result)
+  return state.applyData(node, result)
+}

node_modules/mdast-util-to-hast/lib/handlers/html.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Turn an mdast `html` node into hast (`raw` node in dangerous mode, otherwise
+ * nothing).
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Html} node
+ *   mdast node.
+ * @returns {Element | Raw | undefined}
+ *   hast node.
+ */
+export function html(state: State, node: Html): Element | Raw | undefined;
+export type Element = import("hast").Element;
+export type Html = import("mdast").Html;
+export type State = import("../state.js").State;
+export type Raw = import("../../index.js").Raw;

node_modules/mdast-util-to-hast/lib/handlers/html.js

@@ -0,0 +1,31 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Html} Html
+ * @typedef {import('../state.js').State} State
+ * @typedef {import('../../index.js').Raw} Raw
+ */
+
+// Make VS Code show references to the above types.
+''
+
+/**
+ * Turn an mdast `html` node into hast (`raw` node in dangerous mode, otherwise
+ * nothing).
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Html} node
+ *   mdast node.
+ * @returns {Element | Raw | undefined}
+ *   hast node.
+ */
+export function html(state, node) {
+  if (state.options.allowDangerousHtml) {
+    /** @type {Raw} */
+    const result = {type: 'raw', value: node.value}
+    state.patch(node, result)
+    return state.applyData(node, result)
+  }
+
+  return undefined
+}

node_modules/mdast-util-to-hast/lib/handlers/image-reference.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Turn an mdast `imageReference` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {ImageReference} node
+ *   mdast node.
+ * @returns {Array<ElementContent> | ElementContent}
+ *   hast node.
+ */
+export function imageReference(state: State, node: ImageReference): Array<ElementContent> | ElementContent;
+export type Element = import("hast").Element;
+export type ElementContent = import("hast").ElementContent;
+export type Properties = import("hast").Properties;
+export type ImageReference = import("mdast").ImageReference;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/image-reference.js

@@ -0,0 +1,41 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').ElementContent} ElementContent
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').ImageReference} ImageReference
+ * @typedef {import('../state.js').State} State
+ */
+
+import {normalizeUri} from 'micromark-util-sanitize-uri'
+import {revert} from '../revert.js'
+
+/**
+ * Turn an mdast `imageReference` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {ImageReference} node
+ *   mdast node.
+ * @returns {Array<ElementContent> | ElementContent}
+ *   hast node.
+ */
+export function imageReference(state, node) {
+  const id = String(node.identifier).toUpperCase()
+  const definition = state.definitionById.get(id)
+
+  if (!definition) {
+    return revert(state, node)
+  }
+
+  /** @type {Properties} */
+  const properties = {src: normalizeUri(definition.url || ''), alt: node.alt}
+
+  if (definition.title !== null && definition.title !== undefined) {
+    properties.title = definition.title
+  }
+
+  /** @type {Element} */
+  const result = {type: 'element', tagName: 'img', properties, children: []}
+  state.patch(node, result)
+  return state.applyData(node, result)
+}

node_modules/mdast-util-to-hast/lib/handlers/image.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Turn an mdast `image` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Image} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function image(state: State, node: Image): Element;
+export type Element = import("hast").Element;
+export type Properties = import("hast").Properties;
+export type Image = import("mdast").Image;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/image.js

@@ -0,0 +1,36 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').Image} Image
+ * @typedef {import('../state.js').State} State
+ */
+
+import {normalizeUri} from 'micromark-util-sanitize-uri'
+
+/**
+ * Turn an mdast `image` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Image} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function image(state, node) {
+  /** @type {Properties} */
+  const properties = {src: normalizeUri(node.url)}
+
+  if (node.alt !== null && node.alt !== undefined) {
+    properties.alt = node.alt
+  }
+
+  if (node.title !== null && node.title !== undefined) {
+    properties.title = node.title
+  }
+
+  /** @type {Element} */
+  const result = {type: 'element', tagName: 'img', properties, children: []}
+  state.patch(node, result)
+  return state.applyData(node, result)
+}

node_modules/mdast-util-to-hast/lib/handlers/index.d.ts

@@ -0,0 +1,54 @@
+export namespace handlers {
+    export { blockquote };
+    export { hardBreak as break };
+    export { code };
+    export { strikethrough as delete };
+    export { emphasis };
+    export { footnoteReference };
+    export { heading };
+    export { html };
+    export { imageReference };
+    export { image };
+    export { inlineCode };
+    export { linkReference };
+    export { link };
+    export { listItem };
+    export { list };
+    export { paragraph };
+    export { root };
+    export { strong };
+    export { table };
+    export { tableCell };
+    export { tableRow };
+    export { text };
+    export { thematicBreak };
+    export { ignore as toml };
+    export { ignore as yaml };
+    export { ignore as definition };
+    export { ignore as footnoteDefinition };
+}
+import { blockquote } from './blockquote.js';
+import { hardBreak } from './break.js';
+import { code } from './code.js';
+import { strikethrough } from './delete.js';
+import { emphasis } from './emphasis.js';
+import { footnoteReference } from './footnote-reference.js';
+import { heading } from './heading.js';
+import { html } from './html.js';
+import { imageReference } from './image-reference.js';
+import { image } from './image.js';
+import { inlineCode } from './inline-code.js';
+import { linkReference } from './link-reference.js';
+import { link } from './link.js';
+import { listItem } from './list-item.js';
+import { list } from './list.js';
+import { paragraph } from './paragraph.js';
+import { root } from './root.js';
+import { strong } from './strong.js';
+import { table } from './table.js';
+import { tableCell } from './table-cell.js';
+import { tableRow } from './table-row.js';
+import { text } from './text.js';
+import { thematicBreak } from './thematic-break.js';
+declare function ignore(): undefined;
+export {};

node_modules/mdast-util-to-hast/lib/handlers/index.js

@@ -0,0 +1,64 @@
+import {blockquote} from './blockquote.js'
+import {hardBreak} from './break.js'
+import {code} from './code.js'
+import {strikethrough} from './delete.js'
+import {emphasis} from './emphasis.js'
+import {footnoteReference} from './footnote-reference.js'
+import {heading} from './heading.js'
+import {html} from './html.js'
+import {imageReference} from './image-reference.js'
+import {image} from './image.js'
+import {inlineCode} from './inline-code.js'
+import {linkReference} from './link-reference.js'
+import {link} from './link.js'
+import {listItem} from './list-item.js'
+import {list} from './list.js'
+import {paragraph} from './paragraph.js'
+import {root} from './root.js'
+import {strong} from './strong.js'
+import {table} from './table.js'
+import {tableRow} from './table-row.js'
+import {tableCell} from './table-cell.js'
+import {text} from './text.js'
+import {thematicBreak} from './thematic-break.js'
+
+/**
+ * Default handlers for nodes.
+ *
+ * @satisfies {import('../state.js').Handlers}
+ */
+export const handlers = {
+  blockquote,
+  break: hardBreak,
+  code,
+  delete: strikethrough,
+  emphasis,
+  footnoteReference,
+  heading,
+  html,
+  imageReference,
+  image,
+  inlineCode,
+  linkReference,
+  link,
+  listItem,
+  list,
+  paragraph,
+  // @ts-expect-error: root is different, but hard to type.
+  root,
+  strong,
+  table,
+  tableCell,
+  tableRow,
+  text,
+  thematicBreak,
+  toml: ignore,
+  yaml: ignore,
+  definition: ignore,
+  footnoteDefinition: ignore
+}
+
+// Return nothing for nodes that are ignored.
+function ignore() {
+  return undefined
+}

node_modules/mdast-util-to-hast/lib/handlers/inline-code.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Turn an mdast `inlineCode` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {InlineCode} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function inlineCode(state: State, node: InlineCode): Element;
+export type Element = import("hast").Element;
+export type Text = import("hast").Text;
+export type InlineCode = import("mdast").InlineCode;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/inline-code.js

@@ -0,0 +1,35 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').Text} Text
+ * @typedef {import('mdast').InlineCode} InlineCode
+ * @typedef {import('../state.js').State} State
+ */
+
+// Make VS Code show references to the above types.
+''
+
+/**
+ * Turn an mdast `inlineCode` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {InlineCode} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function inlineCode(state, node) {
+  /** @type {Text} */
+  const text = {type: 'text', value: node.value.replace(/\r?\n|\r/g, ' ')}
+  state.patch(node, text)
+
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'code',
+    properties: {},
+    children: [text]
+  }
+  state.patch(node, result)
+  return state.applyData(node, result)
+}

node_modules/mdast-util-to-hast/lib/handlers/link-reference.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Turn an mdast `linkReference` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {LinkReference} node
+ *   mdast node.
+ * @returns {Array<ElementContent> | ElementContent}
+ *   hast node.
+ */
+export function linkReference(state: State, node: LinkReference): Array<ElementContent> | ElementContent;
+export type Element = import("hast").Element;
+export type ElementContent = import("hast").ElementContent;
+export type Properties = import("hast").Properties;
+export type LinkReference = import("mdast").LinkReference;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/link-reference.js

@@ -0,0 +1,46 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').ElementContent} ElementContent
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').LinkReference} LinkReference
+ * @typedef {import('../state.js').State} State
+ */
+
+import {normalizeUri} from 'micromark-util-sanitize-uri'
+import {revert} from '../revert.js'
+
+/**
+ * Turn an mdast `linkReference` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {LinkReference} node
+ *   mdast node.
+ * @returns {Array<ElementContent> | ElementContent}
+ *   hast node.
+ */
+export function linkReference(state, node) {
+  const id = String(node.identifier).toUpperCase()
+  const definition = state.definitionById.get(id)
+
+  if (!definition) {
+    return revert(state, node)
+  }
+
+  /** @type {Properties} */
+  const properties = {href: normalizeUri(definition.url || '')}
+
+  if (definition.title !== null && definition.title !== undefined) {
+    properties.title = definition.title
+  }
+
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'a',
+    properties,
+    children: state.all(node)
+  }
+  state.patch(node, result)
+  return state.applyData(node, result)
+}

node_modules/mdast-util-to-hast/lib/handlers/link.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Turn an mdast `link` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Link} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function link(state: State, node: Link): Element;
+export type Element = import("hast").Element;
+export type Properties = import("hast").Properties;
+export type Link = import("mdast").Link;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/link.js

@@ -0,0 +1,37 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').Link} Link
+ * @typedef {import('../state.js').State} State
+ */
+
+import {normalizeUri} from 'micromark-util-sanitize-uri'
+
+/**
+ * Turn an mdast `link` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Link} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function link(state, node) {
+  /** @type {Properties} */
+  const properties = {href: normalizeUri(node.url)}
+
+  if (node.title !== null && node.title !== undefined) {
+    properties.title = node.title
+  }
+
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'a',
+    properties,
+    children: state.all(node)
+  }
+  state.patch(node, result)
+  return state.applyData(node, result)
+}

node_modules/mdast-util-to-hast/lib/handlers/list-item.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Turn an mdast `listItem` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {ListItem} node
+ *   mdast node.
+ * @param {Parents | undefined} parent
+ *   Parent of `node`.
+ * @returns {Element}
+ *   hast node.
+ */
+export function listItem(state: State, node: ListItem, parent: Parents | undefined): Element;
+export type Element = import("hast").Element;
+export type ElementContent = import("hast").ElementContent;
+export type Properties = import("hast").Properties;
+export type ListItem = import("mdast").ListItem;
+export type Parents = import("mdast").Parents;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/list-item.js

@@ -0,0 +1,125 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').ElementContent} ElementContent
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').ListItem} ListItem
+ * @typedef {import('mdast').Parents} Parents
+ * @typedef {import('../state.js').State} State
+ */
+
+// Make VS Code show references to the above types.
+''
+
+/**
+ * Turn an mdast `listItem` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {ListItem} node
+ *   mdast node.
+ * @param {Parents | undefined} parent
+ *   Parent of `node`.
+ * @returns {Element}
+ *   hast node.
+ */
+export function listItem(state, node, parent) {
+  const results = state.all(node)
+  const loose = parent ? listLoose(parent) : listItemLoose(node)
+  /** @type {Properties} */
+  const properties = {}
+  /** @type {Array<ElementContent>} */
+  const children = []
+
+  if (typeof node.checked === 'boolean') {
+    const head = results[0]
+    /** @type {Element} */
+    let paragraph
+
+    if (head && head.type === 'element' && head.tagName === 'p') {
+      paragraph = head
+    } else {
+      paragraph = {type: 'element', tagName: 'p', properties: {}, children: []}
+      results.unshift(paragraph)
+    }
+
+    if (paragraph.children.length > 0) {
+      paragraph.children.unshift({type: 'text', value: ' '})
+    }
+
+    paragraph.children.unshift({
+      type: 'element',
+      tagName: 'input',
+      properties: {type: 'checkbox', checked: node.checked, disabled: true},
+      children: []
+    })
+
+    // According to github-markdown-css, this class hides bullet.
+    // See: <https://github.com/sindresorhus/github-markdown-css>.
+    properties.className = ['task-list-item']
+  }
+
+  let index = -1
+
+  while (++index < results.length) {
+    const child = results[index]
+
+    // Add eols before nodes, except if this is a loose, first paragraph.
+    if (
+      loose ||
+      index !== 0 ||
+      child.type !== 'element' ||
+      child.tagName !== 'p'
+    ) {
+      children.push({type: 'text', value: '\n'})
+    }
+
+    if (child.type === 'element' && child.tagName === 'p' && !loose) {
+      children.push(...child.children)
+    } else {
+      children.push(child)
+    }
+  }
+
+  const tail = results[results.length - 1]
+
+  // Add a final eol.
+  if (tail && (loose || tail.type !== 'element' || tail.tagName !== 'p')) {
+    children.push({type: 'text', value: '\n'})
+  }
+
+  /** @type {Element} */
+  const result = {type: 'element', tagName: 'li', properties, children}
+  state.patch(node, result)
+  return state.applyData(node, result)
+}
+
+/**
+ * @param {Parents} node
+ * @return {Boolean}
+ */
+function listLoose(node) {
+  let loose = false
+  if (node.type === 'list') {
+    loose = node.spread || false
+    const children = node.children
+    let index = -1
+
+    while (!loose && ++index < children.length) {
+      loose = listItemLoose(children[index])
+    }
+  }
+
+  return loose
+}
+
+/**
+ * @param {ListItem} node
+ * @return {Boolean}
+ */
+function listItemLoose(node) {
+  const spread = node.spread
+
+  return spread === null || spread === undefined
+    ? node.children.length > 1
+    : spread
+}

node_modules/mdast-util-to-hast/lib/handlers/list.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Turn an mdast `list` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {List} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function list(state: State, node: List): Element;
+export type Element = import("hast").Element;
+export type Properties = import("hast").Properties;
+export type List = import("mdast").List;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/list.js

@@ -0,0 +1,56 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').List} List
+ * @typedef {import('../state.js').State} State
+ */
+
+// Make VS Code show references to the above types.
+''
+
+/**
+ * Turn an mdast `list` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {List} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function list(state, node) {
+  /** @type {Properties} */
+  const properties = {}
+  const results = state.all(node)
+  let index = -1
+
+  if (typeof node.start === 'number' && node.start !== 1) {
+    properties.start = node.start
+  }
+
+  // Like GitHub, add a class for custom styling.
+  while (++index < results.length) {
+    const child = results[index]
+
+    if (
+      child.type === 'element' &&
+      child.tagName === 'li' &&
+      child.properties &&
+      Array.isArray(child.properties.className) &&
+      child.properties.className.includes('task-list-item')
+    ) {
+      properties.className = ['contains-task-list']
+      break
+    }
+  }
+
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: node.ordered ? 'ol' : 'ul',
+    properties,
+    children: state.wrap(results, true)
+  }
+  state.patch(node, result)
+  return state.applyData(node, result)
+}

node_modules/mdast-util-to-hast/lib/handlers/paragraph.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Turn an mdast `paragraph` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Paragraph} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function paragraph(state: State, node: Paragraph): Element;
+export type Element = import("hast").Element;
+export type Paragraph = import("mdast").Paragraph;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/paragraph.js

@@ -0,0 +1,30 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Paragraph} Paragraph
+ * @typedef {import('../state.js').State} State
+ */
+
+// Make VS Code show references to the above types.
+''
+
+/**
+ * Turn an mdast `paragraph` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Paragraph} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function paragraph(state, node) {
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'p',
+    properties: {},
+    children: state.all(node)
+  }
+  state.patch(node, result)
+  return state.applyData(node, result)
+}

node_modules/mdast-util-to-hast/lib/handlers/root.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Turn an mdast `root` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {MdastRoot} node
+ *   mdast node.
+ * @returns {HastParents}
+ *   hast node.
+ */
+export function root(state: State, node: MdastRoot): HastParents;
+export type HastParents = import("hast").Parents;
+export type HastRoot = import("hast").Root;
+export type MdastRoot = import("mdast").Root;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/root.js

@@ -0,0 +1,26 @@
+/**
+ * @typedef {import('hast').Parents} HastParents
+ * @typedef {import('hast').Root} HastRoot
+ * @typedef {import('mdast').Root} MdastRoot
+ * @typedef {import('../state.js').State} State
+ */
+
+// Make VS Code show references to the above types.
+''
+
+/**
+ * Turn an mdast `root` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {MdastRoot} node
+ *   mdast node.
+ * @returns {HastParents}
+ *   hast node.
+ */
+export function root(state, node) {
+  /** @type {HastRoot} */
+  const result = {type: 'root', children: state.wrap(state.all(node))}
+  state.patch(node, result)
+  return state.applyData(node, result)
+}

node_modules/mdast-util-to-hast/lib/handlers/strong.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Turn an mdast `strong` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Strong} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function strong(state: State, node: Strong): Element;
+export type Element = import("hast").Element;
+export type Strong = import("mdast").Strong;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/strong.js

@@ -0,0 +1,30 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Strong} Strong
+ * @typedef {import('../state.js').State} State
+ */
+
+// Make VS Code show references to the above types.
+''
+
+/**
+ * Turn an mdast `strong` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Strong} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function strong(state, node) {
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'strong',
+    properties: {},
+    children: state.all(node)
+  }
+  state.patch(node, result)
+  return state.applyData(node, result)
+}

node_modules/mdast-util-to-hast/lib/handlers/table-cell.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Turn an mdast `tableCell` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {TableCell} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function tableCell(state: State, node: TableCell): Element;
+export type Element = import("hast").Element;
+export type TableCell = import("mdast").TableCell;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/table-cell.js

@@ -0,0 +1,32 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').TableCell} TableCell
+ * @typedef {import('../state.js').State} State
+ */
+
+// Make VS Code show references to the above types.
+''
+
+/**
+ * Turn an mdast `tableCell` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {TableCell} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function tableCell(state, node) {
+  // Note: this function is normally not called: see `table-row` for how rows
+  // and their cells are compiled.
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'td', // Assume body cell.
+    properties: {},
+    children: state.all(node)
+  }
+  state.patch(node, result)
+  return state.applyData(node, result)
+}

node_modules/mdast-util-to-hast/lib/handlers/table-row.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Turn an mdast `tableRow` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {TableRow} node
+ *   mdast node.
+ * @param {Parents | undefined} parent
+ *   Parent of `node`.
+ * @returns {Element}
+ *   hast node.
+ */
+export function tableRow(state: State, node: TableRow, parent: Parents | undefined): Element;
+export type Element = import("hast").Element;
+export type ElementContent = import("hast").ElementContent;
+export type Properties = import("hast").Properties;
+export type Parents = import("mdast").Parents;
+export type TableRow = import("mdast").TableRow;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/table-row.js

@@ -0,0 +1,69 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('hast').ElementContent} ElementContent
+ * @typedef {import('hast').Properties} Properties
+ * @typedef {import('mdast').Parents} Parents
+ * @typedef {import('mdast').TableRow} TableRow
+ * @typedef {import('../state.js').State} State
+ */
+
+// Make VS Code show references to the above types.
+''
+
+/**
+ * Turn an mdast `tableRow` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {TableRow} node
+ *   mdast node.
+ * @param {Parents | undefined} parent
+ *   Parent of `node`.
+ * @returns {Element}
+ *   hast node.
+ */
+export function tableRow(state, node, parent) {
+  const siblings = parent ? parent.children : undefined
+  // Generate a body row when without parent.
+  const rowIndex = siblings ? siblings.indexOf(node) : 1
+  const tagName = rowIndex === 0 ? 'th' : 'td'
+  // To do: option to use `style`?
+  const align = parent && parent.type === 'table' ? parent.align : undefined
+  const length = align ? align.length : node.children.length
+  let cellIndex = -1
+  /** @type {Array<ElementContent>} */
+  const cells = []
+
+  while (++cellIndex < length) {
+    // Note: can also be undefined.
+    const cell = node.children[cellIndex]
+    /** @type {Properties} */
+    const properties = {}
+    const alignValue = align ? align[cellIndex] : undefined
+
+    if (alignValue) {
+      properties.align = alignValue
+    }
+
+    /** @type {Element} */
+    let result = {type: 'element', tagName, properties, children: []}
+
+    if (cell) {
+      result.children = state.all(cell)
+      state.patch(cell, result)
+      result = state.applyData(cell, result)
+    }
+
+    cells.push(result)
+  }
+
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'tr',
+    properties: {},
+    children: state.wrap(cells, true)
+  }
+  state.patch(node, result)
+  return state.applyData(node, result)
+}

node_modules/mdast-util-to-hast/lib/handlers/table.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Turn an mdast `table` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Table} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function table(state: State, node: Table): Element;
+export type Element = import("hast").Element;
+export type Table = import("mdast").Table;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/table.js

@@ -0,0 +1,61 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').Table} Table
+ * @typedef {import('../state.js').State} State
+ */
+
+import {pointEnd, pointStart} from 'unist-util-position'
+
+/**
+ * Turn an mdast `table` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Table} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function table(state, node) {
+  const rows = state.all(node)
+  const firstRow = rows.shift()
+  /** @type {Array<Element>} */
+  const tableContent = []
+
+  if (firstRow) {
+    /** @type {Element} */
+    const head = {
+      type: 'element',
+      tagName: 'thead',
+      properties: {},
+      children: state.wrap([firstRow], true)
+    }
+    state.patch(node.children[0], head)
+    tableContent.push(head)
+  }
+
+  if (rows.length > 0) {
+    /** @type {Element} */
+    const body = {
+      type: 'element',
+      tagName: 'tbody',
+      properties: {},
+      children: state.wrap(rows, true)
+    }
+
+    const start = pointStart(node.children[1])
+    const end = pointEnd(node.children[node.children.length - 1])
+    if (start && end) body.position = {start, end}
+    tableContent.push(body)
+  }
+
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'table',
+    properties: {},
+    children: state.wrap(tableContent, true)
+  }
+  state.patch(node, result)
+  return state.applyData(node, result)
+}

node_modules/mdast-util-to-hast/lib/handlers/text.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Turn an mdast `text` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {MdastText} node
+ *   mdast node.
+ * @returns {HastElement | HastText}
+ *   hast node.
+ */
+export function text(state: State, node: MdastText): HastElement | HastText;
+export type HastElement = import("hast").Element;
+export type HastText = import("hast").Text;
+export type MdastText = import("mdast").Text;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/text.js

@@ -0,0 +1,25 @@
+/**
+ * @typedef {import('hast').Element} HastElement
+ * @typedef {import('hast').Text} HastText
+ * @typedef {import('mdast').Text} MdastText
+ * @typedef {import('../state.js').State} State
+ */
+
+import {trimLines} from 'trim-lines'
+
+/**
+ * Turn an mdast `text` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {MdastText} node
+ *   mdast node.
+ * @returns {HastElement | HastText}
+ *   hast node.
+ */
+export function text(state, node) {
+  /** @type {HastText} */
+  const result = {type: 'text', value: trimLines(String(node.value))}
+  state.patch(node, result)
+  return state.applyData(node, result)
+}

node_modules/mdast-util-to-hast/lib/handlers/thematic-break.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Turn an mdast `thematicBreak` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {ThematicBreak} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function thematicBreak(state: State, node: ThematicBreak): Element;
+export type Element = import("hast").Element;
+export type ThematicBreak = import("mdast").ThematicBreak;
+export type State = import("../state.js").State;

node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js

@@ -0,0 +1,30 @@
+/**
+ * @typedef {import('hast').Element} Element
+ * @typedef {import('mdast').ThematicBreak} ThematicBreak
+ * @typedef {import('../state.js').State} State
+ */
+
+// Make VS Code show references to the above types.
+''
+
+/**
+ * Turn an mdast `thematicBreak` node into hast.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {ThematicBreak} node
+ *   mdast node.
+ * @returns {Element}
+ *   hast node.
+ */
+export function thematicBreak(state, node) {
+  /** @type {Element} */
+  const result = {
+    type: 'element',
+    tagName: 'hr',
+    properties: {},
+    children: []
+  }
+  state.patch(node, result)
+  return state.applyData(node, result)
+}

node_modules/mdast-util-to-hast/lib/index.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Transform mdast to hast.
+ *
+ * ##### Notes
+ *
+ * ###### HTML
+ *
+ * Raw HTML is available in mdast as `html` nodes and can be embedded in hast
+ * as semistandard `raw` nodes.
+ * Most utilities ignore `raw` nodes but two notable ones don’t:
+ *
+ * *   `hast-util-to-html` also has an option `allowDangerousHtml` which will
+ *     output the raw HTML.
+ *     This is typically discouraged as noted by the option name but is useful
+ *     if you completely trust authors
+ * *   `hast-util-raw` can handle the raw embedded HTML strings by parsing them
+ *     into standard hast nodes (`element`, `text`, etc).
+ *     This is a heavy task as it needs a full HTML parser, but it is the only
+ *     way to support untrusted content
+ *
+ * ###### Footnotes
+ *
+ * Many options supported here relate to footnotes.
+ * Footnotes are not specified by CommonMark, which we follow by default.
+ * They are supported by GitHub, so footnotes can be enabled in markdown with
+ * `mdast-util-gfm`.
+ *
+ * The options `footnoteBackLabel` and `footnoteLabel` define natural language
+ * that explains footnotes, which is hidden for sighted users but shown to
+ * assistive technology.
+ * When your page is not in English, you must define translated values.
+ *
+ * Back references use ARIA attributes, but the section label itself uses a
+ * heading that is hidden with an `sr-only` class.
+ * To show it to sighted users, define different attributes in
+ * `footnoteLabelProperties`.
+ *
+ * ###### Clobbering
+ *
+ * Footnotes introduces a problem, as it links footnote calls to footnote
+ * definitions on the page through `id` attributes generated from user content,
+ * which results in DOM clobbering.
+ *
+ * DOM clobbering is this:
+ *
+ * ```html
+ * <p id=x></p>
+ * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>
+ * ```
+ *
+ * Elements by their ID are made available by browsers on the `window` object,
+ * which is a security risk.
+ * Using a prefix solves this problem.
+ *
+ * More information on how to handle clobbering and the prefix is explained in
+ * Example: headings (DOM clobbering) in `rehype-sanitize`.
+ *
+ * ###### Unknown nodes
+ *
+ * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.
+ * The default behavior for unknown nodes is:
+ *
+ * *   when the node has a `value` (and doesn’t have `data.hName`,
+ *     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`
+ *     node
+ * *   otherwise, create a `<div>` element (which could be changed with
+ *     `data.hName`), with its children mapped from mdast to hast as well
+ *
+ * This behavior can be changed by passing an `unknownHandler`.
+ *
+ * @param {MdastNodes} tree
+ *   mdast tree.
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {HastNodes}
+ *   hast tree.
+ */
+export function toHast(tree: MdastNodes, options?: Options | null | undefined): HastNodes;
+export type HastNodes = import("hast").Nodes;
+export type MdastNodes = import("mdast").Nodes;
+export type Options = import("./state.js").Options;

node_modules/mdast-util-to-hast/lib/index.js

@@ -0,0 +1,106 @@
+/**
+ * @typedef {import('hast').Nodes} HastNodes
+ * @typedef {import('mdast').Nodes} MdastNodes
+ * @typedef {import('./state.js').Options} Options
+ */
+
+import {ok as assert} from 'devlop'
+import {footer} from './footer.js'
+import {createState} from './state.js'
+
+/**
+ * Transform mdast to hast.
+ *
+ * ##### Notes
+ *
+ * ###### HTML
+ *
+ * Raw HTML is available in mdast as `html` nodes and can be embedded in hast
+ * as semistandard `raw` nodes.
+ * Most utilities ignore `raw` nodes but two notable ones don’t:
+ *
+ * *   `hast-util-to-html` also has an option `allowDangerousHtml` which will
+ *     output the raw HTML.
+ *     This is typically discouraged as noted by the option name but is useful
+ *     if you completely trust authors
+ * *   `hast-util-raw` can handle the raw embedded HTML strings by parsing them
+ *     into standard hast nodes (`element`, `text`, etc).
+ *     This is a heavy task as it needs a full HTML parser, but it is the only
+ *     way to support untrusted content
+ *
+ * ###### Footnotes
+ *
+ * Many options supported here relate to footnotes.
+ * Footnotes are not specified by CommonMark, which we follow by default.
+ * They are supported by GitHub, so footnotes can be enabled in markdown with
+ * `mdast-util-gfm`.
+ *
+ * The options `footnoteBackLabel` and `footnoteLabel` define natural language
+ * that explains footnotes, which is hidden for sighted users but shown to
+ * assistive technology.
+ * When your page is not in English, you must define translated values.
+ *
+ * Back references use ARIA attributes, but the section label itself uses a
+ * heading that is hidden with an `sr-only` class.
+ * To show it to sighted users, define different attributes in
+ * `footnoteLabelProperties`.
+ *
+ * ###### Clobbering
+ *
+ * Footnotes introduces a problem, as it links footnote calls to footnote
+ * definitions on the page through `id` attributes generated from user content,
+ * which results in DOM clobbering.
+ *
+ * DOM clobbering is this:
+ *
+ * ```html
+ * <p id=x></p>
+ * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>
+ * ```
+ *
+ * Elements by their ID are made available by browsers on the `window` object,
+ * which is a security risk.
+ * Using a prefix solves this problem.
+ *
+ * More information on how to handle clobbering and the prefix is explained in
+ * Example: headings (DOM clobbering) in `rehype-sanitize`.
+ *
+ * ###### Unknown nodes
+ *
+ * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.
+ * The default behavior for unknown nodes is:
+ *
+ * *   when the node has a `value` (and doesn’t have `data.hName`,
+ *     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`
+ *     node
+ * *   otherwise, create a `<div>` element (which could be changed with
+ *     `data.hName`), with its children mapped from mdast to hast as well
+ *
+ * This behavior can be changed by passing an `unknownHandler`.
+ *
+ * @param {MdastNodes} tree
+ *   mdast tree.
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {HastNodes}
+ *   hast tree.
+ */
+export function toHast(tree, options) {
+  const state = createState(tree, options)
+  const node = state.one(tree, undefined)
+  const foot = footer(state)
+  /** @type {HastNodes} */
+  const result = Array.isArray(node)
+    ? {type: 'root', children: node}
+    : node || {type: 'root', children: []}
+
+  if (foot) {
+    // If there’s a footer, there were definitions, meaning block
+    // content.
+    // So `result` is a parent node.
+    assert('children' in result)
+    result.children.push({type: 'text', value: '\n'}, foot)
+  }
+
+  return result
+}

node_modules/mdast-util-to-hast/lib/revert.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Return the content of a reference without definition as plain text.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Extract<Nodes, Reference>} node
+ *   Reference node (image, link).
+ * @returns {Array<ElementContent>}
+ *   hast content.
+ */
+export function revert(state: State, node: Extract<Nodes, Reference>): Array<ElementContent>;
+export type ElementContent = import("hast").ElementContent;
+export type Nodes = import("mdast").Nodes;
+export type Reference = import("mdast").Reference;
+export type State = import("./state.js").State;

node_modules/mdast-util-to-hast/lib/revert.js

@@ -0,0 +1,55 @@
+/**
+ * @typedef {import('hast').ElementContent} ElementContent
+ *
+ * @typedef {import('mdast').Nodes} Nodes
+ * @typedef {import('mdast').Reference} Reference
+ *
+ * @typedef {import('./state.js').State} State
+ */
+
+// Make VS Code show references to the above types.
+''
+
+/**
+ * Return the content of a reference without definition as plain text.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {Extract<Nodes, Reference>} node
+ *   Reference node (image, link).
+ * @returns {Array<ElementContent>}
+ *   hast content.
+ */
+export function revert(state, node) {
+  const subtype = node.referenceType
+  let suffix = ']'
+
+  if (subtype === 'collapsed') {
+    suffix += '[]'
+  } else if (subtype === 'full') {
+    suffix += '[' + (node.label || node.identifier) + ']'
+  }
+
+  if (node.type === 'imageReference') {
+    return [{type: 'text', value: '![' + node.alt + suffix}]
+  }
+
+  const contents = state.all(node)
+  const head = contents[0]
+
+  if (head && head.type === 'text') {
+    head.value = '[' + head.value
+  } else {
+    contents.unshift({type: 'text', value: '['})
+  }
+
+  const tail = contents[contents.length - 1]
+
+  if (tail && tail.type === 'text') {
+    tail.value += suffix
+  } else {
+    contents.push({type: 'text', value: suffix})
+  }
+
+  return contents
+}

node_modules/mdast-util-to-hast/lib/state.d.ts

@@ -0,0 +1,232 @@
+/**
+ * Create `state` from an mdast tree.
+ *
+ * @param {MdastNodes} tree
+ *   mdast node to transform.
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {State}
+ *   `state` function.
+ */
+export function createState(tree: MdastNodes, options?: Options | null | undefined): State;
+/**
+ * Wrap `nodes` with line endings between each node.
+ *
+ * @template {HastRootContent} Type
+ *   Node type.
+ * @param {Array<Type>} nodes
+ *   List of nodes to wrap.
+ * @param {boolean | undefined} [loose=false]
+ *   Whether to add line endings at start and end (default: `false`).
+ * @returns {Array<HastText | Type>}
+ *   Wrapped nodes.
+ */
+export function wrap<Type extends HastRootContent>(nodes: Array<Type>, loose?: boolean | undefined): Array<HastText | Type>;
+export type HastElement = import("hast").Element;
+export type HastElementContent = import("hast").ElementContent;
+export type HastNodes = import("hast").Nodes;
+export type HastProperties = import("hast").Properties;
+export type HastRootContent = import("hast").RootContent;
+export type HastText = import("hast").Text;
+export type MdastDefinition = import("mdast").Definition;
+export type MdastFootnoteDefinition = import("mdast").FootnoteDefinition;
+export type MdastNodes = import("mdast").Nodes;
+export type MdastParents = import("mdast").Parents;
+export type VFile = import("vfile").VFile;
+export type FootnoteBackContentTemplate = import("./footer.js").FootnoteBackContentTemplate;
+export type FootnoteBackLabelTemplate = import("./footer.js").FootnoteBackLabelTemplate;
+/**
+ * Handle a node.
+ */
+export type Handler = (state: State, node: any, parent: MdastParents | undefined) => Array<HastElementContent> | HastElementContent | undefined;
+/**
+ * Handle nodes.
+ */
+export type Handlers = Partial<Record<MdastNodes["type"], Handler>>;
+/**
+ * Configuration (optional).
+ */
+export type Options = {
+    /**
+     * Whether to persist raw HTML in markdown in the hast tree (default:
+     * `false`).
+     */
+    allowDangerousHtml?: boolean | null | undefined;
+    /**
+     * Prefix to use before the `id` property on footnotes to prevent them from
+     * *clobbering* (default: `'user-content-'`).
+     *
+     * Pass `''` for trusted markdown and when you are careful with
+     * polyfilling.
+     * You could pass a different prefix.
+     *
+     * DOM clobbering is this:
+     *
+     * ```html
+     * <p id="x"></p>
+     * <script>alert(x) // `x` now refers to the `p#x` DOM element</script>
+     * ```
+     *
+     * The above example shows that elements are made available by browsers, by
+     * their ID, on the `window` object.
+     * This is a security risk because you might be expecting some other variable
+     * at that place.
+     * It can also break polyfills.
+     * Using a prefix solves these problems.
+     */
+    clobberPrefix?: string | null | undefined;
+    /**
+     * Corresponding virtual file representing the input document (optional).
+     */
+    file?: VFile | null | undefined;
+    /**
+     * Content of the backreference back to references (default: `defaultFootnoteBackContent`).
+     *
+     * The default value is:
+     *
+     * ```js
+     * function defaultFootnoteBackContent(_, rereferenceIndex) {
+     * const result = [{type: 'text', value: '↩'}]
+     *
+     * if (rereferenceIndex > 1) {
+     * result.push({
+     * type: 'element',
+     * tagName: 'sup',
+     * properties: {},
+     * children: [{type: 'text', value: String(rereferenceIndex)}]
+     * })
+     * }
+     *
+     * return result
+     * }
+     * ```
+     *
+     * This content is used in the `a` element of each backreference (the `↩`
+     * links).
+     */
+    footnoteBackContent?: FootnoteBackContentTemplate | string | null | undefined;
+    /**
+     * Label to describe the backreference back to references (default:
+     * `defaultFootnoteBackLabel`).
+     *
+     * The default value is:
+     *
+     * ```js
+     * function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {
+     * return (
+     * 'Back to reference ' +
+     * (referenceIndex + 1) +
+     * (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')
+     * )
+     * }
+     * ```
+     *
+     * Change it when the markdown is not in English.
+     *
+     * This label is used in the `ariaLabel` property on each backreference
+     * (the `↩` links).
+     * It affects users of assistive technology.
+     */
+    footnoteBackLabel?: FootnoteBackLabelTemplate | string | null | undefined;
+    /**
+     * Textual label to use for the footnotes section (default: `'Footnotes'`).
+     *
+     * Change it when the markdown is not in English.
+     *
+     * This label is typically hidden visually (assuming a `sr-only` CSS class
+     * is defined that does that) and so affects screen readers only.
+     * If you do have such a class, but want to show this section to everyone,
+     * pass different properties with the `footnoteLabelProperties` option.
+     */
+    footnoteLabel?: string | null | undefined;
+    /**
+     * Properties to use on the footnote label (default: `{className:
+     * ['sr-only']}`).
+     *
+     * Change it to show the label and add other properties.
+     *
+     * This label is typically hidden visually (assuming an `sr-only` CSS class
+     * is defined that does that) and so affects screen readers only.
+     * If you do have such a class, but want to show this section to everyone,
+     * pass an empty string.
+     * You can also add different properties.
+     *
+     * > **Note**: `id: 'footnote-label'` is always added, because footnote
+     * > calls use it with `aria-describedby` to provide an accessible label.
+     */
+    footnoteLabelProperties?: HastProperties | null | undefined;
+    /**
+     * HTML tag name to use for the footnote label element (default: `'h2'`).
+     *
+     * Change it to match your document structure.
+     *
+     * This label is typically hidden visually (assuming a `sr-only` CSS class
+     * is defined that does that) and so affects screen readers only.
+     * If you do have such a class, but want to show this section to everyone,
+     * pass different properties with the `footnoteLabelProperties` option.
+     */
+    footnoteLabelTagName?: string | null | undefined;
+    /**
+     * Extra handlers for nodes (optional).
+     */
+    handlers?: Handlers | null | undefined;
+    /**
+     * List of custom mdast node types to pass through (keep) in hast (note that
+     * the node itself is passed, but eventual children are transformed)
+     * (optional).
+     */
+    passThrough?: Array<MdastNodes["type"]> | null | undefined;
+    /**
+     * Handler for all unknown nodes (optional).
+     */
+    unknownHandler?: Handler | null | undefined;
+};
+/**
+ * Info passed around.
+ */
+export type State = {
+    /**
+     *   Transform the children of an mdast parent to hast.
+     */
+    all: (node: MdastNodes) => Array<HastElementContent>;
+    /**
+     *   Honor the `data` of `from`, and generate an element instead of `node`.
+     */
+    applyData: <Type extends HastNodes>(from: MdastNodes, to: Type) => HastElement | Type;
+    /**
+     *   Definitions by their identifier.
+     */
+    definitionById: Map<string, MdastDefinition>;
+    /**
+     *   Footnote definitions by their identifier.
+     */
+    footnoteById: Map<string, MdastFootnoteDefinition>;
+    /**
+     *   Counts for how often the same footnote was called.
+     */
+    footnoteCounts: Map<string, number>;
+    /**
+     *   Identifiers of order when footnote calls first appear in tree order.
+     */
+    footnoteOrder: Array<string>;
+    /**
+     *   Applied handlers.
+     */
+    handlers: Handlers;
+    /**
+     *   Transform an mdast node to hast.
+     */
+    one: (node: MdastNodes, parent: MdastParents | undefined) => Array<HastElementContent> | HastElementContent | undefined;
+    /**
+     *   Configuration.
+     */
+    options: Options;
+    /**
+     *   Copy a node’s positional info.
+     */
+    patch: (from: MdastNodes, node: HastNodes) => undefined;
+    /**
+     *   Wrap `nodes` with line endings between each node, adds initial/final line endings when `loose`.
+     */
+    wrap: <Type extends HastRootContent>(nodes: Array<Type>, loose?: boolean | undefined) => Array<HastText | Type>;
+};

node_modules/mdast-util-to-hast/lib/state.js

@@ -0,0 +1,473 @@
+/**
+ * @typedef {import('hast').Element} HastElement
+ * @typedef {import('hast').ElementContent} HastElementContent
+ * @typedef {import('hast').Nodes} HastNodes
+ * @typedef {import('hast').Properties} HastProperties
+ * @typedef {import('hast').RootContent} HastRootContent
+ * @typedef {import('hast').Text} HastText
+ *
+ * @typedef {import('mdast').Definition} MdastDefinition
+ * @typedef {import('mdast').FootnoteDefinition} MdastFootnoteDefinition
+ * @typedef {import('mdast').Nodes} MdastNodes
+ * @typedef {import('mdast').Parents} MdastParents
+ *
+ * @typedef {import('vfile').VFile} VFile
+ *
+ * @typedef {import('./footer.js').FootnoteBackContentTemplate} FootnoteBackContentTemplate
+ * @typedef {import('./footer.js').FootnoteBackLabelTemplate} FootnoteBackLabelTemplate
+ */
+
+/**
+ * @callback Handler
+ *   Handle a node.
+ * @param {State} state
+ *   Info passed around.
+ * @param {any} node
+ *   mdast node to handle.
+ * @param {MdastParents | undefined} parent
+ *   Parent of `node`.
+ * @returns {Array<HastElementContent> | HastElementContent | undefined}
+ *   hast node.
+ *
+ * @typedef {Partial<Record<MdastNodes['type'], Handler>>} Handlers
+ *   Handle nodes.
+ *
+ * @typedef Options
+ *   Configuration (optional).
+ * @property {boolean | null | undefined} [allowDangerousHtml=false]
+ *   Whether to persist raw HTML in markdown in the hast tree (default:
+ *   `false`).
+ * @property {string | null | undefined} [clobberPrefix='user-content-']
+ *   Prefix to use before the `id` property on footnotes to prevent them from
+ *   *clobbering* (default: `'user-content-'`).
+ *
+ *   Pass `''` for trusted markdown and when you are careful with
+ *   polyfilling.
+ *   You could pass a different prefix.
+ *
+ *   DOM clobbering is this:
+ *
+ *   ```html
+ *   <p id="x"></p>
+ *   <script>alert(x) // `x` now refers to the `p#x` DOM element</script>
+ *   ```
+ *
+ *   The above example shows that elements are made available by browsers, by
+ *   their ID, on the `window` object.
+ *   This is a security risk because you might be expecting some other variable
+ *   at that place.
+ *   It can also break polyfills.
+ *   Using a prefix solves these problems.
+ * @property {VFile | null | undefined} [file]
+ *   Corresponding virtual file representing the input document (optional).
+ * @property {FootnoteBackContentTemplate | string | null | undefined} [footnoteBackContent]
+ *   Content of the backreference back to references (default: `defaultFootnoteBackContent`).
+ *
+ *   The default value is:
+ *
+ *   ```js
+ *   function defaultFootnoteBackContent(_, rereferenceIndex) {
+ *     const result = [{type: 'text', value: '↩'}]
+ *
+ *     if (rereferenceIndex > 1) {
+ *       result.push({
+ *         type: 'element',
+ *         tagName: 'sup',
+ *         properties: {},
+ *         children: [{type: 'text', value: String(rereferenceIndex)}]
+ *       })
+ *     }
+ *
+ *     return result
+ *   }
+ *   ```
+ *
+ *   This content is used in the `a` element of each backreference (the `↩`
+ *   links).
+ * @property {FootnoteBackLabelTemplate | string | null | undefined} [footnoteBackLabel]
+ *   Label to describe the backreference back to references (default:
+ *   `defaultFootnoteBackLabel`).
+ *
+ *   The default value is:
+ *
+ *   ```js
+ *   function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {
+ *    return (
+ *      'Back to reference ' +
+ *      (referenceIndex + 1) +
+ *      (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')
+ *    )
+ *   }
+ *   ```
+ *
+ *   Change it when the markdown is not in English.
+ *
+ *   This label is used in the `ariaLabel` property on each backreference
+ *   (the `↩` links).
+ *   It affects users of assistive technology.
+ * @property {string | null | undefined} [footnoteLabel='Footnotes']
+ *   Textual label to use for the footnotes section (default: `'Footnotes'`).
+ *
+ *   Change it when the markdown is not in English.
+ *
+ *   This label is typically hidden visually (assuming a `sr-only` CSS class
+ *   is defined that does that) and so affects screen readers only.
+ *   If you do have such a class, but want to show this section to everyone,
+ *   pass different properties with the `footnoteLabelProperties` option.
+ * @property {HastProperties | null | undefined} [footnoteLabelProperties={className: ['sr-only']}]
+ *   Properties to use on the footnote label (default: `{className:
+ *   ['sr-only']}`).
+ *
+ *   Change it to show the label and add other properties.
+ *
+ *   This label is typically hidden visually (assuming an `sr-only` CSS class
+ *   is defined that does that) and so affects screen readers only.
+ *   If you do have such a class, but want to show this section to everyone,
+ *   pass an empty string.
+ *   You can also add different properties.
+ *
+ *   > **Note**: `id: 'footnote-label'` is always added, because footnote
+ *   > calls use it with `aria-describedby` to provide an accessible label.
+ * @property {string | null | undefined} [footnoteLabelTagName='h2']
+ *   HTML tag name to use for the footnote label element (default: `'h2'`).
+ *
+ *   Change it to match your document structure.
+ *
+ *   This label is typically hidden visually (assuming a `sr-only` CSS class
+ *   is defined that does that) and so affects screen readers only.
+ *   If you do have such a class, but want to show this section to everyone,
+ *   pass different properties with the `footnoteLabelProperties` option.
+ * @property {Handlers | null | undefined} [handlers]
+ *   Extra handlers for nodes (optional).
+ * @property {Array<MdastNodes['type']> | null | undefined} [passThrough]
+ *   List of custom mdast node types to pass through (keep) in hast (note that
+ *   the node itself is passed, but eventual children are transformed)
+ *   (optional).
+ * @property {Handler | null | undefined} [unknownHandler]
+ *   Handler for all unknown nodes (optional).
+ *
+ * @typedef State
+ *   Info passed around.
+ * @property {(node: MdastNodes) => Array<HastElementContent>} all
+ *   Transform the children of an mdast parent to hast.
+ * @property {<Type extends HastNodes>(from: MdastNodes, to: Type) => HastElement | Type} applyData
+ *   Honor the `data` of `from`, and generate an element instead of `node`.
+ * @property {Map<string, MdastDefinition>} definitionById
+ *   Definitions by their identifier.
+ * @property {Map<string, MdastFootnoteDefinition>} footnoteById
+ *   Footnote definitions by their identifier.
+ * @property {Map<string, number>} footnoteCounts
+ *   Counts for how often the same footnote was called.
+ * @property {Array<string>} footnoteOrder
+ *   Identifiers of order when footnote calls first appear in tree order.
+ * @property {Handlers} handlers
+ *   Applied handlers.
+ * @property {(node: MdastNodes, parent: MdastParents | undefined) => Array<HastElementContent> | HastElementContent | undefined} one
+ *   Transform an mdast node to hast.
+ * @property {Options} options
+ *   Configuration.
+ * @property {(from: MdastNodes, node: HastNodes) => undefined} patch
+ *   Copy a node’s positional info.
+ * @property {<Type extends HastRootContent>(nodes: Array<Type>, loose?: boolean | undefined) => Array<HastText | Type>} wrap
+ *   Wrap `nodes` with line endings between each node, adds initial/final line endings when `loose`.
+ */
+
+import structuredClone from '@ungap/structured-clone'
+import {visit} from 'unist-util-visit'
+import {position} from 'unist-util-position'
+import {handlers as defaultHandlers} from './handlers/index.js'
+
+const own = {}.hasOwnProperty
+
+/** @type {Options} */
+const emptyOptions = {}
+
+/**
+ * Create `state` from an mdast tree.
+ *
+ * @param {MdastNodes} tree
+ *   mdast node to transform.
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {State}
+ *   `state` function.
+ */
+export function createState(tree, options) {
+  const settings = options || emptyOptions
+  /** @type {Map<string, MdastDefinition>} */
+  const definitionById = new Map()
+  /** @type {Map<string, MdastFootnoteDefinition>} */
+  const footnoteById = new Map()
+  /** @type {Map<string, number>} */
+  const footnoteCounts = new Map()
+  /** @type {Handlers} */
+  // @ts-expect-error: the root handler returns a root.
+  // Hard to type.
+  const handlers = {...defaultHandlers, ...settings.handlers}
+
+  /** @type {State} */
+  const state = {
+    all,
+    applyData,
+    definitionById,
+    footnoteById,
+    footnoteCounts,
+    footnoteOrder: [],
+    handlers,
+    one,
+    options: settings,
+    patch,
+    wrap
+  }
+
+  visit(tree, function (node) {
+    if (node.type === 'definition' || node.type === 'footnoteDefinition') {
+      const map = node.type === 'definition' ? definitionById : footnoteById
+      const id = String(node.identifier).toUpperCase()
+
+      // Mimick CM behavior of link definitions.
+      // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/9032189/lib/index.js#L20-L21>.
+      if (!map.has(id)) {
+        // @ts-expect-error: node type matches map.
+        map.set(id, node)
+      }
+    }
+  })
+
+  return state
+
+  /**
+   * Transform an mdast node into a hast node.
+   *
+   * @param {MdastNodes} node
+   *   mdast node.
+   * @param {MdastParents | undefined} [parent]
+   *   Parent of `node`.
+   * @returns {Array<HastElementContent> | HastElementContent | undefined}
+   *   Resulting hast node.
+   */
+  function one(node, parent) {
+    const type = node.type
+    const handle = state.handlers[type]
+
+    if (own.call(state.handlers, type) && handle) {
+      return handle(state, node, parent)
+    }
+
+    if (state.options.passThrough && state.options.passThrough.includes(type)) {
+      if ('children' in node) {
+        const {children, ...shallow} = node
+        const result = structuredClone(shallow)
+        // @ts-expect-error: TS doesn’t understand…
+        result.children = state.all(node)
+        // @ts-expect-error: TS doesn’t understand…
+        return result
+      }
+
+      // @ts-expect-error: it’s custom.
+      return structuredClone(node)
+    }
+
+    const unknown = state.options.unknownHandler || defaultUnknownHandler
+
+    return unknown(state, node, parent)
+  }
+
+  /**
+   * Transform the children of an mdast node into hast nodes.
+   *
+   * @param {MdastNodes} parent
+   *   mdast node to compile
+   * @returns {Array<HastElementContent>}
+   *   Resulting hast nodes.
+   */
+  function all(parent) {
+    /** @type {Array<HastElementContent>} */
+    const values = []
+
+    if ('children' in parent) {
+      const nodes = parent.children
+      let index = -1
+      while (++index < nodes.length) {
+        const result = state.one(nodes[index], parent)
+
+        // To do: see if we van clean this? Can we merge texts?
+        if (result) {
+          if (index && nodes[index - 1].type === 'break') {
+            if (!Array.isArray(result) && result.type === 'text') {
+              result.value = trimMarkdownSpaceStart(result.value)
+            }
+
+            if (!Array.isArray(result) && result.type === 'element') {
+              const head = result.children[0]
+
+              if (head && head.type === 'text') {
+                head.value = trimMarkdownSpaceStart(head.value)
+              }
+            }
+          }
+
+          if (Array.isArray(result)) {
+            values.push(...result)
+          } else {
+            values.push(result)
+          }
+        }
+      }
+    }
+
+    return values
+  }
+}
+
+/**
+ * Copy a node’s positional info.
+ *
+ * @param {MdastNodes} from
+ *   mdast node to copy from.
+ * @param {HastNodes} to
+ *   hast node to copy into.
+ * @returns {undefined}
+ *   Nothing.
+ */
+function patch(from, to) {
+  if (from.position) to.position = position(from)
+}
+
+/**
+ * Honor the `data` of `from` and maybe generate an element instead of `to`.
+ *
+ * @template {HastNodes} Type
+ *   Node type.
+ * @param {MdastNodes} from
+ *   mdast node to use data from.
+ * @param {Type} to
+ *   hast node to change.
+ * @returns {HastElement | Type}
+ *   Nothing.
+ */
+function applyData(from, to) {
+  /** @type {HastElement | Type} */
+  let result = to
+
+  // Handle `data.hName`, `data.hProperties, `data.hChildren`.
+  if (from && from.data) {
+    const hName = from.data.hName
+    const hChildren = from.data.hChildren
+    const hProperties = from.data.hProperties
+
+    if (typeof hName === 'string') {
+      // Transforming the node resulted in an element with a different name
+      // than wanted:
+      if (result.type === 'element') {
+        result.tagName = hName
+      }
+      // Transforming the node resulted in a non-element, which happens for
+      // raw, text, and root nodes (unless custom handlers are passed).
+      // The intent of `hName` is to create an element, but likely also to keep
+      // the content around (otherwise: pass `hChildren`).
+      else {
+        /** @type {Array<HastElementContent>} */
+        // @ts-expect-error: assume no doctypes in `root`.
+        const children = 'children' in result ? result.children : [result]
+        result = {type: 'element', tagName: hName, properties: {}, children}
+      }
+    }
+
+    if (result.type === 'element' && hProperties) {
+      Object.assign(result.properties, structuredClone(hProperties))
+    }
+
+    if (
+      'children' in result &&
+      result.children &&
+      hChildren !== null &&
+      hChildren !== undefined
+    ) {
+      result.children = hChildren
+    }
+  }
+
+  return result
+}
+
+/**
+ * Transform an unknown node.
+ *
+ * @param {State} state
+ *   Info passed around.
+ * @param {MdastNodes} node
+ *   Unknown mdast node.
+ * @returns {HastElement | HastText}
+ *   Resulting hast node.
+ */
+function defaultUnknownHandler(state, node) {
+  const data = node.data || {}
+  /** @type {HastElement | HastText} */
+  const result =
+    'value' in node &&
+    !(own.call(data, 'hProperties') || own.call(data, 'hChildren'))
+      ? {type: 'text', value: node.value}
+      : {
+          type: 'element',
+          tagName: 'div',
+          properties: {},
+          children: state.all(node)
+        }
+
+  state.patch(node, result)
+  return state.applyData(node, result)
+}
+
+/**
+ * Wrap `nodes` with line endings between each node.
+ *
+ * @template {HastRootContent} Type
+ *   Node type.
+ * @param {Array<Type>} nodes
+ *   List of nodes to wrap.
+ * @param {boolean | undefined} [loose=false]
+ *   Whether to add line endings at start and end (default: `false`).
+ * @returns {Array<HastText | Type>}
+ *   Wrapped nodes.
+ */
+export function wrap(nodes, loose) {
+  /** @type {Array<HastText | Type>} */
+  const result = []
+  let index = -1
+
+  if (loose) {
+    result.push({type: 'text', value: '\n'})
+  }
+
+  while (++index < nodes.length) {
+    if (index) result.push({type: 'text', value: '\n'})
+    result.push(nodes[index])
+  }
+
+  if (loose && nodes.length > 0) {
+    result.push({type: 'text', value: '\n'})
+  }
+
+  return result
+}
+
+/**
+ * Trim spaces and tabs at the start of `value`.
+ *
+ * @param {string} value
+ *   Value to trim.
+ * @returns {string}
+ *   Result.
+ */
+function trimMarkdownSpaceStart(value) {
+  let index = 0
+  let code = value.charCodeAt(index)
+
+  while (code === 9 || code === 32) {
+    index++
+    code = value.charCodeAt(index)
+  }
+
+  return value.slice(index)
+}