@uiw/react-md-editor 4.0.2 → 4.0.3

package/dist/mdeditor.js

@@ -41615,1134 +41615,82 @@ var preview_defaultUrlTransform = url => url;
     }))
   }));
 }));
-;// CONCATENATED MODULE: ../node_modules/rehype-prism-plus/node_modules/unist-util-is/lib/index.js
-/**
- * @typedef {import('unist').Node} Node
- * @typedef {import('unist').Parent} Parent
- */
-
-/**
- * @typedef {Record<string, unknown>} Props
- * @typedef {null | undefined | string | Props | TestFunctionAnything | Array<string | Props | TestFunctionAnything>} Test
- *   Check for an arbitrary node, unaware of TypeScript inferral.
- *
- * @callback TestFunctionAnything
- *   Check if a node passes a test, unaware of TypeScript inferral.
- * @param {unknown} this
- *   The given context.
- * @param {Node} node
- *   A node.
- * @param {number | null | undefined} [index]
- *   The node’s position in its parent.
- * @param {Parent | null | undefined} [parent]
- *   The node’s parent.
- * @returns {boolean | void}
- *   Whether this node passes the test.
- */
-
-/**
- * @template {Node} Kind
- *   Node type.
- * @typedef {Kind['type'] | Partial<Kind> | TestFunctionPredicate<Kind> | Array<Kind['type'] | Partial<Kind> | TestFunctionPredicate<Kind>>} PredicateTest
- *   Check for a node that can be inferred by TypeScript.
- */
-
-/**
- * Check if a node passes a certain test.
- *
- * @template {Node} Kind
- *   Node type.
- * @callback TestFunctionPredicate
- *   Complex test function for a node that can be inferred by TypeScript.
- * @param {Node} node
- *   A node.
- * @param {number | null | undefined} [index]
- *   The node’s position in its parent.
- * @param {Parent | null | undefined} [parent]
- *   The node’s parent.
- * @returns {node is Kind}
- *   Whether this node passes the test.
- */
-
-/**
- * @callback AssertAnything
- *   Check that an arbitrary value is a node, unaware of TypeScript inferral.
- * @param {unknown} [node]
- *   Anything (typically a node).
- * @param {number | null | undefined} [index]
- *   The node’s position in its parent.
- * @param {Parent | null | undefined} [parent]
- *   The node’s parent.
- * @returns {boolean}
- *   Whether this is a node and passes a test.
- */
-
-/**
- * Check if a node is a node and passes a certain node test.
- *
- * @template {Node} Kind
- *   Node type.
- * @callback AssertPredicate
- *   Check that an arbitrary value is a specific node, aware of TypeScript.
- * @param {unknown} [node]
- *   Anything (typically a node).
- * @param {number | null | undefined} [index]
- *   The node’s position in its parent.
- * @param {Parent | null | undefined} [parent]
- *   The node’s parent.
- * @returns {node is Kind}
- *   Whether this is a node and passes a test.
- */
-
-/**
- * Check if `node` is a `Node` and whether it passes the given test.
- *
- * @param node
- *   Thing to check, typically `Node`.
- * @param test
- *   A check for a specific node.
- * @param index
- *   The node’s position in its parent.
- * @param parent
- *   The node’s parent.
- * @returns
- *   Whether `node` is a node and passes a test.
- */
-const lib_is =
-  /**
-   * @type {(
-   *   (() => false) &
-   *   (<Kind extends Node = Node>(node: unknown, test: PredicateTest<Kind>, index: number, parent: Parent, context?: unknown) => node is Kind) &
-   *   (<Kind extends Node = Node>(node: unknown, test: PredicateTest<Kind>, index?: null | undefined, parent?: null | undefined, context?: unknown) => node is Kind) &
-   *   ((node: unknown, test: Test, index: number, parent: Parent, context?: unknown) => boolean) &
-   *   ((node: unknown, test?: Test, index?: null | undefined, parent?: null | undefined, context?: unknown) => boolean)
-   * )}
-   */
-  (
-    /**
-     * @param {unknown} [node]
-     * @param {Test} [test]
-     * @param {number | null | undefined} [index]
-     * @param {Parent | null | undefined} [parent]
-     * @param {unknown} [context]
-     * @returns {boolean}
-     */
-    // eslint-disable-next-line max-params
-    function is(node, test, index, parent, context) {
-      const check = lib_convert(test)
-
-      if (
-        index !== undefined &&
-        index !== null &&
-        (typeof index !== 'number' ||
-          index < 0 ||
-          index === Number.POSITIVE_INFINITY)
-      ) {
-        throw new Error('Expected positive finite index')
-      }
-
-      if (
-        parent !== undefined &&
-        parent !== null &&
-        (!is(parent) || !parent.children)
-      ) {
-        throw new Error('Expected parent node')
-      }
-
-      if (
-        (parent === undefined || parent === null) !==
-        (index === undefined || index === null)
-      ) {
-        throw new Error('Expected both parent and index')
-      }
-
-      // @ts-expect-error Looks like a node.
-      return node && node.type && typeof node.type === 'string'
-        ? Boolean(check.call(context, node, index, parent))
-        : false
-    }
-  )
-
-/**
- * Generate an assertion from a test.
- *
- * Useful if you’re going to test many nodes, for example when creating a
- * utility where something else passes a compatible test.
- *
- * The created function is a bit faster because it expects valid input only:
- * a `node`, `index`, and `parent`.
- *
- * @param test
- *   *   when nullish, checks if `node` is a `Node`.
- *   *   when `string`, works like passing `(node) => node.type === test`.
- *   *   when `function` checks if function passed the node is true.
- *   *   when `object`, checks that all keys in test are in node, and that they have (strictly) equal values.
- *   *   when `array`, checks if any one of the subtests pass.
- * @returns
- *   An assertion.
- */
-const lib_convert =
-  /**
-   * @type {(
-   *   (<Kind extends Node>(test: PredicateTest<Kind>) => AssertPredicate<Kind>) &
-   *   ((test?: Test) => AssertAnything)
-   * )}
-   */
-  (
-    /**
-     * @param {Test} [test]
-     * @returns {AssertAnything}
-     */
-    function (test) {
-      if (test === undefined || test === null) {
-        return unist_util_is_lib_ok
-      }
-
-      if (typeof test === 'string') {
-        return lib_typeFactory(test)
-      }
-
-      if (typeof test === 'object') {
-        return Array.isArray(test) ? lib_anyFactory(test) : lib_propsFactory(test)
-      }
-
-      if (typeof test === 'function') {
-        return lib_castFactory(test)
-      }
-
-      throw new Error('Expected function, string, or object as test')
-    }
-  )
-
-/**
- * @param {Array<string | Props | TestFunctionAnything>} tests
- * @returns {AssertAnything}
- */
-function lib_anyFactory(tests) {
-  /** @type {Array<AssertAnything>} */
-  const checks = []
-  let index = -1
-
-  while (++index < tests.length) {
-    checks[index] = lib_convert(tests[index])
-  }
-
-  return lib_castFactory(any)
-
-  /**
-   * @this {unknown}
-   * @param {Array<unknown>} parameters
-   * @returns {boolean}
-   */
-  function any(...parameters) {
-    let index = -1
-
-    while (++index < checks.length) {
-      if (checks[index].call(this, ...parameters)) return true
-    }
-
-    return false
-  }
-}
-
-/**
- * Turn an object into a test for a node with a certain fields.
- *
- * @param {Props} check
- * @returns {AssertAnything}
- */
-function lib_propsFactory(check) {
-  return lib_castFactory(all)
-
-  /**
-   * @param {Node} node
-   * @returns {boolean}
-   */
-  function all(node) {
-    /** @type {string} */
-    let key
-
-    for (key in check) {
-      // @ts-expect-error: hush, it sure works as an index.
-      if (node[key] !== check[key]) return false
-    }
-
-    return true
-  }
-}
-
-/**
- * Turn a string into a test for a node with a certain type.
- *
- * @param {string} check
- * @returns {AssertAnything}
- */
-function lib_typeFactory(check) {
-  return lib_castFactory(type)
-
-  /**
-   * @param {Node} node
-   */
-  function type(node) {
-    return node && node.type === check
-  }
-}
-
-/**
- * Turn a custom test into a test for a node that passes that test.
- *
- * @param {TestFunctionAnything} check
- * @returns {AssertAnything}
- */
-function lib_castFactory(check) {
-  return assertion
-
-  /**
-   * @this {unknown}
-   * @param {unknown} node
-   * @param {Array<unknown>} parameters
-   * @returns {boolean}
-   */
-  function assertion(node, ...parameters) {
-    return Boolean(
-      node &&
-        typeof node === 'object' &&
-        'type' in node &&
-        // @ts-expect-error: fine.
-        Boolean(check.call(this, node, ...parameters))
-    )
-  }
-}
-
-function unist_util_is_lib_ok() {
-  return true
-}
-
-;// CONCATENATED MODULE: ../node_modules/rehype-prism-plus/node_modules/unist-util-visit-parents/lib/color.browser.js
-/**
- * @param {string} d
- * @returns {string}
- */
-function color_browser_color(d) {
-  return d
-}
-
-;// CONCATENATED MODULE: ../node_modules/rehype-prism-plus/node_modules/unist-util-visit-parents/lib/index.js
-/**
- * @typedef {import('unist').Node} Node
- * @typedef {import('unist').Parent} Parent
- * @typedef {import('unist-util-is').Test} Test
- */
-
-/**
- * @typedef {boolean | 'skip'} Action
- *   Union of the action types.
- *
- * @typedef {number} Index
- *   Move to the sibling at `index` next (after node itself is completely
- *   traversed).
- *
- *   Useful if mutating the tree, such as removing the node the visitor is
- *   currently on, or any of its previous siblings.
- *   Results less than 0 or greater than or equal to `children.length` stop
- *   traversing the parent.
- *
- * @typedef {[(Action | null | undefined | void)?, (Index | null | undefined)?]} ActionTuple
- *   List with one or two values, the first an action, the second an index.
- *
- * @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult
- *   Any value that can be returned from a visitor.
- */
-
-/**
- * @template {Node} [Visited=Node]
- *   Visited node type.
- * @template {Parent} [Ancestor=Parent]
- *   Ancestor type.
- * @callback Visitor
- *   Handle a node (matching `test`, if given).
- *
- *   Visitors are free to transform `node`.
- *   They can also transform the parent of node (the last of `ancestors`).
- *
- *   Replacing `node` itself, if `SKIP` is not returned, still causes its
- *   descendants to be walked (which is a bug).
- *
- *   When adding or removing previous siblings of `node` (or next siblings, in
- *   case of reverse), the `Visitor` should return a new `Index` to specify the
- *   sibling to traverse after `node` is traversed.
- *   Adding or removing next siblings of `node` (or previous siblings, in case
- *   of reverse) is handled as expected without needing to return a new `Index`.
- *
- *   Removing the children property of an ancestor still results in them being
- *   traversed.
- * @param {Visited} node
- *   Found node.
- * @param {Array<Ancestor>} ancestors
- *   Ancestors of `node`.
- * @returns {VisitorResult}
- *   What to do next.
- *
- *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.
- *   An `Action` is treated as a tuple of `[Action]`.
- *
- *   Passing a tuple back only makes sense if the `Action` is `SKIP`.
- *   When the `Action` is `EXIT`, that action can be returned.
- *   When the `Action` is `CONTINUE`, `Index` can be returned.
- */
-
-/**
- * @template {Node} [Tree=Node]
- *   Tree type.
- * @template {Test} [Check=string]
- *   Test type.
- * @typedef {Visitor<import('./complex-types.js').Matches<import('./complex-types.js').InclusiveDescendant<Tree>, Check>, Extract<import('./complex-types.js').InclusiveDescendant<Tree>, Parent>>} BuildVisitor
- *   Build a typed `Visitor` function from a tree and a test.
- *
- *   It will infer which values are passed as `node` and which as `parents`.
- */
-
-
-
-
-/**
- * Continue traversing as normal.
- */
-const lib_CONTINUE = true
-
-/**
- * Stop traversing immediately.
- */
-const lib_EXIT = false
-
-/**
- * Do not traverse this node’s children.
- */
-const lib_SKIP = 'skip'
-
-/**
- * Visit nodes, with ancestral information.
- *
- * This algorithm performs *depth-first* *tree traversal* in *preorder*
- * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).
- *
- * You can choose for which nodes `visitor` is called by passing a `test`.
- * For complex tests, you should test yourself in `visitor`, as it will be
- * faster and will have improved type information.
- *
- * Walking the tree is an intensive task.
- * Make use of the return values of the visitor when possible.
- * Instead of walking a tree multiple times, walk it once, use `unist-util-is`
- * to check if a node matches, and then perform different operations.
- *
- * You can change the tree.
- * See `Visitor` for more info.
- *
- * @param tree
- *   Tree to traverse.
- * @param test
- *   `unist-util-is`-compatible test
- * @param visitor
- *   Handle each node.
- * @param reverse
- *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).
- * @returns
- *   Nothing.
- */
-const lib_visitParents =
-  /**
-   * @type {(
-   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: BuildVisitor<Tree, Check>, reverse?: boolean | null | undefined) => void) &
-   *   (<Tree extends Node>(tree: Tree, visitor: BuildVisitor<Tree>, reverse?: boolean | null | undefined) => void)
-   * )}
-   */
-  (
-    /**
-     * @param {Node} tree
-     * @param {Test} test
-     * @param {Visitor<Node>} visitor
-     * @param {boolean | null | undefined} [reverse]
-     * @returns {void}
-     */
-    function (tree, test, visitor, reverse) {
-      if (typeof test === 'function' && typeof visitor !== 'function') {
-        reverse = visitor
-        // @ts-expect-error no visitor given, so `visitor` is test.
-        visitor = test
-        test = null
-      }
-
-      const is = lib_convert(test)
-      const step = reverse ? -1 : 1
-
-      factory(tree, undefined, [])()
-
-      /**
-       * @param {Node} node
-       * @param {number | undefined} index
-       * @param {Array<Parent>} parents
-       */
-      function factory(node, index, parents) {
-        /** @type {Record<string, unknown>} */
-        // @ts-expect-error: hush
-        const value = node && typeof node === 'object' ? node : {}
-
-        if (typeof value.type === 'string') {
-          const name =
-            // `hast`
-            typeof value.tagName === 'string'
-              ? value.tagName
-              : // `xast`
-              typeof value.name === 'string'
-              ? value.name
-              : undefined
-
-          Object.defineProperty(visit, 'name', {
-            value:
-              'node (' + color_browser_color(node.type + (name ? '<' + name + '>' : '')) + ')'
-          })
-        }
-
-        return visit
-
-        function visit() {
-          /** @type {ActionTuple} */
-          let result = []
-          /** @type {ActionTuple} */
-          let subresult
-          /** @type {number} */
-          let offset
-          /** @type {Array<Parent>} */
-          let grandparents
-
-          if (!test || is(node, index, parents[parents.length - 1] || null)) {
-            result = lib_toResult(visitor(node, parents))
-
-            if (result[0] === lib_EXIT) {
-              return result
-            }
-          }
-
-          // @ts-expect-error looks like a parent.
-          if (node.children && result[0] !== lib_SKIP) {
-            // @ts-expect-error looks like a parent.
-            offset = (reverse ? node.children.length : -1) + step
-            // @ts-expect-error looks like a parent.
-            grandparents = parents.concat(node)
-
-            // @ts-expect-error looks like a parent.
-            while (offset > -1 && offset < node.children.length) {
-              // @ts-expect-error looks like a parent.
-              subresult = factory(node.children[offset], offset, grandparents)()
-
-              if (subresult[0] === lib_EXIT) {
-                return subresult
-              }
-
-              offset =
-                typeof subresult[1] === 'number' ? subresult[1] : offset + step
-            }
-          }
-
-          return result
-        }
-      }
-    }
-  )
-
-/**
- * Turn a return value into a clean result.
- *
- * @param {VisitorResult} value
- *   Valid return values from visitors.
- * @returns {ActionTuple}
- *   Clean result.
- */
-function lib_toResult(value) {
-  if (Array.isArray(value)) {
-    return value
-  }
-
-  if (typeof value === 'number') {
-    return [lib_CONTINUE, value]
-  }
-
-  return [value]
-}
-
-;// CONCATENATED MODULE: ../node_modules/rehype-prism-plus/node_modules/unist-util-visit/lib/index.js
-/**
- * @typedef {import('unist').Node} Node
- * @typedef {import('unist').Parent} Parent
- * @typedef {import('unist-util-is').Test} Test
- * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult
- */
-
-/**
- * Check if `Child` can be a child of `Ancestor`.
- *
- * Returns the ancestor when `Child` can be a child of `Ancestor`, or returns
- * `never`.
- *
- * @template {Node} Ancestor
- *   Node type.
- * @template {Node} Child
- *   Node type.
- * @typedef {(
- *   Ancestor extends Parent
- *     ? Child extends Ancestor['children'][number]
- *       ? Ancestor
- *       : never
- *     : never
- * )} ParentsOf
- */
-
-/**
- * @template {Node} [Visited=Node]
- *   Visited node type.
- * @template {Parent} [Ancestor=Parent]
- *   Ancestor type.
- * @callback Visitor
- *   Handle a node (matching `test`, if given).
- *
- *   Visitors are free to transform `node`.
- *   They can also transform `parent`.
- *
- *   Replacing `node` itself, if `SKIP` is not returned, still causes its
- *   descendants to be walked (which is a bug).
- *
- *   When adding or removing previous siblings of `node` (or next siblings, in
- *   case of reverse), the `Visitor` should return a new `Index` to specify the
- *   sibling to traverse after `node` is traversed.
- *   Adding or removing next siblings of `node` (or previous siblings, in case
- *   of reverse) is handled as expected without needing to return a new `Index`.
- *
- *   Removing the children property of `parent` still results in them being
- *   traversed.
- * @param {Visited} node
- *   Found node.
- * @param {Visited extends Node ? number | null : never} index
- *   Index of `node` in `parent`.
- * @param {Ancestor extends Node ? Ancestor | null : never} parent
- *   Parent of `node`.
- * @returns {VisitorResult}
- *   What to do next.
- *
- *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.
- *   An `Action` is treated as a tuple of `[Action]`.
- *
- *   Passing a tuple back only makes sense if the `Action` is `SKIP`.
- *   When the `Action` is `EXIT`, that action can be returned.
- *   When the `Action` is `CONTINUE`, `Index` can be returned.
- */
-
-/**
- * Build a typed `Visitor` function from a node and all possible parents.
- *
- * It will infer which values are passed as `node` and which as `parent`.
- *
- * @template {Node} Visited
- *   Node type.
- * @template {Parent} Ancestor
- *   Parent type.
- * @typedef {Visitor<Visited, ParentsOf<Ancestor, Visited>>} BuildVisitorFromMatch
- */
-
-/**
- * Build a typed `Visitor` function from a list of descendants and a test.
- *
- * It will infer which values are passed as `node` and which as `parent`.
- *
- * @template {Node} Descendant
- *   Node type.
- * @template {Test} Check
- *   Test type.
- * @typedef {(
- *   BuildVisitorFromMatch<
- *     import('unist-util-visit-parents/complex-types.js').Matches<Descendant, Check>,
- *     Extract<Descendant, Parent>
- *   >
- * )} BuildVisitorFromDescendants
- */
-
-/**
- * Build a typed `Visitor` function from a tree and a test.
- *
- * It will infer which values are passed as `node` and which as `parent`.
- *
- * @template {Node} [Tree=Node]
- *   Node type.
- * @template {Test} [Check=string]
- *   Test type.
- * @typedef {(
- *   BuildVisitorFromDescendants<
- *     import('unist-util-visit-parents/complex-types.js').InclusiveDescendant<Tree>,
- *     Check
- *   >
- * )} BuildVisitor
- */
-
-
-
-/**
- * Visit nodes.
- *
- * This algorithm performs *depth-first* *tree traversal* in *preorder*
- * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).
- *
- * You can choose for which nodes `visitor` is called by passing a `test`.
- * For complex tests, you should test yourself in `visitor`, as it will be
- * faster and will have improved type information.
- *
- * Walking the tree is an intensive task.
- * Make use of the return values of the visitor when possible.
- * Instead of walking a tree multiple times, walk it once, use `unist-util-is`
- * to check if a node matches, and then perform different operations.
- *
- * You can change the tree.
- * See `Visitor` for more info.
- *
- * @param tree
- *   Tree to traverse.
- * @param test
- *   `unist-util-is`-compatible test
- * @param visitor
- *   Handle each node.
- * @param reverse
- *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).
- * @returns
- *   Nothing.
- */
-const lib_visit =
-  /**
-   * @type {(
-   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: BuildVisitor<Tree, Check>, reverse?: boolean | null | undefined) => void) &
-   *   (<Tree extends Node>(tree: Tree, visitor: BuildVisitor<Tree>, reverse?: boolean | null | undefined) => void)
-   * )}
-   */
-  (
-    /**
-     * @param {Node} tree
-     * @param {Test} test
-     * @param {Visitor} visitor
-     * @param {boolean | null | undefined} [reverse]
-     * @returns {void}
-     */
-    function (tree, test, visitor, reverse) {
-      if (typeof test === 'function' && typeof visitor !== 'function') {
-        reverse = visitor
-        visitor = test
-        test = null
-      }
-
-      lib_visitParents(tree, test, overload, reverse)
-
-      /**
-       * @param {Node} node
-       * @param {Array<Parent>} parents
-       */
-      function overload(node, parents) {
-        const parent = parents[parents.length - 1]
-        return visitor(
-          node,
-          parent ? parent.children.indexOf(node) : null,
-          parent
-        )
-      }
-    }
-  )
-
-
-
-;// CONCATENATED MODULE: ../node_modules/rehype-prism-plus/node_modules/hast-util-to-string/index.js
-/**
- * @fileoverview
- *   Get the plain-text value of a hast node.
- * @longdescription
- *   ## Use
- *
- *   ```js
- *   import {h} from 'hastscript'
- *   import {toString} from 'hast-util-to-string'
- *
- *   toString(h('p', 'Alpha'))
- *   //=> 'Alpha'
- *   toString(h('div', [h('b', 'Bold'), ' and ', h('i', 'italic'), '.']))
- *   //=> 'Bold and italic.'
- *   ```
- *
- *   ## API
- *
- *   ### `toString(node)`
- *
- *   Transform a node to a string.
- */
-
-/**
- * @typedef {import('hast').Root} Root
- * @typedef {import('hast').Element} Element
- * @typedef {Root|Root['children'][number]} Node
- */
-
-/**
- * Get the plain-text value of a hast node.
- *
- * @param {Node} node
- * @returns {string}
- */
-function hast_util_to_string_toString(node) {
-  // “The concatenation of data of all the Text node descendants of the context
-  // object, in tree order.”
-  if ('children' in node) {
-    return hast_util_to_string_all(node)
-  }
-
-  // “Context object’s data.”
-  return 'value' in node ? node.value : ''
-}
-
-/**
- * @param {Node} node
- * @returns {string}
- */
-function hast_util_to_string_one(node) {
-  if (node.type === 'text') {
-    return node.value
-  }
-
-  return 'children' in node ? hast_util_to_string_all(node) : ''
-}
-
-/**
- * @param {Root|Element} node
- * @returns {string}
- */
-function hast_util_to_string_all(node) {
-  let index = -1
-  /** @type {string[]} */
-  const result = []
-
-  while (++index < node.children.length) {
-    result[index] = hast_util_to_string_one(node.children[index])
-  }
-
-  return result.join('')
-}
-
-;// CONCATENATED MODULE: ../node_modules/unist-util-filter/node_modules/unist-util-is/lib/index.js
-/**
- * @typedef {import('unist').Node} Node
- * @typedef {import('unist').Parent} Parent
- */
-
-/**
- * @typedef {Record<string, unknown>} Props
- * @typedef {null | undefined | string | Props | TestFunctionAnything | Array<string | Props | TestFunctionAnything>} Test
- *   Check for an arbitrary node, unaware of TypeScript inferral.
- *
- * @callback TestFunctionAnything
- *   Check if a node passes a test, unaware of TypeScript inferral.
- * @param {unknown} this
- *   The given context.
- * @param {Node} node
- *   A node.
- * @param {number | null | undefined} [index]
- *   The node’s position in its parent.
- * @param {Parent | null | undefined} [parent]
- *   The node’s parent.
- * @returns {boolean | void}
- *   Whether this node passes the test.
- */
-
-/**
- * @template {Node} Kind
- *   Node type.
- * @typedef {Kind['type'] | Partial<Kind> | TestFunctionPredicate<Kind> | Array<Kind['type'] | Partial<Kind> | TestFunctionPredicate<Kind>>} PredicateTest
- *   Check for a node that can be inferred by TypeScript.
- */
-
-/**
- * Check if a node passes a certain test.
- *
- * @template {Node} Kind
- *   Node type.
- * @callback TestFunctionPredicate
- *   Complex test function for a node that can be inferred by TypeScript.
- * @param {Node} node
- *   A node.
- * @param {number | null | undefined} [index]
- *   The node’s position in its parent.
- * @param {Parent | null | undefined} [parent]
- *   The node’s parent.
- * @returns {node is Kind}
- *   Whether this node passes the test.
- */
-
-/**
- * @callback AssertAnything
- *   Check that an arbitrary value is a node, unaware of TypeScript inferral.
- * @param {unknown} [node]
- *   Anything (typically a node).
- * @param {number | null | undefined} [index]
- *   The node’s position in its parent.
- * @param {Parent | null | undefined} [parent]
- *   The node’s parent.
- * @returns {boolean}
- *   Whether this is a node and passes a test.
- */
-
-/**
- * Check if a node is a node and passes a certain node test.
- *
- * @template {Node} Kind
- *   Node type.
- * @callback AssertPredicate
- *   Check that an arbitrary value is a specific node, aware of TypeScript.
- * @param {unknown} [node]
- *   Anything (typically a node).
- * @param {number | null | undefined} [index]
- *   The node’s position in its parent.
- * @param {Parent | null | undefined} [parent]
- *   The node’s parent.
- * @returns {node is Kind}
- *   Whether this is a node and passes a test.
- */
-
-/**
- * Check if `node` is a `Node` and whether it passes the given test.
- *
- * @param node
- *   Thing to check, typically `Node`.
- * @param test
- *   A check for a specific node.
- * @param index
- *   The node’s position in its parent.
- * @param parent
- *   The node’s parent.
- * @returns
- *   Whether `node` is a node and passes a test.
- */
-const unist_util_is_lib_is =
-  /**
-   * @type {(
-   *   (() => false) &
-   *   (<Kind extends Node = Node>(node: unknown, test: PredicateTest<Kind>, index: number, parent: Parent, context?: unknown) => node is Kind) &
-   *   (<Kind extends Node = Node>(node: unknown, test: PredicateTest<Kind>, index?: null | undefined, parent?: null | undefined, context?: unknown) => node is Kind) &
-   *   ((node: unknown, test: Test, index: number, parent: Parent, context?: unknown) => boolean) &
-   *   ((node: unknown, test?: Test, index?: null | undefined, parent?: null | undefined, context?: unknown) => boolean)
-   * )}
-   */
-  (
-    /**
-     * @param {unknown} [node]
-     * @param {Test} [test]
-     * @param {number | null | undefined} [index]
-     * @param {Parent | null | undefined} [parent]
-     * @param {unknown} [context]
-     * @returns {boolean}
-     */
-    // eslint-disable-next-line max-params
-    function is(node, test, index, parent, context) {
-      const check = unist_util_is_lib_convert(test)
-
-      if (
-        index !== undefined &&
-        index !== null &&
-        (typeof index !== 'number' ||
-          index < 0 ||
-          index === Number.POSITIVE_INFINITY)
-      ) {
-        throw new Error('Expected positive finite index')
-      }
-
-      if (
-        parent !== undefined &&
-        parent !== null &&
-        (!is(parent) || !parent.children)
-      ) {
-        throw new Error('Expected parent node')
-      }
-
-      if (
-        (parent === undefined || parent === null) !==
-        (index === undefined || index === null)
-      ) {
-        throw new Error('Expected both parent and index')
-      }
-
-      // @ts-expect-error Looks like a node.
-      return node && node.type && typeof node.type === 'string'
-        ? Boolean(check.call(context, node, index, parent))
-        : false
-    }
-  )
-
+;// CONCATENATED MODULE: ../node_modules/hast-util-to-string/lib/index.js
 /**
- * Generate an assertion from a test.
- *
- * Useful if you’re going to test many nodes, for example when creating a
- * utility where something else passes a compatible test.
- *
- * The created function is a bit faster because it expects valid input only:
- * a `node`, `index`, and `parent`.
- *
- * @param test
- *   *   when nullish, checks if `node` is a `Node`.
- *   *   when `string`, works like passing `(node) => node.type === test`.
- *   *   when `function` checks if function passed the node is true.
- *   *   when `object`, checks that all keys in test are in node, and that they have (strictly) equal values.
- *   *   when `array`, checks if any one of the subtests pass.
- * @returns
- *   An assertion.
+ * @typedef {import('hast').Nodes} Nodes
+ * @typedef {import('hast').Parents} Parents
  */
-const unist_util_is_lib_convert =
-  /**
-   * @type {(
-   *   (<Kind extends Node>(test: PredicateTest<Kind>) => AssertPredicate<Kind>) &
-   *   ((test?: Test) => AssertAnything)
-   * )}
-   */
-  (
-    /**
-     * @param {Test} [test]
-     * @returns {AssertAnything}
-     */
-    function (test) {
-      if (test === undefined || test === null) {
-        return node_modules_unist_util_is_lib_ok
-      }
-
-      if (typeof test === 'string') {
-        return unist_util_is_lib_typeFactory(test)
-      }
-
-      if (typeof test === 'object') {
-        return Array.isArray(test) ? unist_util_is_lib_anyFactory(test) : unist_util_is_lib_propsFactory(test)
-      }
-
-      if (typeof test === 'function') {
-        return unist_util_is_lib_castFactory(test)
-      }
-
-      throw new Error('Expected function, string, or object as test')
-    }
-  )
 
 /**
- * @param {Array<string | Props | TestFunctionAnything>} tests
- * @returns {AssertAnything}
+ * Get the plain-text value of a hast node.
+ *
+ * @param {Nodes} node
+ *   Node to serialize.
+ * @returns {string}
+ *   Serialized node.
  */
-function unist_util_is_lib_anyFactory(tests) {
-  /** @type {Array<AssertAnything>} */
-  const checks = []
-  let index = -1
-
-  while (++index < tests.length) {
-    checks[index] = unist_util_is_lib_convert(tests[index])
+function hast_util_to_string_lib_toString(node) {
+  // “The concatenation of data of all the Text node descendants of the context
+  // object, in tree order.”
+  if ('children' in node) {
+    return hast_util_to_string_lib_all(node)
   }
 
-  return unist_util_is_lib_castFactory(any)
-
-  /**
-   * @this {unknown}
-   * @param {Array<unknown>} parameters
-   * @returns {boolean}
-   */
-  function any(...parameters) {
-    let index = -1
-
-    while (++index < checks.length) {
-      if (checks[index].call(this, ...parameters)) return true
-    }
-
-    return false
-  }
+  // “Context object’s data.”
+  return 'value' in node ? node.value : ''
 }
 
 /**
- * Turn an object into a test for a node with a certain fields.
- *
- * @param {Props} check
- * @returns {AssertAnything}
+ * @param {Nodes} node
+ *   Node.
+ * @returns {string}
+ *   Serialized node.
  */
-function unist_util_is_lib_propsFactory(check) {
-  return unist_util_is_lib_castFactory(all)
-
-  /**
-   * @param {Node} node
-   * @returns {boolean}
-   */
-  function all(node) {
-    /** @type {string} */
-    let key
-
-    for (key in check) {
-      // @ts-expect-error: hush, it sure works as an index.
-      if (node[key] !== check[key]) return false
-    }
-
-    return true
+function hast_util_to_string_lib_one(node) {
+  if (node.type === 'text') {
+    return node.value
   }
-}
-
-/**
- * Turn a string into a test for a node with a certain type.
- *
- * @param {string} check
- * @returns {AssertAnything}
- */
-function unist_util_is_lib_typeFactory(check) {
-  return unist_util_is_lib_castFactory(type)
 
-  /**
-   * @param {Node} node
-   */
-  function type(node) {
-    return node && node.type === check
-  }
+  return 'children' in node ? hast_util_to_string_lib_all(node) : ''
 }
 
 /**
- * Turn a custom test into a test for a node that passes that test.
- *
- * @param {TestFunctionAnything} check
- * @returns {AssertAnything}
+ * @param {Parents} node
+ *   Node.
+ * @returns {string}
+ *   Serialized node.
  */
-function unist_util_is_lib_castFactory(check) {
-  return assertion
+function hast_util_to_string_lib_all(node) {
+  let index = -1
+  /** @type {Array<string>} */
+  const result = []
 
-  /**
-   * @this {unknown}
-   * @param {unknown} node
-   * @param {Array<unknown>} parameters
-   * @returns {boolean}
-   */
-  function assertion(node, ...parameters) {
-    return Boolean(
-      node &&
-        typeof node === 'object' &&
-        'type' in node &&
-        // @ts-expect-error: fine.
-        Boolean(check.call(this, node, ...parameters))
-    )
+  while (++index < node.children.length) {
+    result[index] = hast_util_to_string_lib_one(node.children[index])
   }
-}
 
-function node_modules_unist_util_is_lib_ok() {
-  return true
+  return result.join('')
 }
 
 ;// CONCATENATED MODULE: ../node_modules/unist-util-filter/lib/index.js
 /**
  * @typedef {import('unist').Node} Node
  * @typedef {import('unist').Parent} Parent
- * @typedef {import('unist-util-is').Test} Test
  *
+ * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test
+ *   Test from `unist-util-is`.
+ *
+ *   Note: we have remove and add `undefined`, because otherwise when generating
+ *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,
+ *   which doesn’t work when publishing on npm.
+ */
+
+/**
  * @typedef Options
  *   Configuration (optional).
  * @property {boolean | null | undefined} [cascade=true]
  *   Whether to drop parent nodes if they had children, but all their children
- *   were filtered out.
+ *   were filtered out (default: `true`).
  */
 
 
@@ -42755,98 +41703,105 @@ const unist_util_filter_lib_own = {}.hasOwnProperty
  * The tree is walked in *preorder* (NLR), visiting the node itself, then its
  * head, etc.
  *
- * @param tree
+ * @template {Node} Tree
+ * @template {Test} Check
+ *
+ * @overload
+ * @param {Tree} tree
+ * @param {Options | null | undefined} options
+ * @param {Check} test
+ * @returns {import('./complex-types.js').Matches<Tree, Check>}
+ *
+ * @overload
+ * @param {Tree} tree
+ * @param {Check} test
+ * @returns {import('./complex-types.js').Matches<Tree, Check>}
+ *
+ * @overload
+ * @param {Tree} tree
+ * @param {null | undefined} [options]
+ * @returns {Tree}
+ *
+ * @param {Node} tree
  *   Tree to filter.
- * @param options
+ * @param {Options | Test} [options]
  *   Configuration (optional).
- * @param test
+ * @param {Test} [test]
  *   `unist-util-is` compatible test.
- * @returns
+ * @returns {Node | undefined}
  *   New filtered tree.
  *
- *   `null` is returned if `tree` itself didn’t pass the test, or is cascaded
- *   away.
+ *   `undefined` is returned if `tree` itself didn’t pass the test, or is
+ *   cascaded away.
  */
-const filter =
-  /**
-   * @type {(
-   *  (<Tree extends Node, Check extends Test>(node: Tree, options: Options | null | undefined, test: Check | null | undefined) => import('./complex-types.js').Matches<Tree, Check>) &
-   *  (<Tree extends Node, Check extends Test>(node: Tree, test: Check) => import('./complex-types.js').Matches<Tree, Check>) &
-   *  (<Tree extends Node>(node: Tree, options?: Options | null | undefined) => Tree)
-   * )}
-   */
-  (
-    /**
-     * @param {Node} tree
-     * @param {Options | Test | null | undefined} [options]
-     * @param {Test | null | undefined} [test]
-     * @returns {Node | null}
-     */
-    function (tree, options, test) {
-      const is = unist_util_is_lib_convert(test || options)
-      /** @type {boolean | null | undefined} */
-      const cascadeRaw =
-        options && typeof options === 'object' && 'cascade' in options
-          ? /** @type {boolean | null | undefined} */ (options.cascade)
-          : undefined
-      const cascade =
-        cascadeRaw === undefined || cascadeRaw === null ? true : cascadeRaw
-
-      return preorder(tree)
+function filter(tree, options, test) {
+  const is = convert(test || options)
+  const cascadeRaw =
+    options && typeof options === 'object' && 'cascade' in options
+      ? /** @type {boolean | null | undefined} */ (options.cascade)
+      : undefined
+  const cascade =
+    cascadeRaw === undefined || cascadeRaw === null ? true : cascadeRaw
 
-      /**
-       * @param {Node} node
-       *   Current node.
-       * @param {number | undefined} [index]
-       *   Index of `node` in `parent`.
-       * @param {Parent | undefined} [parent]
-       *   Parent node.
-       * @returns {Node | null}
-       *   Shallow copy of `node`.
-       */
-      function preorder(node, index, parent) {
-        /** @type {Array<Node>} */
-        const children = []
+  return preorder(tree)
 
-        if (!is(node, index, parent)) return null
+  /**
+   * @param {Node} node
+   *   Current node.
+   * @param {number | undefined} [index]
+   *   Index of `node` in `parent`.
+   * @param {Parent | undefined} [parentNode]
+   *   Parent node.
+   * @returns {Node | undefined}
+   *   Shallow copy of `node`.
+   */
+  function preorder(node, index, parentNode) {
+    /** @type {Array<Node>} */
+    const children = []
 
-        // @ts-expect-error: Looks like a parent.
-        if (node.children) {
-          let childIndex = -1
+    if (!is(node, index, parentNode)) return undefined
 
-          // @ts-expect-error Looks like a parent.
-          while (++childIndex < node.children.length) {
-            // @ts-expect-error Looks like a parent.
-            const result = preorder(node.children[childIndex], childIndex, node)
+    if (lib_parent(node)) {
+      let childIndex = -1
 
-            if (result) {
-              children.push(result)
-            }
-          }
+      while (++childIndex < node.children.length) {
+        const result = preorder(node.children[childIndex], childIndex, node)
 
-          // @ts-expect-error Looks like a parent.
-          if (cascade && node.children.length > 0 && children.length === 0)
-            return null
+        if (result) {
+          children.push(result)
         }
+      }
 
-        // Create a shallow clone, using the new children.
-        /** @type {typeof node} */
-        // @ts-expect-error all the fields will be copied over.
-        const next = {}
-        /** @type {string} */
-        let key
+      if (cascade && node.children.length > 0 && children.length === 0) {
+        return undefined
+      }
+    }
 
-        for (key in node) {
-          if (unist_util_filter_lib_own.call(node, key)) {
-            // @ts-expect-error: Looks like a record.
-            next[key] = key === 'children' ? children : node[key]
-          }
-        }
+    // Create a shallow clone, using the new children.
+    /** @type {typeof node} */
+    // @ts-expect-error all the fields will be copied over.
+    const next = {}
+    /** @type {string} */
+    let key
 
-        return next
+    for (key in node) {
+      if (unist_util_filter_lib_own.call(node, key)) {
+        // @ts-expect-error: Looks like a record.
+        next[key] = key === 'children' ? children : node[key]
       }
     }
-  )
+
+    return next
+  }
+}
+
+/**
+ * @param {Node} node
+ * @returns {node is Parent}
+ */
+function lib_parent(node) {
+  return 'children' in node && node.children !== undefined
+}
 
 // EXTERNAL MODULE: ../node_modules/parse-numeric-range/index.js
 var parse_numeric_range = __webpack_require__(324);
@@ -70175,7 +69130,7 @@ refractor.register(zig)
 
 
 ;// CONCATENATED MODULE: ../node_modules/rehype-prism-plus/dist/index.es.js
-function a(){a=function(e,r){return new t(e,void 0,r)};var e=RegExp.prototype,r=new WeakMap;function t(e,n,i){var o=new RegExp(e,n);return r.set(o,i||r.get(e)),l(o,t.prototype)}function n(e,t){var n=r.get(t);return Object.keys(n).reduce(function(r,t){var i=n[t];if("number"==typeof i)r[t]=e[i];else{for(var o=0;void 0===e[i[o]]&&o+1<i.length;)o++;r[t]=e[i[o]]}return r},Object.create(null))}return function(e,r){if("function"!=typeof r&&null!==r)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(r&&r.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),Object.defineProperty(e,"prototype",{writable:!1}),r&&l(e,r)}(t,RegExp),t.prototype.exec=function(r){var t=e.exec.call(this,r);if(t){t.groups=n(t,this);var i=t.indices;i&&(i.groups=n(i,this))}return t},t.prototype[Symbol.replace]=function(t,i){if("string"==typeof i){var o=r.get(this);return e[Symbol.replace].call(this,t,i.replace(/\$<([^>]+)>/g,function(e,r){var t=o[r];return"$"+(Array.isArray(t)?t.join("$"):t)}))}if("function"==typeof i){var a=this;return e[Symbol.replace].call(this,t,function(){var e=arguments;return"object"!=typeof e[e.length-1]&&(e=[].slice.call(e)).push(n(e,a)),i.apply(this,e)})}return e[Symbol.replace].call(this,t,i)},a.apply(this,arguments)}function l(e,r){return l=Object.setPrototypeOf?Object.setPrototypeOf.bind():function(e,r){return e.__proto__=r,e},l(e,r)}function index_es_s(e,r){(null==r||r>e.length)&&(r=e.length);for(var t=0,n=new Array(r);t<r;t++)n[t]=e[t];return n}function u(e,r){var t="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(t)return(t=t.call(e)).next.bind(t);if(Array.isArray(e)||(t=function(e,r){if(e){if("string"==typeof e)return index_es_s(e,r);var t=Object.prototype.toString.call(e).slice(8,-1);return"Object"===t&&e.constructor&&(t=e.constructor.name),"Map"===t||"Set"===t?Array.from(e):"Arguments"===t||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)?index_es_s(e,r):void 0}}(e))||r&&e&&"number"==typeof e.length){t&&(e=t);var n=0;return function(){return n>=e.length?{done:!0}:{done:!1,value:e[n++]}}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var index_es_c=function(i){return function(o){return void 0===o&&(o={}),function(e,r){if(r&&!e.registered(r))throw new Error('The default language "'+r+'" is not registered with refractor.')}(i,o.defaultLanguage),function(r){lib_visit(r,"element",l)};function l(e,l,s){var c,p;if(s&&"pre"===s.tagName&&"code"===e.tagName){var f=(null==e||null==(c=e.data)?void 0:c.meta)||(null==e||null==(p=e.properties)?void 0:p.metastring)||"";e.properties.className?"boolean"==typeof e.properties.className?e.properties.className=[]:Array.isArray(e.properties.className)||(e.properties.className=[e.properties.className]):e.properties.className=[];var m,h,d=function(e){for(var r,t=u(e.properties.className);!(r=t()).done;){var n=r.value;if("language-"===n.slice(0,9))return n.slice(9).toLowerCase()}return null}(e);if(!d&&o.defaultLanguage&&e.properties.className.push("language-"+(d=o.defaultLanguage)),e.properties.className.push("code-highlight"),d)try{var g,v;v=null!=(g=d)&&g.includes("diff-")?d.split("-")[1]:d,m=i.highlight(hast_util_to_string_toString(e),v),s.properties.className=(s.properties.className||[]).concat("language-"+v)}catch(r){if(!o.ignoreMissing||!/Unknown language/.test(r.message))throw r;m=e}else m=e;m.children=(h=1,function e(r){return r.reduce(function(r,t){if("text"===t.type){var n=t.value,i=(n.match(/\n/g)||"").length;if(0===i)t.position={start:{line:h,column:1},end:{line:h,column:1}},r.push(t);else for(var o,a=n.split("\n"),l=u(a.entries());!(o=l()).done;){var s=o.value,c=s[0],p=s[1];r.push({type:"text",value:c===a.length-1?p:p+"\n",position:{start:{line:h+c,column:1},end:{line:h+c,column:1}}})}return h+=i,r}if(Object.prototype.hasOwnProperty.call(t,"children")){var f=h;return t.children=e(t.children),r.push(t),t.position={start:{line:f,column:1},end:{line:h,column:1}},r}return r.push(t),r},[])})(m.children),m.position=m.children.length>0?{start:{line:m.children[0].position.start.line,column:0},end:{line:m.children[m.children.length-1].position.end.line,column:0}}:{start:{line:0,column:0},end:{line:0,column:0}};for(var y,b=function(e){var r=/{([\d,-]+)}/,t=e.split(",").map(function(e){return e.trim()}).join();if(r.test(t)){var i=r.exec(t)[1],o=parse_numeric_range(i);return function(e){return o.includes(e+1)}}return function(){return!1}}(f),w=function(e){var r=/*#__PURE__*/a(/showLineNumbers=(\d+)/i,{lines:1});if(r.test(e)){var t=r.exec(e);return Number(t.groups.lines)}return 1}(f),N=function(e){for(var r=new Array(e),t=0;t<e;t++)r[t]={type:"element",tagName:"span",properties:{className:[]},children:[]};return r}(m.position.end.line),j=["showlinenumbers=false",'showlinenumbers="false"',"showlinenumbers={false}"],x=function(){var e,n,i=y.value,a=i[0],l=i[1];l.properties.className=["code-line"];var s=filter(m,function(e){return e.position.start.line<=a+1&&e.position.end.line>=a+1});l.children=s.children,!f.toLowerCase().includes("showLineNumbers".toLowerCase())&&!o.showLineNumbers||j.some(function(e){return f.toLowerCase().includes(e)})||(l.properties.line=[(a+w).toString()],l.properties.className.push("line-number")),b(a)&&l.properties.className.push("highlight-line"),("diff"===d||null!=(e=d)&&e.includes("diff-"))&&"-"===hast_util_to_string_toString(l).substring(0,1)?l.properties.className.push("deleted"):("diff"===d||null!=(n=d)&&n.includes("diff-"))&&"+"===hast_util_to_string_toString(l).substring(0,1)&&l.properties.className.push("inserted")},O=u(N.entries());!(y=O()).done;)x();N.length>0&&""===hast_util_to_string_toString(N[N.length-1]).trim()&&N.pop(),e.children=N}}}},p=index_es_c(refractor),f=index_es_c(refractor);
+function a(){a=function(e,r){return new t(e,void 0,r)};var e=RegExp.prototype,r=new WeakMap;function t(e,n,i){var o=new RegExp(e,n);return r.set(o,i||r.get(e)),l(o,t.prototype)}function n(e,t){var n=r.get(t);return Object.keys(n).reduce(function(r,t){var i=n[t];if("number"==typeof i)r[t]=e[i];else{for(var o=0;void 0===e[i[o]]&&o+1<i.length;)o++;r[t]=e[i[o]]}return r},Object.create(null))}return function(e,r){if("function"!=typeof r&&null!==r)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(r&&r.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),Object.defineProperty(e,"prototype",{writable:!1}),r&&l(e,r)}(t,RegExp),t.prototype.exec=function(r){var t=e.exec.call(this,r);if(t){t.groups=n(t,this);var i=t.indices;i&&(i.groups=n(i,this))}return t},t.prototype[Symbol.replace]=function(t,i){if("string"==typeof i){var o=r.get(this);return e[Symbol.replace].call(this,t,i.replace(/\$<([^>]+)>/g,function(e,r){var t=o[r];return"$"+(Array.isArray(t)?t.join("$"):t)}))}if("function"==typeof i){var a=this;return e[Symbol.replace].call(this,t,function(){var e=arguments;return"object"!=typeof e[e.length-1]&&(e=[].slice.call(e)).push(n(e,a)),i.apply(this,e)})}return e[Symbol.replace].call(this,t,i)},a.apply(this,arguments)}function l(e,r){return l=Object.setPrototypeOf?Object.setPrototypeOf.bind():function(e,r){return e.__proto__=r,e},l(e,r)}function index_es_s(e,r){(null==r||r>e.length)&&(r=e.length);for(var t=0,n=new Array(r);t<r;t++)n[t]=e[t];return n}function u(e,r){var t="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(t)return(t=t.call(e)).next.bind(t);if(Array.isArray(e)||(t=function(e,r){if(e){if("string"==typeof e)return index_es_s(e,r);var t=Object.prototype.toString.call(e).slice(8,-1);return"Object"===t&&e.constructor&&(t=e.constructor.name),"Map"===t||"Set"===t?Array.from(e):"Arguments"===t||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)?index_es_s(e,r):void 0}}(e))||r&&e&&"number"==typeof e.length){t&&(e=t);var n=0;return function(){return n>=e.length?{done:!0}:{done:!1,value:e[n++]}}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var index_es_c=function(i){return function(o){return void 0===o&&(o={}),function(e,r){if(r&&!e.registered(r))throw new Error('The default language "'+r+'" is not registered with refractor.')}(i,o.defaultLanguage),function(r){visit(r,"element",l)};function l(e,l,s){var c,p;if(s&&"pre"===s.tagName&&"code"===e.tagName){var f=(null==e||null==(c=e.data)?void 0:c.meta)||(null==e||null==(p=e.properties)?void 0:p.metastring)||"";e.properties.className?"boolean"==typeof e.properties.className?e.properties.className=[]:Array.isArray(e.properties.className)||(e.properties.className=[e.properties.className]):e.properties.className=[];var m,h,d=function(e){for(var r,t=u(e.properties.className);!(r=t()).done;){var n=r.value;if("language-"===n.slice(0,9))return n.slice(9).toLowerCase()}return null}(e);if(!d&&o.defaultLanguage&&e.properties.className.push("language-"+(d=o.defaultLanguage)),e.properties.className.push("code-highlight"),d)try{var g,v;v=null!=(g=d)&&g.includes("diff-")?d.split("-")[1]:d,m=i.highlight(hast_util_to_string_lib_toString(e),v),s.properties.className=(s.properties.className||[]).concat("language-"+v)}catch(r){if(!o.ignoreMissing||!/Unknown language/.test(r.message))throw r;m=e}else m=e;m.children=(h=1,function e(r){return r.reduce(function(r,t){if("text"===t.type){var n=t.value,i=(n.match(/\n/g)||"").length;if(0===i)t.position={start:{line:h,column:1},end:{line:h,column:1}},r.push(t);else for(var o,a=n.split("\n"),l=u(a.entries());!(o=l()).done;){var s=o.value,c=s[0],p=s[1];r.push({type:"text",value:c===a.length-1?p:p+"\n",position:{start:{line:h+c,column:1},end:{line:h+c,column:1}}})}return h+=i,r}if(Object.prototype.hasOwnProperty.call(t,"children")){var f=h;return t.children=e(t.children),r.push(t),t.position={start:{line:f,column:1},end:{line:h,column:1}},r}return r.push(t),r},[])})(m.children),m.position=m.children.length>0?{start:{line:m.children[0].position.start.line,column:0},end:{line:m.children[m.children.length-1].position.end.line,column:0}}:{start:{line:0,column:0},end:{line:0,column:0}};for(var y,b=function(e){var r=/{([\d,-]+)}/,t=e.split(",").map(function(e){return e.trim()}).join();if(r.test(t)){var i=r.exec(t)[1],o=parse_numeric_range(i);return function(e){return o.includes(e+1)}}return function(){return!1}}(f),w=function(e){var r=/*#__PURE__*/a(/showLineNumbers=(\d+)/i,{lines:1});if(r.test(e)){var t=r.exec(e);return Number(t.groups.lines)}return 1}(f),N=function(e){for(var r=new Array(e),t=0;t<e;t++)r[t]={type:"element",tagName:"span",properties:{className:[]},children:[]};return r}(m.position.end.line),j=["showlinenumbers=false",'showlinenumbers="false"',"showlinenumbers={false}"],x=function(){var e,n,i=y.value,a=i[0],l=i[1];l.properties.className=["code-line"];var s=filter(m,function(e){return e.position.start.line<=a+1&&e.position.end.line>=a+1});l.children=s.children,!f.toLowerCase().includes("showLineNumbers".toLowerCase())&&!o.showLineNumbers||j.some(function(e){return f.toLowerCase().includes(e)})||(l.properties.line=[(a+w).toString()],l.properties.className.push("line-number")),b(a)&&l.properties.className.push("highlight-line"),("diff"===d||null!=(e=d)&&e.includes("diff-"))&&"-"===hast_util_to_string_lib_toString(l).substring(0,1)?l.properties.className.push("deleted"):("diff"===d||null!=(n=d)&&n.includes("diff-"))&&"+"===hast_util_to_string_lib_toString(l).substring(0,1)&&l.properties.className.push("inserted")},O=u(N.entries());!(y=O()).done;)x();N.length>0&&""===hast_util_to_string_lib_toString(N[N.length-1]).trim()&&N.pop(),e.children=N}}}},p=index_es_c(refractor),f=index_es_c(refractor);
 //# sourceMappingURL=index.es.js.map
 
 ;// CONCATENATED MODULE: ../node_modules/css-selector-parser/dist/mjs/indexes.js
@@ -71644,63 +70599,6 @@ function direction(value) {
   return rtl.test(source) ? 'rtl' : ltr.test(source) ? 'ltr' : 'neutral'
 }
 
-;// CONCATENATED MODULE: ../node_modules/hast-util-to-string/lib/index.js
-/**
- * @typedef {import('hast').Nodes} Nodes
- * @typedef {import('hast').Parents} Parents
- */
-
-/**
- * Get the plain-text value of a hast node.
- *
- * @param {Nodes} node
- *   Node to serialize.
- * @returns {string}
- *   Serialized node.
- */
-function hast_util_to_string_lib_toString(node) {
-  // “The concatenation of data of all the Text node descendants of the context
-  // object, in tree order.”
-  if ('children' in node) {
-    return hast_util_to_string_lib_all(node)
-  }
-
-  // “Context object’s data.”
-  return 'value' in node ? node.value : ''
-}
-
-/**
- * @param {Nodes} node
- *   Node.
- * @returns {string}
- *   Serialized node.
- */
-function hast_util_to_string_lib_one(node) {
-  if (node.type === 'text') {
-    return node.value
-  }
-
-  return 'children' in node ? hast_util_to_string_lib_all(node) : ''
-}
-
-/**
- * @param {Parents} node
- *   Node.
- * @returns {string}
- *   Serialized node.
- */
-function hast_util_to_string_lib_all(node) {
-  let index = -1
-  /** @type {Array<string>} */
-  const result = []
-
-  while (++index < node.children.length) {
-    result[index] = hast_util_to_string_lib_one(node.children[index])
-  }
-
-  return result.join('')
-}
-
 ;// CONCATENATED MODULE: ../node_modules/hast-util-select/lib/enter-state.js
 /**
  * @typedef {import('hast').ElementContent} ElementContent
@@ -74394,11 +73292,11 @@ const convertElement =
 
       // Assume array.
       if (typeof test === 'object') {
-        return hast_util_is_element_lib_anyFactory(test)
+        return lib_anyFactory(test)
       }
 
       if (typeof test === 'function') {
-        return hast_util_is_element_lib_castFactory(test)
+        return lib_castFactory(test)
       }
 
       throw new Error('Expected function, string, or array as `test`')
@@ -74411,7 +73309,7 @@ const convertElement =
  * @param {Array<TestFunction | string>} tests
  * @returns {Check}
  */
-function hast_util_is_element_lib_anyFactory(tests) {
+function lib_anyFactory(tests) {
   /** @type {Array<Check>} */
   const checks = []
   let index = -1
@@ -74420,7 +73318,7 @@ function hast_util_is_element_lib_anyFactory(tests) {
     checks[index] = convertElement(tests[index])
   }
 
-  return hast_util_is_element_lib_castFactory(any)
+  return lib_castFactory(any)
 
   /**
    * @this {unknown}
@@ -74444,7 +73342,7 @@ function hast_util_is_element_lib_anyFactory(tests) {
  * @returns {Check}
  */
 function tagNameFactory(check) {
-  return hast_util_is_element_lib_castFactory(tagName)
+  return lib_castFactory(tagName)
 
   /**
    * @param {Element} element
@@ -74461,7 +73359,7 @@ function tagNameFactory(check) {
  * @param {TestFunction} testFunction
  * @returns {Check}
  */
-function hast_util_is_element_lib_castFactory(testFunction) {
+function lib_castFactory(testFunction) {
   return check
 
   /**