{"version":3,"file":"static/chunks/2369-715f93fabe0ee7c6.js","mappings":"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","sources":["webpack://_N_E/../../node_modules/extend/index.js","webpack://_N_E/../../node_modules/inline-style-parser/index.js","webpack://_N_E/../../node_modules/style-to-object/cjs/index.js","webpack://_N_E/../../node_modules/devlop/lib/default.js","webpack://_N_E/../../node_modules/comma-separated-tokens/index.js","webpack://_N_E/../../node_modules/estree-util-is-identifier-name/lib/index.js","webpack://_N_E/../../node_modules/hast-util-whitespace/lib/index.js","webpack://_N_E/../../node_modules/property-information/lib/util/schema.js","webpack://_N_E/../../node_modules/property-information/lib/util/merge.js","webpack://_N_E/../../node_modules/property-information/lib/normalize.js","webpack://_N_E/../../node_modules/property-information/lib/util/info.js","webpack://_N_E/../../node_modules/property-information/lib/util/types.js","webpack://_N_E/../../node_modules/property-information/lib/util/defined-info.js","webpack://_N_E/../../node_modules/property-information/lib/util/create.js","webpack://_N_E/../../node_modules/property-information/lib/xlink.js","webpack://_N_E/../../node_modules/property-information/lib/xml.js","webpack://_N_E/../../node_modules/property-information/lib/util/case-sensitive-transform.js","webpack://_N_E/../../node_modules/property-information/lib/util/case-insensitive-transform.js","webpack://_N_E/../../node_modules/property-information/lib/xmlns.js","webpack://_N_E/../../node_modules/property-information/lib/aria.js","webpack://_N_E/../../node_modules/property-information/lib/html.js","webpack://_N_E/../../node_modules/property-information/lib/svg.js","webpack://_N_E/../../node_modules/property-information/index.js","webpack://_N_E/../../node_modules/property-information/lib/find.js","webpack://_N_E/../../node_modules/property-information/lib/hast-to-react.js","webpack://_N_E/../../node_modules/space-separated-tokens/index.js","webpack://_N_E/../../node_modules/style-to-object/esm/index.mjs","webpack://_N_E/../../node_modules/unist-util-position/lib/index.js","webpack://_N_E/../../node_modules/unist-util-stringify-position/lib/index.js","webpack://_N_E/../../node_modules/vfile-message/lib/index.js","webpack://_N_E/../../node_modules/hast-util-to-jsx-runtime/lib/index.js","webpack://_N_E/../../node_modules/html-url-attributes/lib/index.js","webpack://_N_E/../../node_modules/mdast-util-to-string/lib/index.js","webpack://_N_E/../../node_modules/micromark-util-chunked/index.js","webpack://_N_E/../../node_modules/micromark-util-subtokenize/lib/splice-buffer.js","webpack://_N_E/../../node_modules/micromark-util-subtokenize/index.js","webpack://_N_E/../../node_modules/micromark/lib/postprocess.js","webpack://_N_E/../../node_modules/micromark-util-combine-extensions/index.js","webpack://_N_E/../../node_modules/micromark-util-character/index.js","webpack://_N_E/../../node_modules/micromark-factory-space/index.js","webpack://_N_E/../../node_modules/micromark/lib/initialize/content.js","webpack://_N_E/../../node_modules/micromark/lib/initialize/document.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/blank-line.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/content.js","webpack://_N_E/../../node_modules/micromark/lib/initialize/flow.js","webpack://_N_E/../../node_modules/micromark/lib/initialize/text.js","webpack://_N_E/../../node_modules/micromark-util-resolve-all/index.js","webpack://_N_E/../../node_modules/micromark/lib/create-tokenizer.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/thematic-break.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/list.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/block-quote.js","webpack://_N_E/../../node_modules/micromark-factory-destination/index.js","webpack://_N_E/../../node_modules/micromark-factory-label/index.js","webpack://_N_E/../../node_modules/micromark-factory-title/index.js","webpack://_N_E/../../node_modules/micromark-factory-whitespace/index.js","webpack://_N_E/../../node_modules/micromark-util-normalize-identifier/index.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/definition.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/code-indented.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/heading-atx.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/setext-underline.js","webpack://_N_E/../../node_modules/micromark-util-html-tag-name/index.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/html-flow.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/code-fenced.js","webpack://_N_E/../../node_modules/decode-named-character-reference/index.dom.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/character-reference.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/character-escape.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/line-ending.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/label-end.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/label-start-image.js","webpack://_N_E/../../node_modules/micromark-util-classify-character/index.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/attention.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/autolink.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/html-text.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/label-start-link.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/hard-break-escape.js","webpack://_N_E/../../node_modules/micromark-core-commonmark/lib/code-text.js","webpack://_N_E/../../node_modules/micromark/lib/constructs.js","webpack://_N_E/../../node_modules/micromark/lib/parse.js","webpack://_N_E/../../node_modules/micromark/lib/preprocess.js","webpack://_N_E/../../node_modules/micromark-util-decode-numeric-character-reference/index.js","webpack://_N_E/../../node_modules/micromark-util-decode-string/index.js","webpack://_N_E/../../node_modules/mdast-util-from-markdown/lib/index.js","webpack://_N_E/../../node_modules/remark-parse/lib/index.js","webpack://_N_E/../../node_modules/@ungap/structured-clone/esm/types.js","webpack://_N_E/../../node_modules/@ungap/structured-clone/esm/deserialize.js","webpack://_N_E/../../node_modules/@ungap/structured-clone/esm/serialize.js","webpack://_N_E/../../node_modules/@ungap/structured-clone/esm/index.js","webpack://_N_E/../../node_modules/micromark-util-sanitize-uri/index.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/footer.js","webpack://_N_E/../../node_modules/unist-util-is/lib/index.js","webpack://_N_E/../../node_modules/unist-util-visit-parents/lib/color.js","webpack://_N_E/../../node_modules/unist-util-visit-parents/lib/index.js","webpack://_N_E/../../node_modules/unist-util-visit/lib/index.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/blockquote.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/break.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/code.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/delete.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/emphasis.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/heading.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/html.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/revert.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/image-reference.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/image.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/inline-code.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/link-reference.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/link.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/list-item.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/list.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/paragraph.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/root.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/strong.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/table.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/table-row.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/table-cell.js","webpack://_N_E/../../node_modules/trim-lines/index.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/text.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/handlers/index.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/state.js","webpack://_N_E/../../node_modules/mdast-util-to-hast/lib/index.js","webpack://_N_E/../../node_modules/remark-rehype/lib/index.js","webpack://_N_E/../../node_modules/bail/index.js","webpack://_N_E/../../node_modules/is-plain-obj/index.js","webpack://_N_E/../../node_modules/trough/lib/index.js","webpack://_N_E/../../node_modules/vfile/lib/minpath.browser.js","webpack://_N_E/../../node_modules/vfile/lib/minproc.browser.js","webpack://_N_E/../../node_modules/vfile/lib/minurl.shared.js","webpack://_N_E/../../node_modules/vfile/lib/minurl.browser.js","webpack://_N_E/../../node_modules/vfile/lib/index.js","webpack://_N_E/../../node_modules/unified/lib/callable-instance.js","webpack://_N_E/../../node_modules/unified/lib/index.js","webpack://_N_E/../../node_modules/react-markdown/lib/index.js","webpack://_N_E/<anon>"],"sourcesContent":["'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n\tif (typeof Array.isArray === 'function') {\n\t\treturn Array.isArray(arr);\n\t}\n\n\treturn toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n\tif (!obj || toStr.call(obj) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tvar hasOwnConstructor = hasOwn.call(obj, 'constructor');\n\tvar hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n\t// Not own constructor property must be Object\n\tif (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n\t\treturn false;\n\t}\n\n\t// Own properties are enumerated firstly, so to speed up,\n\t// if last one is own, then all properties are own.\n\tvar key;\n\tfor (key in obj) { /**/ }\n\n\treturn typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n\tif (defineProperty && options.name === '__proto__') {\n\t\tdefineProperty(target, options.name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tvalue: options.newValue,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\ttarget[options.name] = options.newValue;\n\t}\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n\tif (name === '__proto__') {\n\t\tif (!hasOwn.call(obj, name)) {\n\t\t\treturn void 0;\n\t\t} else if (gOPD) {\n\t\t\t// In early versions of node, obj['__proto__'] is buggy when obj has\n\t\t\t// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n\t\t\treturn gOPD(obj, name).value;\n\t\t}\n\t}\n\n\treturn obj[name];\n};\n\nmodule.exports = function extend() {\n\tvar options, name, src, copy, copyIsArray, clone;\n\tvar target = arguments[0];\n\tvar i = 1;\n\tvar length = arguments.length;\n\tvar deep = false;\n\n\t// Handle a deep copy situation\n\tif (typeof target === 'boolean') {\n\t\tdeep = target;\n\t\ttarget = arguments[1] || {};\n\t\t// skip the boolean and the target\n\t\ti = 2;\n\t}\n\tif (target == null || (typeof target !== 'object' && typeof target !== 'function')) {\n\t\ttarget = {};\n\t}\n\n\tfor (; i < length; ++i) {\n\t\toptions = arguments[i];\n\t\t// Only deal with non-null/undefined values\n\t\tif (options != null) {\n\t\t\t// Extend the base object\n\t\t\tfor (name in options) {\n\t\t\t\tsrc = getProperty(target, name);\n\t\t\t\tcopy = getProperty(options, name);\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif (target !== copy) {\n\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\tif (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n\t\t\t\t\t\tif (copyIsArray) {\n\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\tclone = src && isArray(src) ? src : [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tclone = src && isPlainObject(src) ? src : {};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: extend(deep, clone, copy) });\n\n\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t} else if (typeof copy !== 'undefined') {\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: copy });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n","// http://www.w3.org/TR/CSS21/grammar.html\n// https://github.com/visionmedia/css-parse/pull/49#issuecomment-30088027\nvar COMMENT_REGEX = /\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\//g;\n\nvar NEWLINE_REGEX = /\\n/g;\nvar WHITESPACE_REGEX = /^\\s*/;\n\n// declaration\nvar PROPERTY_REGEX = /^(\\*?[-#/*\\\\\\w]+(\\[[0-9a-z_-]+\\])?)\\s*/;\nvar COLON_REGEX = /^:\\s*/;\nvar VALUE_REGEX = /^((?:'(?:\\\\'|.)*?'|\"(?:\\\\\"|.)*?\"|\\([^)]*?\\)|[^};])+)/;\nvar SEMICOLON_REGEX = /^[;\\s]*/;\n\n// https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim#Polyfill\nvar TRIM_REGEX = /^\\s+|\\s+$/g;\n\n// strings\nvar NEWLINE = '\\n';\nvar FORWARD_SLASH = '/';\nvar ASTERISK = '*';\nvar EMPTY_STRING = '';\n\n// types\nvar TYPE_COMMENT = 'comment';\nvar TYPE_DECLARATION = 'declaration';\n\n/**\n * @param {String} style\n * @param {Object} [options]\n * @return {Object[]}\n * @throws {TypeError}\n * @throws {Error}\n */\nmodule.exports = function (style, options) {\n  if (typeof style !== 'string') {\n    throw new TypeError('First argument must be a string');\n  }\n\n  if (!style) return [];\n\n  options = options || {};\n\n  /**\n   * Positional.\n   */\n  var lineno = 1;\n  var column = 1;\n\n  /**\n   * Update lineno and column based on `str`.\n   *\n   * @param {String} str\n   */\n  function updatePosition(str) {\n    var lines = str.match(NEWLINE_REGEX);\n    if (lines) lineno += lines.length;\n    var i = str.lastIndexOf(NEWLINE);\n    column = ~i ? str.length - i : column + str.length;\n  }\n\n  /**\n   * Mark position and patch `node.position`.\n   *\n   * @return {Function}\n   */\n  function position() {\n    var start = { line: lineno, column: column };\n    return function (node) {\n      node.position = new Position(start);\n      whitespace();\n      return node;\n    };\n  }\n\n  /**\n   * Store position information for a node.\n   *\n   * @constructor\n   * @property {Object} start\n   * @property {Object} end\n   * @property {undefined|String} source\n   */\n  function Position(start) {\n    this.start = start;\n    this.end = { line: lineno, column: column };\n    this.source = options.source;\n  }\n\n  /**\n   * Non-enumerable source string.\n   */\n  Position.prototype.content = style;\n\n  var errorsList = [];\n\n  /**\n   * Error `msg`.\n   *\n   * @param {String} msg\n   * @throws {Error}\n   */\n  function error(msg) {\n    var err = new Error(\n      options.source + ':' + lineno + ':' + column + ': ' + msg\n    );\n    err.reason = msg;\n    err.filename = options.source;\n    err.line = lineno;\n    err.column = column;\n    err.source = style;\n\n    if (options.silent) {\n      errorsList.push(err);\n    } else {\n      throw err;\n    }\n  }\n\n  /**\n   * Match `re` and return captures.\n   *\n   * @param {RegExp} re\n   * @return {undefined|Array}\n   */\n  function match(re) {\n    var m = re.exec(style);\n    if (!m) return;\n    var str = m[0];\n    updatePosition(str);\n    style = style.slice(str.length);\n    return m;\n  }\n\n  /**\n   * Parse whitespace.\n   */\n  function whitespace() {\n    match(WHITESPACE_REGEX);\n  }\n\n  /**\n   * Parse comments.\n   *\n   * @param {Object[]} [rules]\n   * @return {Object[]}\n   */\n  function comments(rules) {\n    var c;\n    rules = rules || [];\n    while ((c = comment())) {\n      if (c !== false) {\n        rules.push(c);\n      }\n    }\n    return rules;\n  }\n\n  /**\n   * Parse comment.\n   *\n   * @return {Object}\n   * @throws {Error}\n   */\n  function comment() {\n    var pos = position();\n    if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1)) return;\n\n    var i = 2;\n    while (\n      EMPTY_STRING != style.charAt(i) &&\n      (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))\n    ) {\n      ++i;\n    }\n    i += 2;\n\n    if (EMPTY_STRING === style.charAt(i - 1)) {\n      return error('End of comment missing');\n    }\n\n    var str = style.slice(2, i - 2);\n    column += 2;\n    updatePosition(str);\n    style = style.slice(i);\n    column += 2;\n\n    return pos({\n      type: TYPE_COMMENT,\n      comment: str\n    });\n  }\n\n  /**\n   * Parse declaration.\n   *\n   * @return {Object}\n   * @throws {Error}\n   */\n  function declaration() {\n    var pos = position();\n\n    // prop\n    var prop = match(PROPERTY_REGEX);\n    if (!prop) return;\n    comment();\n\n    // :\n    if (!match(COLON_REGEX)) return error(\"property missing ':'\");\n\n    // val\n    var val = match(VALUE_REGEX);\n\n    var ret = pos({\n      type: TYPE_DECLARATION,\n      property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),\n      value: val\n        ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING))\n        : EMPTY_STRING\n    });\n\n    // ;\n    match(SEMICOLON_REGEX);\n\n    return ret;\n  }\n\n  /**\n   * Parse declarations.\n   *\n   * @return {Object[]}\n   */\n  function declarations() {\n    var decls = [];\n\n    comments(decls);\n\n    // declarations\n    var decl;\n    while ((decl = declaration())) {\n      if (decl !== false) {\n        decls.push(decl);\n        comments(decls);\n      }\n    }\n\n    return decls;\n  }\n\n  whitespace();\n  return declarations();\n};\n\n/**\n * Trim `str`.\n *\n * @param {String} str\n * @return {String}\n */\nfunction trim(str) {\n  return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;\n}\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.default = StyleToObject;\nvar inline_style_parser_1 = __importDefault(require(\"inline-style-parser\"));\n/**\n * Parses inline style to object.\n *\n * @param style - Inline style.\n * @param iterator - Iterator.\n * @returns - Style object or null.\n *\n * @example Parsing inline style to object:\n *\n * ```js\n * import parse from 'style-to-object';\n * parse('line-height: 42;'); // { 'line-height': '42' }\n * ```\n */\nfunction StyleToObject(style, iterator) {\n    var styleObject = null;\n    if (!style || typeof style !== 'string') {\n        return styleObject;\n    }\n    var declarations = (0, inline_style_parser_1.default)(style);\n    var hasIterator = typeof iterator === 'function';\n    declarations.forEach(function (declaration) {\n        if (declaration.type !== 'declaration') {\n            return;\n        }\n        var property = declaration.property, value = declaration.value;\n        if (hasIterator) {\n            iterator(property, value, declaration);\n        }\n        else if (value) {\n            styleObject = styleObject || {};\n            styleObject[property] = value;\n        }\n    });\n    return styleObject;\n}\n//# sourceMappingURL=index.js.map","export function deprecate(fn) {\n  return fn\n}\n\nexport function equal() {}\n\nexport function ok() {}\n\nexport function unreachable() {}\n","/**\n * @typedef Options\n *   Configuration for `stringify`.\n * @property {boolean} [padLeft=true]\n *   Whether to pad a space before a token.\n * @property {boolean} [padRight=false]\n *   Whether to pad a space after a token.\n */\n\n/**\n * @typedef {Options} StringifyOptions\n *   Please use `StringifyOptions` instead.\n */\n\n/**\n * Parse comma-separated tokens to an array.\n *\n * @param {string} value\n *   Comma-separated tokens.\n * @returns {Array<string>}\n *   List of tokens.\n */\nexport function parse(value) {\n  /** @type {Array<string>} */\n  const tokens = []\n  const input = String(value || '')\n  let index = input.indexOf(',')\n  let start = 0\n  /** @type {boolean} */\n  let end = false\n\n  while (!end) {\n    if (index === -1) {\n      index = input.length\n      end = true\n    }\n\n    const token = input.slice(start, index).trim()\n\n    if (token || !end) {\n      tokens.push(token)\n    }\n\n    start = index + 1\n    index = input.indexOf(',', start)\n  }\n\n  return tokens\n}\n\n/**\n * Serialize an array of strings or numbers to comma-separated tokens.\n *\n * @param {Array<string|number>} values\n *   List of tokens.\n * @param {Options} [options]\n *   Configuration for `stringify` (optional).\n * @returns {string}\n *   Comma-separated tokens.\n */\nexport function stringify(values, options) {\n  const settings = options || {}\n\n  // Ensure the last empty entry is seen.\n  const input = values[values.length - 1] === '' ? [...values, ''] : values\n\n  return input\n    .join(\n      (settings.padRight ? ' ' : '') +\n        ',' +\n        (settings.padLeft === false ? '' : ' ')\n    )\n    .trim()\n}\n","/**\n * @typedef Options\n *   Configuration.\n * @property {boolean | null | undefined} [jsx=false]\n *   Support JSX identifiers (default: `false`).\n */\n\nconst startRe = /[$_\\p{ID_Start}]/u\nconst contRe = /[$_\\u{200C}\\u{200D}\\p{ID_Continue}]/u\nconst contReJsx = /[-$_\\u{200C}\\u{200D}\\p{ID_Continue}]/u\nconst nameRe = /^[$_\\p{ID_Start}][$_\\u{200C}\\u{200D}\\p{ID_Continue}]*$/u\nconst nameReJsx = /^[$_\\p{ID_Start}][-$_\\u{200C}\\u{200D}\\p{ID_Continue}]*$/u\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Checks if the given code point can start an identifier.\n *\n * @param {number | undefined} code\n *   Code point to check.\n * @returns {boolean}\n *   Whether `code` can start an identifier.\n */\n// Note: `undefined` is supported so you can pass the result from `''.codePointAt`.\nexport function start(code) {\n  return code ? startRe.test(String.fromCodePoint(code)) : false\n}\n\n/**\n * Checks if the given code point can continue an identifier.\n *\n * @param {number | undefined} code\n *   Code point to check.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {boolean}\n *   Whether `code` can continue an identifier.\n */\n// Note: `undefined` is supported so you can pass the result from `''.codePointAt`.\nexport function cont(code, options) {\n  const settings = options || emptyOptions\n  const re = settings.jsx ? contReJsx : contRe\n  return code ? re.test(String.fromCodePoint(code)) : false\n}\n\n/**\n * Checks if the given value is a valid identifier name.\n *\n * @param {string} name\n *   Identifier to check.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {boolean}\n *   Whether `name` can be an identifier.\n */\nexport function name(name, options) {\n  const settings = options || emptyOptions\n  const re = settings.jsx ? nameReJsx : nameRe\n  return re.test(name)\n}\n","/**\n * @typedef {import('hast').Nodes} Nodes\n */\n\n// HTML whitespace expression.\n// See <https://infra.spec.whatwg.org/#ascii-whitespace>.\nconst re = /[ \\t\\n\\f\\r]/g\n\n/**\n * Check if the given value is *inter-element whitespace*.\n *\n * @param {Nodes | string} thing\n *   Thing to check (`Node` or `string`).\n * @returns {boolean}\n *   Whether the `value` is inter-element whitespace (`boolean`): consisting of\n *   zero or more of space, tab (`\\t`), line feed (`\\n`), carriage return\n *   (`\\r`), or form feed (`\\f`); if a node is passed it must be a `Text` node,\n *   whose `value` field is checked.\n */\nexport function whitespace(thing) {\n  return typeof thing === 'object'\n    ? thing.type === 'text'\n      ? empty(thing.value)\n      : false\n    : empty(thing)\n}\n\n/**\n * @param {string} value\n * @returns {boolean}\n */\nfunction empty(value) {\n  return value.replace(re, '') === ''\n}\n","/**\n * @typedef {import('./info.js').Info} Info\n * @typedef {Record<string, Info>} Properties\n * @typedef {Record<string, string>} Normal\n */\n\nexport class Schema {\n  /**\n   * @constructor\n   * @param {Properties} property\n   * @param {Normal} normal\n   * @param {string} [space]\n   */\n  constructor(property, normal, space) {\n    this.property = property\n    this.normal = normal\n    if (space) {\n      this.space = space\n    }\n  }\n}\n\n/** @type {Properties} */\nSchema.prototype.property = {}\n/** @type {Normal} */\nSchema.prototype.normal = {}\n/** @type {string|null} */\nSchema.prototype.space = null\n","/**\n * @typedef {import('./schema.js').Properties} Properties\n * @typedef {import('./schema.js').Normal} Normal\n */\n\nimport {Schema} from './schema.js'\n\n/**\n * @param {Schema[]} definitions\n * @param {string} [space]\n * @returns {Schema}\n */\nexport function merge(definitions, space) {\n  /** @type {Properties} */\n  const property = {}\n  /** @type {Normal} */\n  const normal = {}\n  let index = -1\n\n  while (++index < definitions.length) {\n    Object.assign(property, definitions[index].property)\n    Object.assign(normal, definitions[index].normal)\n  }\n\n  return new Schema(property, normal, space)\n}\n","/**\n * @param {string} value\n * @returns {string}\n */\nexport function normalize(value) {\n  return value.toLowerCase()\n}\n","export class Info {\n  /**\n   * @constructor\n   * @param {string} property\n   * @param {string} attribute\n   */\n  constructor(property, attribute) {\n    /** @type {string} */\n    this.property = property\n    /** @type {string} */\n    this.attribute = attribute\n  }\n}\n\n/** @type {string|null} */\nInfo.prototype.space = null\nInfo.prototype.boolean = false\nInfo.prototype.booleanish = false\nInfo.prototype.overloadedBoolean = false\nInfo.prototype.number = false\nInfo.prototype.commaSeparated = false\nInfo.prototype.spaceSeparated = false\nInfo.prototype.commaOrSpaceSeparated = false\nInfo.prototype.mustUseProperty = false\nInfo.prototype.defined = false\n","let powers = 0\n\nexport const boolean = increment()\nexport const booleanish = increment()\nexport const overloadedBoolean = increment()\nexport const number = increment()\nexport const spaceSeparated = increment()\nexport const commaSeparated = increment()\nexport const commaOrSpaceSeparated = increment()\n\nfunction increment() {\n  return 2 ** ++powers\n}\n","import {Info} from './info.js'\nimport * as types from './types.js'\n\n/** @type {Array<keyof types>} */\n// @ts-expect-error: hush.\nconst checks = Object.keys(types)\n\nexport class DefinedInfo extends Info {\n  /**\n   * @constructor\n   * @param {string} property\n   * @param {string} attribute\n   * @param {number|null} [mask]\n   * @param {string} [space]\n   */\n  constructor(property, attribute, mask, space) {\n    let index = -1\n\n    super(property, attribute)\n\n    mark(this, 'space', space)\n\n    if (typeof mask === 'number') {\n      while (++index < checks.length) {\n        const check = checks[index]\n        mark(this, checks[index], (mask & types[check]) === types[check])\n      }\n    }\n  }\n}\n\nDefinedInfo.prototype.defined = true\n\n/**\n * @param {DefinedInfo} values\n * @param {string} key\n * @param {unknown} value\n */\nfunction mark(values, key, value) {\n  if (value) {\n    // @ts-expect-error: assume `value` matches the expected value of `key`.\n    values[key] = value\n  }\n}\n","/**\n * @typedef {import('./schema.js').Properties} Properties\n * @typedef {import('./schema.js').Normal} Normal\n *\n * @typedef {Record<string, string>} Attributes\n *\n * @typedef {Object} Definition\n * @property {Record<string, number|null>} properties\n * @property {(attributes: Attributes, property: string) => string} transform\n * @property {string} [space]\n * @property {Attributes} [attributes]\n * @property {Array<string>} [mustUseProperty]\n */\n\nimport {normalize} from '../normalize.js'\nimport {Schema} from './schema.js'\nimport {DefinedInfo} from './defined-info.js'\n\nconst own = {}.hasOwnProperty\n\n/**\n * @param {Definition} definition\n * @returns {Schema}\n */\nexport function create(definition) {\n  /** @type {Properties} */\n  const property = {}\n  /** @type {Normal} */\n  const normal = {}\n  /** @type {string} */\n  let prop\n\n  for (prop in definition.properties) {\n    if (own.call(definition.properties, prop)) {\n      const value = definition.properties[prop]\n      const info = new DefinedInfo(\n        prop,\n        definition.transform(definition.attributes || {}, prop),\n        value,\n        definition.space\n      )\n\n      if (\n        definition.mustUseProperty &&\n        definition.mustUseProperty.includes(prop)\n      ) {\n        info.mustUseProperty = true\n      }\n\n      property[prop] = info\n\n      normal[normalize(prop)] = prop\n      normal[normalize(info.attribute)] = prop\n    }\n  }\n\n  return new Schema(property, normal, definition.space)\n}\n","import {create} from './util/create.js'\n\nexport const xlink = create({\n  space: 'xlink',\n  transform(_, prop) {\n    return 'xlink:' + prop.slice(5).toLowerCase()\n  },\n  properties: {\n    xLinkActuate: null,\n    xLinkArcRole: null,\n    xLinkHref: null,\n    xLinkRole: null,\n    xLinkShow: null,\n    xLinkTitle: null,\n    xLinkType: null\n  }\n})\n","import {create} from './util/create.js'\n\nexport const xml = create({\n  space: 'xml',\n  transform(_, prop) {\n    return 'xml:' + prop.slice(3).toLowerCase()\n  },\n  properties: {xmlLang: null, xmlBase: null, xmlSpace: null}\n})\n","/**\n * @param {Record<string, string>} attributes\n * @param {string} attribute\n * @returns {string}\n */\nexport function caseSensitiveTransform(attributes, attribute) {\n  return attribute in attributes ? attributes[attribute] : attribute\n}\n","import {caseSensitiveTransform} from './case-sensitive-transform.js'\n\n/**\n * @param {Record<string, string>} attributes\n * @param {string} property\n * @returns {string}\n */\nexport function caseInsensitiveTransform(attributes, property) {\n  return caseSensitiveTransform(attributes, property.toLowerCase())\n}\n","import {create} from './util/create.js'\nimport {caseInsensitiveTransform} from './util/case-insensitive-transform.js'\n\nexport const xmlns = create({\n  space: 'xmlns',\n  attributes: {xmlnsxlink: 'xmlns:xlink'},\n  transform: caseInsensitiveTransform,\n  properties: {xmlns: null, xmlnsXLink: null}\n})\n","import {booleanish, number, spaceSeparated} from './util/types.js'\nimport {create} from './util/create.js'\n\nexport const aria = create({\n  transform(_, prop) {\n    return prop === 'role' ? prop : 'aria-' + prop.slice(4).toLowerCase()\n  },\n  properties: {\n    ariaActiveDescendant: null,\n    ariaAtomic: booleanish,\n    ariaAutoComplete: null,\n    ariaBusy: booleanish,\n    ariaChecked: booleanish,\n    ariaColCount: number,\n    ariaColIndex: number,\n    ariaColSpan: number,\n    ariaControls: spaceSeparated,\n    ariaCurrent: null,\n    ariaDescribedBy: spaceSeparated,\n    ariaDetails: null,\n    ariaDisabled: booleanish,\n    ariaDropEffect: spaceSeparated,\n    ariaErrorMessage: null,\n    ariaExpanded: booleanish,\n    ariaFlowTo: spaceSeparated,\n    ariaGrabbed: booleanish,\n    ariaHasPopup: null,\n    ariaHidden: booleanish,\n    ariaInvalid: null,\n    ariaKeyShortcuts: null,\n    ariaLabel: null,\n    ariaLabelledBy: spaceSeparated,\n    ariaLevel: number,\n    ariaLive: null,\n    ariaModal: booleanish,\n    ariaMultiLine: booleanish,\n    ariaMultiSelectable: booleanish,\n    ariaOrientation: null,\n    ariaOwns: spaceSeparated,\n    ariaPlaceholder: null,\n    ariaPosInSet: number,\n    ariaPressed: booleanish,\n    ariaReadOnly: booleanish,\n    ariaRelevant: null,\n    ariaRequired: booleanish,\n    ariaRoleDescription: spaceSeparated,\n    ariaRowCount: number,\n    ariaRowIndex: number,\n    ariaRowSpan: number,\n    ariaSelected: booleanish,\n    ariaSetSize: number,\n    ariaSort: null,\n    ariaValueMax: number,\n    ariaValueMin: number,\n    ariaValueNow: number,\n    ariaValueText: null,\n    role: null\n  }\n})\n","import {\n  boolean,\n  overloadedBoolean,\n  booleanish,\n  number,\n  spaceSeparated,\n  commaSeparated\n} from './util/types.js'\nimport {create} from './util/create.js'\nimport {caseInsensitiveTransform} from './util/case-insensitive-transform.js'\n\nexport const html = create({\n  space: 'html',\n  attributes: {\n    acceptcharset: 'accept-charset',\n    classname: 'class',\n    htmlfor: 'for',\n    httpequiv: 'http-equiv'\n  },\n  transform: caseInsensitiveTransform,\n  mustUseProperty: ['checked', 'multiple', 'muted', 'selected'],\n  properties: {\n    // Standard Properties.\n    abbr: null,\n    accept: commaSeparated,\n    acceptCharset: spaceSeparated,\n    accessKey: spaceSeparated,\n    action: null,\n    allow: null,\n    allowFullScreen: boolean,\n    allowPaymentRequest: boolean,\n    allowUserMedia: boolean,\n    alt: null,\n    as: null,\n    async: boolean,\n    autoCapitalize: null,\n    autoComplete: spaceSeparated,\n    autoFocus: boolean,\n    autoPlay: boolean,\n    blocking: spaceSeparated,\n    capture: null,\n    charSet: null,\n    checked: boolean,\n    cite: null,\n    className: spaceSeparated,\n    cols: number,\n    colSpan: null,\n    content: null,\n    contentEditable: booleanish,\n    controls: boolean,\n    controlsList: spaceSeparated,\n    coords: number | commaSeparated,\n    crossOrigin: null,\n    data: null,\n    dateTime: null,\n    decoding: null,\n    default: boolean,\n    defer: boolean,\n    dir: null,\n    dirName: null,\n    disabled: boolean,\n    download: overloadedBoolean,\n    draggable: booleanish,\n    encType: null,\n    enterKeyHint: null,\n    fetchPriority: null,\n    form: null,\n    formAction: null,\n    formEncType: null,\n    formMethod: null,\n    formNoValidate: boolean,\n    formTarget: null,\n    headers: spaceSeparated,\n    height: number,\n    hidden: boolean,\n    high: number,\n    href: null,\n    hrefLang: null,\n    htmlFor: spaceSeparated,\n    httpEquiv: spaceSeparated,\n    id: null,\n    imageSizes: null,\n    imageSrcSet: null,\n    inert: boolean,\n    inputMode: null,\n    integrity: null,\n    is: null,\n    isMap: boolean,\n    itemId: null,\n    itemProp: spaceSeparated,\n    itemRef: spaceSeparated,\n    itemScope: boolean,\n    itemType: spaceSeparated,\n    kind: null,\n    label: null,\n    lang: null,\n    language: null,\n    list: null,\n    loading: null,\n    loop: boolean,\n    low: number,\n    manifest: null,\n    max: null,\n    maxLength: number,\n    media: null,\n    method: null,\n    min: null,\n    minLength: number,\n    multiple: boolean,\n    muted: boolean,\n    name: null,\n    nonce: null,\n    noModule: boolean,\n    noValidate: boolean,\n    onAbort: null,\n    onAfterPrint: null,\n    onAuxClick: null,\n    onBeforeMatch: null,\n    onBeforePrint: null,\n    onBeforeToggle: null,\n    onBeforeUnload: null,\n    onBlur: null,\n    onCancel: null,\n    onCanPlay: null,\n    onCanPlayThrough: null,\n    onChange: null,\n    onClick: null,\n    onClose: null,\n    onContextLost: null,\n    onContextMenu: null,\n    onContextRestored: null,\n    onCopy: null,\n    onCueChange: null,\n    onCut: null,\n    onDblClick: null,\n    onDrag: null,\n    onDragEnd: null,\n    onDragEnter: null,\n    onDragExit: null,\n    onDragLeave: null,\n    onDragOver: null,\n    onDragStart: null,\n    onDrop: null,\n    onDurationChange: null,\n    onEmptied: null,\n    onEnded: null,\n    onError: null,\n    onFocus: null,\n    onFormData: null,\n    onHashChange: null,\n    onInput: null,\n    onInvalid: null,\n    onKeyDown: null,\n    onKeyPress: null,\n    onKeyUp: null,\n    onLanguageChange: null,\n    onLoad: null,\n    onLoadedData: null,\n    onLoadedMetadata: null,\n    onLoadEnd: null,\n    onLoadStart: null,\n    onMessage: null,\n    onMessageError: null,\n    onMouseDown: null,\n    onMouseEnter: null,\n    onMouseLeave: null,\n    onMouseMove: null,\n    onMouseOut: null,\n    onMouseOver: null,\n    onMouseUp: null,\n    onOffline: null,\n    onOnline: null,\n    onPageHide: null,\n    onPageShow: null,\n    onPaste: null,\n    onPause: null,\n    onPlay: null,\n    onPlaying: null,\n    onPopState: null,\n    onProgress: null,\n    onRateChange: null,\n    onRejectionHandled: null,\n    onReset: null,\n    onResize: null,\n    onScroll: null,\n    onScrollEnd: null,\n    onSecurityPolicyViolation: null,\n    onSeeked: null,\n    onSeeking: null,\n    onSelect: null,\n    onSlotChange: null,\n    onStalled: null,\n    onStorage: null,\n    onSubmit: null,\n    onSuspend: null,\n    onTimeUpdate: null,\n    onToggle: null,\n    onUnhandledRejection: null,\n    onUnload: null,\n    onVolumeChange: null,\n    onWaiting: null,\n    onWheel: null,\n    open: boolean,\n    optimum: number,\n    pattern: null,\n    ping: spaceSeparated,\n    placeholder: null,\n    playsInline: boolean,\n    popover: null,\n    popoverTarget: null,\n    popoverTargetAction: null,\n    poster: null,\n    preload: null,\n    readOnly: boolean,\n    referrerPolicy: null,\n    rel: spaceSeparated,\n    required: boolean,\n    reversed: boolean,\n    rows: number,\n    rowSpan: number,\n    sandbox: spaceSeparated,\n    scope: null,\n    scoped: boolean,\n    seamless: boolean,\n    selected: boolean,\n    shadowRootClonable: boolean,\n    shadowRootDelegatesFocus: boolean,\n    shadowRootMode: null,\n    shape: null,\n    size: number,\n    sizes: null,\n    slot: null,\n    span: number,\n    spellCheck: booleanish,\n    src: null,\n    srcDoc: null,\n    srcLang: null,\n    srcSet: null,\n    start: number,\n    step: null,\n    style: null,\n    tabIndex: number,\n    target: null,\n    title: null,\n    translate: null,\n    type: null,\n    typeMustMatch: boolean,\n    useMap: null,\n    value: booleanish,\n    width: number,\n    wrap: null,\n    writingSuggestions: null,\n\n    // Legacy.\n    // See: https://html.spec.whatwg.org/#other-elements,-attributes-and-apis\n    align: null, // Several. Use CSS `text-align` instead,\n    aLink: null, // `<body>`. Use CSS `a:active {color}` instead\n    archive: spaceSeparated, // `<object>`. List of URIs to archives\n    axis: null, // `<td>` and `<th>`. Use `scope` on `<th>`\n    background: null, // `<body>`. Use CSS `background-image` instead\n    bgColor: null, // `<body>` and table elements. Use CSS `background-color` instead\n    border: number, // `<table>`. Use CSS `border-width` instead,\n    borderColor: null, // `<table>`. Use CSS `border-color` instead,\n    bottomMargin: number, // `<body>`\n    cellPadding: null, // `<table>`\n    cellSpacing: null, // `<table>`\n    char: null, // Several table elements. When `align=char`, sets the character to align on\n    charOff: null, // Several table elements. When `char`, offsets the alignment\n    classId: null, // `<object>`\n    clear: null, // `<br>`. Use CSS `clear` instead\n    code: null, // `<object>`\n    codeBase: null, // `<object>`\n    codeType: null, // `<object>`\n    color: null, // `<font>` and `<hr>`. Use CSS instead\n    compact: boolean, // Lists. Use CSS to reduce space between items instead\n    declare: boolean, // `<object>`\n    event: null, // `<script>`\n    face: null, // `<font>`. Use CSS instead\n    frame: null, // `<table>`\n    frameBorder: null, // `<iframe>`. Use CSS `border` instead\n    hSpace: number, // `<img>` and `<object>`\n    leftMargin: number, // `<body>`\n    link: null, // `<body>`. Use CSS `a:link {color: *}` instead\n    longDesc: null, // `<frame>`, `<iframe>`, and `<img>`. Use an `<a>`\n    lowSrc: null, // `<img>`. Use a `<picture>`\n    marginHeight: number, // `<body>`\n    marginWidth: number, // `<body>`\n    noResize: boolean, // `<frame>`\n    noHref: boolean, // `<area>`. Use no href instead of an explicit `nohref`\n    noShade: boolean, // `<hr>`. Use background-color and height instead of borders\n    noWrap: boolean, // `<td>` and `<th>`\n    object: null, // `<applet>`\n    profile: null, // `<head>`\n    prompt: null, // `<isindex>`\n    rev: null, // `<link>`\n    rightMargin: number, // `<body>`\n    rules: null, // `<table>`\n    scheme: null, // `<meta>`\n    scrolling: booleanish, // `<frame>`. Use overflow in the child context\n    standby: null, // `<object>`\n    summary: null, // `<table>`\n    text: null, // `<body>`. Use CSS `color` instead\n    topMargin: number, // `<body>`\n    valueType: null, // `<param>`\n    version: null, // `<html>`. Use a doctype.\n    vAlign: null, // Several. Use CSS `vertical-align` instead\n    vLink: null, // `<body>`. Use CSS `a:visited {color}` instead\n    vSpace: number, // `<img>` and `<object>`\n\n    // Non-standard Properties.\n    allowTransparency: null,\n    autoCorrect: null,\n    autoSave: null,\n    disablePictureInPicture: boolean,\n    disableRemotePlayback: boolean,\n    prefix: null,\n    property: null,\n    results: number,\n    security: null,\n    unselectable: null\n  }\n})\n","import {\n  boolean,\n  number,\n  spaceSeparated,\n  commaSeparated,\n  commaOrSpaceSeparated\n} from './util/types.js'\nimport {create} from './util/create.js'\nimport {caseSensitiveTransform} from './util/case-sensitive-transform.js'\n\nexport const svg = create({\n  space: 'svg',\n  attributes: {\n    accentHeight: 'accent-height',\n    alignmentBaseline: 'alignment-baseline',\n    arabicForm: 'arabic-form',\n    baselineShift: 'baseline-shift',\n    capHeight: 'cap-height',\n    className: 'class',\n    clipPath: 'clip-path',\n    clipRule: 'clip-rule',\n    colorInterpolation: 'color-interpolation',\n    colorInterpolationFilters: 'color-interpolation-filters',\n    colorProfile: 'color-profile',\n    colorRendering: 'color-rendering',\n    crossOrigin: 'crossorigin',\n    dataType: 'datatype',\n    dominantBaseline: 'dominant-baseline',\n    enableBackground: 'enable-background',\n    fillOpacity: 'fill-opacity',\n    fillRule: 'fill-rule',\n    floodColor: 'flood-color',\n    floodOpacity: 'flood-opacity',\n    fontFamily: 'font-family',\n    fontSize: 'font-size',\n    fontSizeAdjust: 'font-size-adjust',\n    fontStretch: 'font-stretch',\n    fontStyle: 'font-style',\n    fontVariant: 'font-variant',\n    fontWeight: 'font-weight',\n    glyphName: 'glyph-name',\n    glyphOrientationHorizontal: 'glyph-orientation-horizontal',\n    glyphOrientationVertical: 'glyph-orientation-vertical',\n    hrefLang: 'hreflang',\n    horizAdvX: 'horiz-adv-x',\n    horizOriginX: 'horiz-origin-x',\n    horizOriginY: 'horiz-origin-y',\n    imageRendering: 'image-rendering',\n    letterSpacing: 'letter-spacing',\n    lightingColor: 'lighting-color',\n    markerEnd: 'marker-end',\n    markerMid: 'marker-mid',\n    markerStart: 'marker-start',\n    navDown: 'nav-down',\n    navDownLeft: 'nav-down-left',\n    navDownRight: 'nav-down-right',\n    navLeft: 'nav-left',\n    navNext: 'nav-next',\n    navPrev: 'nav-prev',\n    navRight: 'nav-right',\n    navUp: 'nav-up',\n    navUpLeft: 'nav-up-left',\n    navUpRight: 'nav-up-right',\n    onAbort: 'onabort',\n    onActivate: 'onactivate',\n    onAfterPrint: 'onafterprint',\n    onBeforePrint: 'onbeforeprint',\n    onBegin: 'onbegin',\n    onCancel: 'oncancel',\n    onCanPlay: 'oncanplay',\n    onCanPlayThrough: 'oncanplaythrough',\n    onChange: 'onchange',\n    onClick: 'onclick',\n    onClose: 'onclose',\n    onCopy: 'oncopy',\n    onCueChange: 'oncuechange',\n    onCut: 'oncut',\n    onDblClick: 'ondblclick',\n    onDrag: 'ondrag',\n    onDragEnd: 'ondragend',\n    onDragEnter: 'ondragenter',\n    onDragExit: 'ondragexit',\n    onDragLeave: 'ondragleave',\n    onDragOver: 'ondragover',\n    onDragStart: 'ondragstart',\n    onDrop: 'ondrop',\n    onDurationChange: 'ondurationchange',\n    onEmptied: 'onemptied',\n    onEnd: 'onend',\n    onEnded: 'onended',\n    onError: 'onerror',\n    onFocus: 'onfocus',\n    onFocusIn: 'onfocusin',\n    onFocusOut: 'onfocusout',\n    onHashChange: 'onhashchange',\n    onInput: 'oninput',\n    onInvalid: 'oninvalid',\n    onKeyDown: 'onkeydown',\n    onKeyPress: 'onkeypress',\n    onKeyUp: 'onkeyup',\n    onLoad: 'onload',\n    onLoadedData: 'onloadeddata',\n    onLoadedMetadata: 'onloadedmetadata',\n    onLoadStart: 'onloadstart',\n    onMessage: 'onmessage',\n    onMouseDown: 'onmousedown',\n    onMouseEnter: 'onmouseenter',\n    onMouseLeave: 'onmouseleave',\n    onMouseMove: 'onmousemove',\n    onMouseOut: 'onmouseout',\n    onMouseOver: 'onmouseover',\n    onMouseUp: 'onmouseup',\n    onMouseWheel: 'onmousewheel',\n    onOffline: 'onoffline',\n    onOnline: 'ononline',\n    onPageHide: 'onpagehide',\n    onPageShow: 'onpageshow',\n    onPaste: 'onpaste',\n    onPause: 'onpause',\n    onPlay: 'onplay',\n    onPlaying: 'onplaying',\n    onPopState: 'onpopstate',\n    onProgress: 'onprogress',\n    onRateChange: 'onratechange',\n    onRepeat: 'onrepeat',\n    onReset: 'onreset',\n    onResize: 'onresize',\n    onScroll: 'onscroll',\n    onSeeked: 'onseeked',\n    onSeeking: 'onseeking',\n    onSelect: 'onselect',\n    onShow: 'onshow',\n    onStalled: 'onstalled',\n    onStorage: 'onstorage',\n    onSubmit: 'onsubmit',\n    onSuspend: 'onsuspend',\n    onTimeUpdate: 'ontimeupdate',\n    onToggle: 'ontoggle',\n    onUnload: 'onunload',\n    onVolumeChange: 'onvolumechange',\n    onWaiting: 'onwaiting',\n    onZoom: 'onzoom',\n    overlinePosition: 'overline-position',\n    overlineThickness: 'overline-thickness',\n    paintOrder: 'paint-order',\n    panose1: 'panose-1',\n    pointerEvents: 'pointer-events',\n    referrerPolicy: 'referrerpolicy',\n    renderingIntent: 'rendering-intent',\n    shapeRendering: 'shape-rendering',\n    stopColor: 'stop-color',\n    stopOpacity: 'stop-opacity',\n    strikethroughPosition: 'strikethrough-position',\n    strikethroughThickness: 'strikethrough-thickness',\n    strokeDashArray: 'stroke-dasharray',\n    strokeDashOffset: 'stroke-dashoffset',\n    strokeLineCap: 'stroke-linecap',\n    strokeLineJoin: 'stroke-linejoin',\n    strokeMiterLimit: 'stroke-miterlimit',\n    strokeOpacity: 'stroke-opacity',\n    strokeWidth: 'stroke-width',\n    tabIndex: 'tabindex',\n    textAnchor: 'text-anchor',\n    textDecoration: 'text-decoration',\n    textRendering: 'text-rendering',\n    transformOrigin: 'transform-origin',\n    typeOf: 'typeof',\n    underlinePosition: 'underline-position',\n    underlineThickness: 'underline-thickness',\n    unicodeBidi: 'unicode-bidi',\n    unicodeRange: 'unicode-range',\n    unitsPerEm: 'units-per-em',\n    vAlphabetic: 'v-alphabetic',\n    vHanging: 'v-hanging',\n    vIdeographic: 'v-ideographic',\n    vMathematical: 'v-mathematical',\n    vectorEffect: 'vector-effect',\n    vertAdvY: 'vert-adv-y',\n    vertOriginX: 'vert-origin-x',\n    vertOriginY: 'vert-origin-y',\n    wordSpacing: 'word-spacing',\n    writingMode: 'writing-mode',\n    xHeight: 'x-height',\n    // These were camelcased in Tiny. Now lowercased in SVG 2\n    playbackOrder: 'playbackorder',\n    timelineBegin: 'timelinebegin'\n  },\n  transform: caseSensitiveTransform,\n  properties: {\n    about: commaOrSpaceSeparated,\n    accentHeight: number,\n    accumulate: null,\n    additive: null,\n    alignmentBaseline: null,\n    alphabetic: number,\n    amplitude: number,\n    arabicForm: null,\n    ascent: number,\n    attributeName: null,\n    attributeType: null,\n    azimuth: number,\n    bandwidth: null,\n    baselineShift: null,\n    baseFrequency: null,\n    baseProfile: null,\n    bbox: null,\n    begin: null,\n    bias: number,\n    by: null,\n    calcMode: null,\n    capHeight: number,\n    className: spaceSeparated,\n    clip: null,\n    clipPath: null,\n    clipPathUnits: null,\n    clipRule: null,\n    color: null,\n    colorInterpolation: null,\n    colorInterpolationFilters: null,\n    colorProfile: null,\n    colorRendering: null,\n    content: null,\n    contentScriptType: null,\n    contentStyleType: null,\n    crossOrigin: null,\n    cursor: null,\n    cx: null,\n    cy: null,\n    d: null,\n    dataType: null,\n    defaultAction: null,\n    descent: number,\n    diffuseConstant: number,\n    direction: null,\n    display: null,\n    dur: null,\n    divisor: number,\n    dominantBaseline: null,\n    download: boolean,\n    dx: null,\n    dy: null,\n    edgeMode: null,\n    editable: null,\n    elevation: number,\n    enableBackground: null,\n    end: null,\n    event: null,\n    exponent: number,\n    externalResourcesRequired: null,\n    fill: null,\n    fillOpacity: number,\n    fillRule: null,\n    filter: null,\n    filterRes: null,\n    filterUnits: null,\n    floodColor: null,\n    floodOpacity: null,\n    focusable: null,\n    focusHighlight: null,\n    fontFamily: null,\n    fontSize: null,\n    fontSizeAdjust: null,\n    fontStretch: null,\n    fontStyle: null,\n    fontVariant: null,\n    fontWeight: null,\n    format: null,\n    fr: null,\n    from: null,\n    fx: null,\n    fy: null,\n    g1: commaSeparated,\n    g2: commaSeparated,\n    glyphName: commaSeparated,\n    glyphOrientationHorizontal: null,\n    glyphOrientationVertical: null,\n    glyphRef: null,\n    gradientTransform: null,\n    gradientUnits: null,\n    handler: null,\n    hanging: number,\n    hatchContentUnits: null,\n    hatchUnits: null,\n    height: null,\n    href: null,\n    hrefLang: null,\n    horizAdvX: number,\n    horizOriginX: number,\n    horizOriginY: number,\n    id: null,\n    ideographic: number,\n    imageRendering: null,\n    initialVisibility: null,\n    in: null,\n    in2: null,\n    intercept: number,\n    k: number,\n    k1: number,\n    k2: number,\n    k3: number,\n    k4: number,\n    kernelMatrix: commaOrSpaceSeparated,\n    kernelUnitLength: null,\n    keyPoints: null, // SEMI_COLON_SEPARATED\n    keySplines: null, // SEMI_COLON_SEPARATED\n    keyTimes: null, // SEMI_COLON_SEPARATED\n    kerning: null,\n    lang: null,\n    lengthAdjust: null,\n    letterSpacing: null,\n    lightingColor: null,\n    limitingConeAngle: number,\n    local: null,\n    markerEnd: null,\n    markerMid: null,\n    markerStart: null,\n    markerHeight: null,\n    markerUnits: null,\n    markerWidth: null,\n    mask: null,\n    maskContentUnits: null,\n    maskUnits: null,\n    mathematical: null,\n    max: null,\n    media: null,\n    mediaCharacterEncoding: null,\n    mediaContentEncodings: null,\n    mediaSize: number,\n    mediaTime: null,\n    method: null,\n    min: null,\n    mode: null,\n    name: null,\n    navDown: null,\n    navDownLeft: null,\n    navDownRight: null,\n    navLeft: null,\n    navNext: null,\n    navPrev: null,\n    navRight: null,\n    navUp: null,\n    navUpLeft: null,\n    navUpRight: null,\n    numOctaves: null,\n    observer: null,\n    offset: null,\n    onAbort: null,\n    onActivate: null,\n    onAfterPrint: null,\n    onBeforePrint: null,\n    onBegin: null,\n    onCancel: null,\n    onCanPlay: null,\n    onCanPlayThrough: null,\n    onChange: null,\n    onClick: null,\n    onClose: null,\n    onCopy: null,\n    onCueChange: null,\n    onCut: null,\n    onDblClick: null,\n    onDrag: null,\n    onDragEnd: null,\n    onDragEnter: null,\n    onDragExit: null,\n    onDragLeave: null,\n    onDragOver: null,\n    onDragStart: null,\n    onDrop: null,\n    onDurationChange: null,\n    onEmptied: null,\n    onEnd: null,\n    onEnded: null,\n    onError: null,\n    onFocus: null,\n    onFocusIn: null,\n    onFocusOut: null,\n    onHashChange: null,\n    onInput: null,\n    onInvalid: null,\n    onKeyDown: null,\n    onKeyPress: null,\n    onKeyUp: null,\n    onLoad: null,\n    onLoadedData: null,\n    onLoadedMetadata: null,\n    onLoadStart: null,\n    onMessage: null,\n    onMouseDown: null,\n    onMouseEnter: null,\n    onMouseLeave: null,\n    onMouseMove: null,\n    onMouseOut: null,\n    onMouseOver: null,\n    onMouseUp: null,\n    onMouseWheel: null,\n    onOffline: null,\n    onOnline: null,\n    onPageHide: null,\n    onPageShow: null,\n    onPaste: null,\n    onPause: null,\n    onPlay: null,\n    onPlaying: null,\n    onPopState: null,\n    onProgress: null,\n    onRateChange: null,\n    onRepeat: null,\n    onReset: null,\n    onResize: null,\n    onScroll: null,\n    onSeeked: null,\n    onSeeking: null,\n    onSelect: null,\n    onShow: null,\n    onStalled: null,\n    onStorage: null,\n    onSubmit: null,\n    onSuspend: null,\n    onTimeUpdate: null,\n    onToggle: null,\n    onUnload: null,\n    onVolumeChange: null,\n    onWaiting: null,\n    onZoom: null,\n    opacity: null,\n    operator: null,\n    order: null,\n    orient: null,\n    orientation: null,\n    origin: null,\n    overflow: null,\n    overlay: null,\n    overlinePosition: number,\n    overlineThickness: number,\n    paintOrder: null,\n    panose1: null,\n    path: null,\n    pathLength: number,\n    patternContentUnits: null,\n    patternTransform: null,\n    patternUnits: null,\n    phase: null,\n    ping: spaceSeparated,\n    pitch: null,\n    playbackOrder: null,\n    pointerEvents: null,\n    points: null,\n    pointsAtX: number,\n    pointsAtY: number,\n    pointsAtZ: number,\n    preserveAlpha: null,\n    preserveAspectRatio: null,\n    primitiveUnits: null,\n    propagate: null,\n    property: commaOrSpaceSeparated,\n    r: null,\n    radius: null,\n    referrerPolicy: null,\n    refX: null,\n    refY: null,\n    rel: commaOrSpaceSeparated,\n    rev: commaOrSpaceSeparated,\n    renderingIntent: null,\n    repeatCount: null,\n    repeatDur: null,\n    requiredExtensions: commaOrSpaceSeparated,\n    requiredFeatures: commaOrSpaceSeparated,\n    requiredFonts: commaOrSpaceSeparated,\n    requiredFormats: commaOrSpaceSeparated,\n    resource: null,\n    restart: null,\n    result: null,\n    rotate: null,\n    rx: null,\n    ry: null,\n    scale: null,\n    seed: null,\n    shapeRendering: null,\n    side: null,\n    slope: null,\n    snapshotTime: null,\n    specularConstant: number,\n    specularExponent: number,\n    spreadMethod: null,\n    spacing: null,\n    startOffset: null,\n    stdDeviation: null,\n    stemh: null,\n    stemv: null,\n    stitchTiles: null,\n    stopColor: null,\n    stopOpacity: null,\n    strikethroughPosition: number,\n    strikethroughThickness: number,\n    string: null,\n    stroke: null,\n    strokeDashArray: commaOrSpaceSeparated,\n    strokeDashOffset: null,\n    strokeLineCap: null,\n    strokeLineJoin: null,\n    strokeMiterLimit: number,\n    strokeOpacity: number,\n    strokeWidth: null,\n    style: null,\n    surfaceScale: number,\n    syncBehavior: null,\n    syncBehaviorDefault: null,\n    syncMaster: null,\n    syncTolerance: null,\n    syncToleranceDefault: null,\n    systemLanguage: commaOrSpaceSeparated,\n    tabIndex: number,\n    tableValues: null,\n    target: null,\n    targetX: number,\n    targetY: number,\n    textAnchor: null,\n    textDecoration: null,\n    textRendering: null,\n    textLength: null,\n    timelineBegin: null,\n    title: null,\n    transformBehavior: null,\n    type: null,\n    typeOf: commaOrSpaceSeparated,\n    to: null,\n    transform: null,\n    transformOrigin: null,\n    u1: null,\n    u2: null,\n    underlinePosition: number,\n    underlineThickness: number,\n    unicode: null,\n    unicodeBidi: null,\n    unicodeRange: null,\n    unitsPerEm: number,\n    values: null,\n    vAlphabetic: number,\n    vMathematical: number,\n    vectorEffect: null,\n    vHanging: number,\n    vIdeographic: number,\n    version: null,\n    vertAdvY: number,\n    vertOriginX: number,\n    vertOriginY: number,\n    viewBox: null,\n    viewTarget: null,\n    visibility: null,\n    width: null,\n    widths: null,\n    wordSpacing: null,\n    writingMode: null,\n    x: null,\n    x1: null,\n    x2: null,\n    xChannelSelector: null,\n    xHeight: number,\n    y: null,\n    y1: null,\n    y2: null,\n    yChannelSelector: null,\n    z: null,\n    zoomAndPan: null\n  }\n})\n","/**\n * @typedef {import('./lib/util/info.js').Info} Info\n * @typedef {import('./lib/util/schema.js').Schema} Schema\n */\n\nimport {merge} from './lib/util/merge.js'\nimport {xlink} from './lib/xlink.js'\nimport {xml} from './lib/xml.js'\nimport {xmlns} from './lib/xmlns.js'\nimport {aria} from './lib/aria.js'\nimport {html as htmlBase} from './lib/html.js'\nimport {svg as svgBase} from './lib/svg.js'\n\nexport {find} from './lib/find.js'\nexport {hastToReact} from './lib/hast-to-react.js'\nexport {normalize} from './lib/normalize.js'\nexport const html = merge([xml, xlink, xmlns, aria, htmlBase], 'html')\nexport const svg = merge([xml, xlink, xmlns, aria, svgBase], 'svg')\n","/**\n * @typedef {import('./util/schema.js').Schema} Schema\n */\n\nimport {normalize} from './normalize.js'\nimport {DefinedInfo} from './util/defined-info.js'\nimport {Info} from './util/info.js'\n\nconst valid = /^data[-\\w.:]+$/i\nconst dash = /-[a-z]/g\nconst cap = /[A-Z]/g\n\n/**\n * @param {Schema} schema\n * @param {string} value\n * @returns {Info}\n */\nexport function find(schema, value) {\n  const normal = normalize(value)\n  let prop = value\n  let Type = Info\n\n  if (normal in schema.normal) {\n    return schema.property[schema.normal[normal]]\n  }\n\n  if (normal.length > 4 && normal.slice(0, 4) === 'data' && valid.test(value)) {\n    // Attribute or property.\n    if (value.charAt(4) === '-') {\n      // Turn it into a property.\n      const rest = value.slice(5).replace(dash, camelcase)\n      prop = 'data' + rest.charAt(0).toUpperCase() + rest.slice(1)\n    } else {\n      // Turn it into an attribute.\n      const rest = value.slice(4)\n\n      if (!dash.test(rest)) {\n        let dashes = rest.replace(cap, kebab)\n\n        if (dashes.charAt(0) !== '-') {\n          dashes = '-' + dashes\n        }\n\n        value = 'data' + dashes\n      }\n    }\n\n    Type = DefinedInfo\n  }\n\n  return new Type(prop, value)\n}\n\n/**\n * @param {string} $0\n * @returns {string}\n */\nfunction kebab($0) {\n  return '-' + $0.toLowerCase()\n}\n\n/**\n * @param {string} $0\n * @returns {string}\n */\nfunction camelcase($0) {\n  return $0.charAt(1).toUpperCase()\n}\n","/**\n * `hast` is close to `React`, but differs in a couple of cases.\n *\n * To get a React property from a hast property, check if it is in\n * `hastToReact`, if it is, then use the corresponding value,\n * otherwise, use the hast property.\n *\n * @type {Record<string, string>}\n */\nexport const hastToReact = {\n  classId: 'classID',\n  dataType: 'datatype',\n  itemId: 'itemID',\n  strokeDashArray: 'strokeDasharray',\n  strokeDashOffset: 'strokeDashoffset',\n  strokeLineCap: 'strokeLinecap',\n  strokeLineJoin: 'strokeLinejoin',\n  strokeMiterLimit: 'strokeMiterlimit',\n  typeOf: 'typeof',\n  xLinkActuate: 'xlinkActuate',\n  xLinkArcRole: 'xlinkArcrole',\n  xLinkHref: 'xlinkHref',\n  xLinkRole: 'xlinkRole',\n  xLinkShow: 'xlinkShow',\n  xLinkTitle: 'xlinkTitle',\n  xLinkType: 'xlinkType',\n  xmlnsXLink: 'xmlnsXlink'\n}\n","/**\n * Parse space-separated tokens to an array of strings.\n *\n * @param {string} value\n *   Space-separated tokens.\n * @returns {Array<string>}\n *   List of tokens.\n */\nexport function parse(value) {\n  const input = String(value || '').trim()\n  return input ? input.split(/[ \\t\\n\\r\\f]+/g) : []\n}\n\n/**\n * Serialize an array of strings as space separated-tokens.\n *\n * @param {Array<string|number>} values\n *   List of tokens.\n * @returns {string}\n *   Space-separated tokens.\n */\nexport function stringify(values) {\n  return values.join(' ').trim()\n}\n","import StyleToObject from '../cjs/index.js';\n\n// ensure compatibility with rollup umd build\nexport default StyleToObject.default || StyleToObject;\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef NodeLike\n * @property {string} type\n * @property {PositionLike | null | undefined} [position]\n *\n * @typedef PositionLike\n * @property {PointLike | null | undefined} [start]\n * @property {PointLike | null | undefined} [end]\n *\n * @typedef PointLike\n * @property {number | null | undefined} [line]\n * @property {number | null | undefined} [column]\n * @property {number | null | undefined} [offset]\n */\n\n/**\n * Get the ending point of `node`.\n *\n * @param node\n *   Node.\n * @returns\n *   Point.\n */\nexport const pointEnd = point('end')\n\n/**\n * Get the starting point of `node`.\n *\n * @param node\n *   Node.\n * @returns\n *   Point.\n */\nexport const pointStart = point('start')\n\n/**\n * Get the positional info of `node`.\n *\n * @param {'end' | 'start'} type\n *   Side.\n * @returns\n *   Getter.\n */\nfunction point(type) {\n  return point\n\n  /**\n   * Get the point info of `node` at a bound side.\n   *\n   * @param {Node | NodeLike | null | undefined} [node]\n   * @returns {Point | undefined}\n   */\n  function point(node) {\n    const point = (node && node.position && node.position[type]) || {}\n\n    if (\n      typeof point.line === 'number' &&\n      point.line > 0 &&\n      typeof point.column === 'number' &&\n      point.column > 0\n    ) {\n      return {\n        line: point.line,\n        column: point.column,\n        offset:\n          typeof point.offset === 'number' && point.offset > -1\n            ? point.offset\n            : undefined\n      }\n    }\n  }\n}\n\n/**\n * Get the positional info of `node`.\n *\n * @param {Node | NodeLike | null | undefined} [node]\n *   Node.\n * @returns {Position | undefined}\n *   Position.\n */\nexport function position(node) {\n  const start = pointStart(node)\n  const end = pointEnd(node)\n\n  if (start && end) {\n    return {start, end}\n  }\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef NodeLike\n * @property {string} type\n * @property {PositionLike | null | undefined} [position]\n *\n * @typedef PointLike\n * @property {number | null | undefined} [line]\n * @property {number | null | undefined} [column]\n * @property {number | null | undefined} [offset]\n *\n * @typedef PositionLike\n * @property {PointLike | null | undefined} [start]\n * @property {PointLike | null | undefined} [end]\n */\n\n/**\n * Serialize the positional info of a point, position (start and end points),\n * or node.\n *\n * @param {Node | NodeLike | Point | PointLike | Position | PositionLike | null | undefined} [value]\n *   Node, position, or point.\n * @returns {string}\n *   Pretty printed positional info of a node (`string`).\n *\n *   In the format of a range `ls:cs-le:ce` (when given `node` or `position`)\n *   or a point `l:c` (when given `point`), where `l` stands for line, `c` for\n *   column, `s` for `start`, and `e` for end.\n *   An empty string (`''`) is returned if the given value is neither `node`,\n *   `position`, nor `point`.\n */\nexport function stringifyPosition(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return ''\n  }\n\n  // Node.\n  if ('position' in value || 'type' in value) {\n    return position(value.position)\n  }\n\n  // Position.\n  if ('start' in value || 'end' in value) {\n    return position(value)\n  }\n\n  // Point.\n  if ('line' in value || 'column' in value) {\n    return point(value)\n  }\n\n  // ?\n  return ''\n}\n\n/**\n * @param {Point | PointLike | null | undefined} point\n * @returns {string}\n */\nfunction point(point) {\n  return index(point && point.line) + ':' + index(point && point.column)\n}\n\n/**\n * @param {Position | PositionLike | null | undefined} pos\n * @returns {string}\n */\nfunction position(pos) {\n  return point(pos && pos.start) + '-' + point(pos && pos.end)\n}\n\n/**\n * @param {number | null | undefined} value\n * @returns {number}\n */\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef {object & {type: string, position?: Position | undefined}} NodeLike\n *\n * @typedef Options\n *   Configuration.\n * @property {Array<Node> | null | undefined} [ancestors]\n *   Stack of (inclusive) ancestor nodes surrounding the message (optional).\n * @property {Error | null | undefined} [cause]\n *   Original error cause of the message (optional).\n * @property {Point | Position | null | undefined} [place]\n *   Place of message (optional).\n * @property {string | null | undefined} [ruleId]\n *   Category of message (optional, example: `'my-rule'`).\n * @property {string | null | undefined} [source]\n *   Namespace of who sent the message (optional, example: `'my-package'`).\n */\n\nimport {stringifyPosition} from 'unist-util-stringify-position'\n\n/**\n * Message.\n */\nexport class VFileMessage extends Error {\n  /**\n   * Create a message for `reason`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Options | null | undefined} [options]\n   * @returns\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | Options | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns\n   *   Instance of `VFileMessage`.\n   */\n  // eslint-disable-next-line complexity\n  constructor(causeOrReason, optionsOrParentOrPlace, origin) {\n    super()\n\n    if (typeof optionsOrParentOrPlace === 'string') {\n      origin = optionsOrParentOrPlace\n      optionsOrParentOrPlace = undefined\n    }\n\n    /** @type {string} */\n    let reason = ''\n    /** @type {Options} */\n    let options = {}\n    let legacyCause = false\n\n    if (optionsOrParentOrPlace) {\n      // Point.\n      if (\n        'line' in optionsOrParentOrPlace &&\n        'column' in optionsOrParentOrPlace\n      ) {\n        options = {place: optionsOrParentOrPlace}\n      }\n      // Position.\n      else if (\n        'start' in optionsOrParentOrPlace &&\n        'end' in optionsOrParentOrPlace\n      ) {\n        options = {place: optionsOrParentOrPlace}\n      }\n      // Node.\n      else if ('type' in optionsOrParentOrPlace) {\n        options = {\n          ancestors: [optionsOrParentOrPlace],\n          place: optionsOrParentOrPlace.position\n        }\n      }\n      // Options.\n      else {\n        options = {...optionsOrParentOrPlace}\n      }\n    }\n\n    if (typeof causeOrReason === 'string') {\n      reason = causeOrReason\n    }\n    // Error.\n    else if (!options.cause && causeOrReason) {\n      legacyCause = true\n      reason = causeOrReason.message\n      options.cause = causeOrReason\n    }\n\n    if (!options.ruleId && !options.source && typeof origin === 'string') {\n      const index = origin.indexOf(':')\n\n      if (index === -1) {\n        options.ruleId = origin\n      } else {\n        options.source = origin.slice(0, index)\n        options.ruleId = origin.slice(index + 1)\n      }\n    }\n\n    if (!options.place && options.ancestors && options.ancestors) {\n      const parent = options.ancestors[options.ancestors.length - 1]\n\n      if (parent) {\n        options.place = parent.position\n      }\n    }\n\n    const start =\n      options.place && 'start' in options.place\n        ? options.place.start\n        : options.place\n\n    /* eslint-disable no-unused-expressions */\n    /**\n     * Stack of ancestor nodes surrounding the message.\n     *\n     * @type {Array<Node> | undefined}\n     */\n    this.ancestors = options.ancestors || undefined\n\n    /**\n     * Original error cause of the message.\n     *\n     * @type {Error | undefined}\n     */\n    this.cause = options.cause || undefined\n\n    /**\n     * Starting column of message.\n     *\n     * @type {number | undefined}\n     */\n    this.column = start ? start.column : undefined\n\n    /**\n     * State of problem.\n     *\n     * * `true` — error, file not usable\n     * * `false` — warning, change may be needed\n     * * `undefined` — change likely not needed\n     *\n     * @type {boolean | null | undefined}\n     */\n    this.fatal = undefined\n\n    /**\n     * Path of a file (used throughout the `VFile` ecosystem).\n     *\n     * @type {string | undefined}\n     */\n    this.file\n\n    // Field from `Error`.\n    /**\n     * Reason for message.\n     *\n     * @type {string}\n     */\n    this.message = reason\n\n    /**\n     * Starting line of error.\n     *\n     * @type {number | undefined}\n     */\n    this.line = start ? start.line : undefined\n\n    // Field from `Error`.\n    /**\n     * Serialized positional info of message.\n     *\n     * On normal errors, this would be something like `ParseError`, buit in\n     * `VFile` messages we use this space to show where an error happened.\n     */\n    this.name = stringifyPosition(options.place) || '1:1'\n\n    /**\n     * Place of message.\n     *\n     * @type {Point | Position | undefined}\n     */\n    this.place = options.place || undefined\n\n    /**\n     * Reason for message, should use markdown.\n     *\n     * @type {string}\n     */\n    this.reason = this.message\n\n    /**\n     * Category of message (example: `'my-rule'`).\n     *\n     * @type {string | undefined}\n     */\n    this.ruleId = options.ruleId || undefined\n\n    /**\n     * Namespace of message (example: `'my-package'`).\n     *\n     * @type {string | undefined}\n     */\n    this.source = options.source || undefined\n\n    // Field from `Error`.\n    /**\n     * Stack of message.\n     *\n     * This is used by normal errors to show where something happened in\n     * programming code, irrelevant for `VFile` messages,\n     *\n     * @type {string}\n     */\n    this.stack =\n      legacyCause && options.cause && typeof options.cause.stack === 'string'\n        ? options.cause.stack\n        : ''\n\n    // The following fields are “well known”.\n    // Not standard.\n    // Feel free to add other non-standard fields to your messages.\n\n    /**\n     * Specify the source value that’s being reported, which is deemed\n     * incorrect.\n     *\n     * @type {string | undefined}\n     */\n    this.actual\n\n    /**\n     * Suggest acceptable values that can be used instead of `actual`.\n     *\n     * @type {Array<string> | undefined}\n     */\n    this.expected\n\n    /**\n     * Long form description of the message (you should use markdown).\n     *\n     * @type {string | undefined}\n     */\n    this.note\n\n    /**\n     * Link to docs for the message.\n     *\n     * > 👉 **Note**: this must be an absolute URL that can be passed as `x`\n     * > to `new URL(x)`.\n     *\n     * @type {string | undefined}\n     */\n    this.url\n    /* eslint-enable no-unused-expressions */\n  }\n}\n\nVFileMessage.prototype.file = ''\nVFileMessage.prototype.name = ''\nVFileMessage.prototype.reason = ''\nVFileMessage.prototype.message = ''\nVFileMessage.prototype.stack = ''\nVFileMessage.prototype.column = undefined\nVFileMessage.prototype.line = undefined\nVFileMessage.prototype.ancestors = undefined\nVFileMessage.prototype.cause = undefined\nVFileMessage.prototype.fatal = undefined\nVFileMessage.prototype.place = undefined\nVFileMessage.prototype.ruleId = undefined\nVFileMessage.prototype.source = undefined\n","/**\n * @import {Identifier, Literal, MemberExpression} from 'estree'\n * @import {Jsx, JsxDev, Options, Props} from 'hast-util-to-jsx-runtime'\n * @import {Element, Nodes, Parents, Root, Text} from 'hast'\n * @import {MdxFlowExpressionHast, MdxTextExpressionHast} from 'mdast-util-mdx-expression'\n * @import {MdxJsxFlowElementHast, MdxJsxTextElementHast} from 'mdast-util-mdx-jsx'\n * @import {MdxjsEsmHast} from 'mdast-util-mdxjs-esm'\n * @import {Position} from 'unist'\n * @import {Child, Create, Field, State, Style} from './types.js'\n */\n\nimport {stringify as commas} from 'comma-separated-tokens'\nimport {ok as assert} from 'devlop'\nimport {name as isIdentifierName} from 'estree-util-is-identifier-name'\nimport {whitespace} from 'hast-util-whitespace'\nimport {find, hastToReact, html, svg} from 'property-information'\nimport {stringify as spaces} from 'space-separated-tokens'\nimport styleToObject from 'style-to-object'\nimport {pointStart} from 'unist-util-position'\nimport {VFileMessage} from 'vfile-message'\n\n// To do: next major: `Object.hasOwn`.\nconst own = {}.hasOwnProperty\n\n/** @type {Map<string, number>} */\nconst emptyMap = new Map()\n\nconst cap = /[A-Z]/g\nconst dashSomething = /-([a-z])/g\n\n// `react-dom` triggers a warning for *any* white space in tables.\n// To follow GFM, `mdast-util-to-hast` injects line endings between elements.\n// Other tools might do so too, but they don’t do here, so we remove all of\n// that.\n\n// See: <https://github.com/facebook/react/pull/7081>.\n// See: <https://github.com/facebook/react/pull/7515>.\n// See: <https://github.com/remarkjs/remark-react/issues/64>.\n// See: <https://github.com/rehypejs/rehype-react/pull/29>.\n// See: <https://github.com/rehypejs/rehype-react/pull/32>.\n// See: <https://github.com/rehypejs/rehype-react/pull/45>.\nconst tableElements = new Set(['table', 'tbody', 'thead', 'tfoot', 'tr'])\n\nconst tableCellElement = new Set(['td', 'th'])\n\nconst docs = 'https://github.com/syntax-tree/hast-util-to-jsx-runtime'\n\n/**\n * Transform a hast tree to preact, react, solid, svelte, vue, etc.,\n * with an automatic JSX runtime.\n *\n * @param {Nodes} tree\n *   Tree to transform.\n * @param {Options} options\n *   Configuration (required).\n * @returns {JSX.Element}\n *   JSX element.\n */\n\nexport function toJsxRuntime(tree, options) {\n  if (!options || options.Fragment === undefined) {\n    throw new TypeError('Expected `Fragment` in options')\n  }\n\n  const filePath = options.filePath || undefined\n  /** @type {Create} */\n  let create\n\n  if (options.development) {\n    if (typeof options.jsxDEV !== 'function') {\n      throw new TypeError(\n        'Expected `jsxDEV` in options when `development: true`'\n      )\n    }\n\n    create = developmentCreate(filePath, options.jsxDEV)\n  } else {\n    if (typeof options.jsx !== 'function') {\n      throw new TypeError('Expected `jsx` in production options')\n    }\n\n    if (typeof options.jsxs !== 'function') {\n      throw new TypeError('Expected `jsxs` in production options')\n    }\n\n    create = productionCreate(filePath, options.jsx, options.jsxs)\n  }\n\n  /** @type {State} */\n  const state = {\n    Fragment: options.Fragment,\n    ancestors: [],\n    components: options.components || {},\n    create,\n    elementAttributeNameCase: options.elementAttributeNameCase || 'react',\n    evaluater: options.createEvaluater ? options.createEvaluater() : undefined,\n    filePath,\n    ignoreInvalidStyle: options.ignoreInvalidStyle || false,\n    passKeys: options.passKeys !== false,\n    passNode: options.passNode || false,\n    schema: options.space === 'svg' ? svg : html,\n    stylePropertyNameCase: options.stylePropertyNameCase || 'dom',\n    tableCellAlignToStyle: options.tableCellAlignToStyle !== false\n  }\n\n  const result = one(state, tree, undefined)\n\n  // JSX element.\n  if (result && typeof result !== 'string') {\n    return result\n  }\n\n  // Text node or something that turned into nothing.\n  return state.create(\n    tree,\n    state.Fragment,\n    {children: result || undefined},\n    undefined\n  )\n}\n\n/**\n * Transform a node.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Nodes} node\n *   Current node.\n * @param {string | undefined} key\n *   Key.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction one(state, node, key) {\n  if (node.type === 'element') {\n    return element(state, node, key)\n  }\n\n  if (node.type === 'mdxFlowExpression' || node.type === 'mdxTextExpression') {\n    return mdxExpression(state, node)\n  }\n\n  if (node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') {\n    return mdxJsxElement(state, node, key)\n  }\n\n  if (node.type === 'mdxjsEsm') {\n    return mdxEsm(state, node)\n  }\n\n  if (node.type === 'root') {\n    return root(state, node, key)\n  }\n\n  if (node.type === 'text') {\n    return text(state, node)\n  }\n}\n\n/**\n * Handle element.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Element} node\n *   Current node.\n * @param {string | undefined} key\n *   Key.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction element(state, node, key) {\n  const parentSchema = state.schema\n  let schema = parentSchema\n\n  if (node.tagName.toLowerCase() === 'svg' && parentSchema.space === 'html') {\n    schema = svg\n    state.schema = schema\n  }\n\n  state.ancestors.push(node)\n\n  const type = findComponentFromName(state, node.tagName, false)\n  const props = createElementProps(state, node)\n  let children = createChildren(state, node)\n\n  if (tableElements.has(node.tagName)) {\n    children = children.filter(function (child) {\n      return typeof child === 'string' ? !whitespace(child) : true\n    })\n  }\n\n  addNode(state, props, type, node)\n  addChildren(props, children)\n\n  // Restore.\n  state.ancestors.pop()\n  state.schema = parentSchema\n\n  return state.create(node, type, props, key)\n}\n\n/**\n * Handle MDX expression.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdxFlowExpressionHast | MdxTextExpressionHast} node\n *   Current node.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction mdxExpression(state, node) {\n  if (node.data && node.data.estree && state.evaluater) {\n    const program = node.data.estree\n    const expression = program.body[0]\n    assert(expression.type === 'ExpressionStatement')\n\n    // Assume result is a child.\n    return /** @type {Child | undefined} */ (\n      state.evaluater.evaluateExpression(expression.expression)\n    )\n  }\n\n  crashEstree(state, node.position)\n}\n\n/**\n * Handle MDX ESM.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdxjsEsmHast} node\n *   Current node.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction mdxEsm(state, node) {\n  if (node.data && node.data.estree && state.evaluater) {\n    // Assume result is a child.\n    return /** @type {Child | undefined} */ (\n      state.evaluater.evaluateProgram(node.data.estree)\n    )\n  }\n\n  crashEstree(state, node.position)\n}\n\n/**\n * Handle MDX JSX.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdxJsxFlowElementHast | MdxJsxTextElementHast} node\n *   Current node.\n * @param {string | undefined} key\n *   Key.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction mdxJsxElement(state, node, key) {\n  const parentSchema = state.schema\n  let schema = parentSchema\n\n  if (node.name === 'svg' && parentSchema.space === 'html') {\n    schema = svg\n    state.schema = schema\n  }\n\n  state.ancestors.push(node)\n\n  const type =\n    node.name === null\n      ? state.Fragment\n      : findComponentFromName(state, node.name, true)\n  const props = createJsxElementProps(state, node)\n  const children = createChildren(state, node)\n\n  addNode(state, props, type, node)\n  addChildren(props, children)\n\n  // Restore.\n  state.ancestors.pop()\n  state.schema = parentSchema\n\n  return state.create(node, type, props, key)\n}\n\n/**\n * Handle root.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Root} node\n *   Current node.\n * @param {string | undefined} key\n *   Key.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction root(state, node, key) {\n  /** @type {Props} */\n  const props = {}\n\n  addChildren(props, createChildren(state, node))\n\n  return state.create(node, state.Fragment, props, key)\n}\n\n/**\n * Handle text.\n *\n * @param {State} _\n *   Info passed around.\n * @param {Text} node\n *   Current node.\n * @returns {Child | undefined}\n *   Child, optional.\n */\nfunction text(_, node) {\n  return node.value\n}\n\n/**\n * Add `node` to props.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Props} props\n *   Props.\n * @param {unknown} type\n *   Type.\n * @param {Element | MdxJsxFlowElementHast | MdxJsxTextElementHast} node\n *   Node.\n * @returns {undefined}\n *   Nothing.\n */\nfunction addNode(state, props, type, node) {\n  // If this is swapped out for a component:\n  if (typeof type !== 'string' && type !== state.Fragment && state.passNode) {\n    props.node = node\n  }\n}\n\n/**\n * Add children to props.\n *\n * @param {Props} props\n *   Props.\n * @param {Array<Child>} children\n *   Children.\n * @returns {undefined}\n *   Nothing.\n */\nfunction addChildren(props, children) {\n  if (children.length > 0) {\n    const value = children.length > 1 ? children : children[0]\n\n    if (value) {\n      props.children = value\n    }\n  }\n}\n\n/**\n * @param {string | undefined} _\n *   Path to file.\n * @param {Jsx} jsx\n *   Dynamic.\n * @param {Jsx} jsxs\n *   Static.\n * @returns {Create}\n *   Create a production element.\n */\nfunction productionCreate(_, jsx, jsxs) {\n  return create\n  /** @type {Create} */\n  function create(_, type, props, key) {\n    // Only an array when there are 2 or more children.\n    const isStaticChildren = Array.isArray(props.children)\n    const fn = isStaticChildren ? jsxs : jsx\n    return key ? fn(type, props, key) : fn(type, props)\n  }\n}\n\n/**\n * @param {string | undefined} filePath\n *   Path to file.\n * @param {JsxDev} jsxDEV\n *   Development.\n * @returns {Create}\n *   Create a development element.\n */\nfunction developmentCreate(filePath, jsxDEV) {\n  return create\n  /** @type {Create} */\n  function create(node, type, props, key) {\n    // Only an array when there are 2 or more children.\n    const isStaticChildren = Array.isArray(props.children)\n    const point = pointStart(node)\n    return jsxDEV(\n      type,\n      props,\n      key,\n      isStaticChildren,\n      {\n        columnNumber: point ? point.column - 1 : undefined,\n        fileName: filePath,\n        lineNumber: point ? point.line : undefined\n      },\n      undefined\n    )\n  }\n}\n\n/**\n * Create props from an element.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Element} node\n *   Current element.\n * @returns {Props}\n *   Props.\n */\nfunction createElementProps(state, node) {\n  /** @type {Props} */\n  const props = {}\n  /** @type {string | undefined} */\n  let alignValue\n  /** @type {string} */\n  let prop\n\n  for (prop in node.properties) {\n    if (prop !== 'children' && own.call(node.properties, prop)) {\n      const result = createProperty(state, prop, node.properties[prop])\n\n      if (result) {\n        const [key, value] = result\n\n        if (\n          state.tableCellAlignToStyle &&\n          key === 'align' &&\n          typeof value === 'string' &&\n          tableCellElement.has(node.tagName)\n        ) {\n          alignValue = value\n        } else {\n          props[key] = value\n        }\n      }\n    }\n  }\n\n  if (alignValue) {\n    // Assume style is an object.\n    const style = /** @type {Style} */ (props.style || (props.style = {}))\n    style[state.stylePropertyNameCase === 'css' ? 'text-align' : 'textAlign'] =\n      alignValue\n  }\n\n  return props\n}\n\n/**\n * Create props from a JSX element.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdxJsxFlowElementHast | MdxJsxTextElementHast} node\n *   Current JSX element.\n * @returns {Props}\n *   Props.\n */\nfunction createJsxElementProps(state, node) {\n  /** @type {Props} */\n  const props = {}\n\n  for (const attribute of node.attributes) {\n    if (attribute.type === 'mdxJsxExpressionAttribute') {\n      if (attribute.data && attribute.data.estree && state.evaluater) {\n        const program = attribute.data.estree\n        const expression = program.body[0]\n        assert(expression.type === 'ExpressionStatement')\n        const objectExpression = expression.expression\n        assert(objectExpression.type === 'ObjectExpression')\n        const property = objectExpression.properties[0]\n        assert(property.type === 'SpreadElement')\n\n        Object.assign(\n          props,\n          state.evaluater.evaluateExpression(property.argument)\n        )\n      } else {\n        crashEstree(state, node.position)\n      }\n    } else {\n      // For JSX, the author is responsible of passing in the correct values.\n      const name = attribute.name\n      /** @type {unknown} */\n      let value\n\n      if (attribute.value && typeof attribute.value === 'object') {\n        if (\n          attribute.value.data &&\n          attribute.value.data.estree &&\n          state.evaluater\n        ) {\n          const program = attribute.value.data.estree\n          const expression = program.body[0]\n          assert(expression.type === 'ExpressionStatement')\n          value = state.evaluater.evaluateExpression(expression.expression)\n        } else {\n          crashEstree(state, node.position)\n        }\n      } else {\n        value = attribute.value === null ? true : attribute.value\n      }\n\n      // Assume a prop.\n      props[name] = /** @type {Props[keyof Props]} */ (value)\n    }\n  }\n\n  return props\n}\n\n/**\n * Create children.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Parents} node\n *   Current element.\n * @returns {Array<Child>}\n *   Children.\n */\nfunction createChildren(state, node) {\n  /** @type {Array<Child>} */\n  const children = []\n  let index = -1\n  /** @type {Map<string, number>} */\n  // Note: test this when Solid doesn’t want to merge my upcoming PR.\n  /* c8 ignore next */\n  const countsByName = state.passKeys ? new Map() : emptyMap\n\n  while (++index < node.children.length) {\n    const child = node.children[index]\n    /** @type {string | undefined} */\n    let key\n\n    if (state.passKeys) {\n      const name =\n        child.type === 'element'\n          ? child.tagName\n          : child.type === 'mdxJsxFlowElement' ||\n              child.type === 'mdxJsxTextElement'\n            ? child.name\n            : undefined\n\n      if (name) {\n        const count = countsByName.get(name) || 0\n        key = name + '-' + count\n        countsByName.set(name, count + 1)\n      }\n    }\n\n    const result = one(state, child, key)\n    if (result !== undefined) children.push(result)\n  }\n\n  return children\n}\n\n/**\n * Handle a property.\n *\n * @param {State} state\n *   Info passed around.\n * @param {string} prop\n *   Key.\n * @param {Array<number | string> | boolean | number | string | null | undefined} value\n *   hast property value.\n * @returns {Field | undefined}\n *   Field for runtime, optional.\n */\nfunction createProperty(state, prop, value) {\n  const info = find(state.schema, prop)\n\n  // Ignore nullish and `NaN` values.\n  if (\n    value === null ||\n    value === undefined ||\n    (typeof value === 'number' && Number.isNaN(value))\n  ) {\n    return\n  }\n\n  if (Array.isArray(value)) {\n    // Accept `array`.\n    // Most props are space-separated.\n    value = info.commaSeparated ? commas(value) : spaces(value)\n  }\n\n  // React only accepts `style` as object.\n  if (info.property === 'style') {\n    let styleObject =\n      typeof value === 'object' ? value : parseStyle(state, String(value))\n\n    if (state.stylePropertyNameCase === 'css') {\n      styleObject = transformStylesToCssCasing(styleObject)\n    }\n\n    return ['style', styleObject]\n  }\n\n  return [\n    state.elementAttributeNameCase === 'react' && info.space\n      ? hastToReact[info.property] || info.property\n      : info.attribute,\n    value\n  ]\n}\n\n/**\n * Parse a CSS declaration to an object.\n *\n * @param {State} state\n *   Info passed around.\n * @param {string} value\n *   CSS declarations.\n * @returns {Style}\n *   Properties.\n * @throws\n *   Throws `VFileMessage` when CSS cannot be parsed.\n */\nfunction parseStyle(state, value) {\n  /** @type {Style} */\n  const result = {}\n\n  try {\n    styleToObject(value, replacer)\n  } catch (error) {\n    if (!state.ignoreInvalidStyle) {\n      const cause = /** @type {Error} */ (error)\n      const message = new VFileMessage('Cannot parse `style` attribute', {\n        ancestors: state.ancestors,\n        cause,\n        ruleId: 'style',\n        source: 'hast-util-to-jsx-runtime'\n      })\n      message.file = state.filePath || undefined\n      message.url = docs + '#cannot-parse-style-attribute'\n\n      throw message\n    }\n  }\n\n  return result\n\n  /**\n   * Add a CSS property (normal, so with dashes) to `result` as a DOM CSS\n   * property.\n   *\n   * @param {string} name\n   *   Key.\n   * @param {string} value\n   *   Value\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function replacer(name, value) {\n    let key = name\n\n    if (key.slice(0, 2) !== '--') {\n      if (key.slice(0, 4) === '-ms-') key = 'ms-' + key.slice(4)\n      key = key.replace(dashSomething, toCamel)\n    }\n\n    result[key] = value\n  }\n}\n\n/**\n * Create a JSX name from a string.\n *\n * @param {State} state\n *   To do.\n * @param {string} name\n *   Name.\n * @param {boolean} allowExpression\n *   Allow member expressions and identifiers.\n * @returns {unknown}\n *   To do.\n */\nfunction findComponentFromName(state, name, allowExpression) {\n  /** @type {Identifier | Literal | MemberExpression} */\n  let result\n\n  if (!allowExpression) {\n    result = {type: 'Literal', value: name}\n  } else if (name.includes('.')) {\n    const identifiers = name.split('.')\n    let index = -1\n    /** @type {Identifier | Literal | MemberExpression | undefined} */\n    let node\n\n    while (++index < identifiers.length) {\n      /** @type {Identifier | Literal} */\n      const prop = isIdentifierName(identifiers[index])\n        ? {type: 'Identifier', name: identifiers[index]}\n        : {type: 'Literal', value: identifiers[index]}\n      node = node\n        ? {\n            type: 'MemberExpression',\n            object: node,\n            property: prop,\n            computed: Boolean(index && prop.type === 'Literal'),\n            optional: false\n          }\n        : prop\n    }\n\n    assert(node, 'always a result')\n    result = node\n  } else {\n    result =\n      isIdentifierName(name) && !/^[a-z]/.test(name)\n        ? {type: 'Identifier', name}\n        : {type: 'Literal', value: name}\n  }\n\n  // Only literals can be passed in `components` currently.\n  // No identifiers / member expressions.\n  if (result.type === 'Literal') {\n    const name = /** @type {keyof JSX.IntrinsicElements} */ (result.value)\n\n    return own.call(state.components, name) ? state.components[name] : name\n  }\n\n  // Assume component.\n  if (state.evaluater) {\n    return state.evaluater.evaluateExpression(result)\n  }\n\n  crashEstree(state)\n}\n\n/**\n * @param {State} state\n * @param {Position | undefined} [place]\n * @returns {never}\n */\nfunction crashEstree(state, place) {\n  const message = new VFileMessage(\n    'Cannot handle MDX estrees without `createEvaluater`',\n    {\n      ancestors: state.ancestors,\n      place,\n      ruleId: 'mdx-estree',\n      source: 'hast-util-to-jsx-runtime'\n    }\n  )\n  message.file = state.filePath || undefined\n  message.url = docs + '#cannot-handle-mdx-estrees-without-createevaluater'\n\n  throw message\n}\n\n/**\n * Transform a DOM casing style object to a CSS casing style object.\n *\n * @param {Style} domCasing\n * @returns {Style}\n */\nfunction transformStylesToCssCasing(domCasing) {\n  /** @type {Style} */\n  const cssCasing = {}\n  /** @type {string} */\n  let from\n\n  for (from in domCasing) {\n    if (own.call(domCasing, from)) {\n      cssCasing[transformStyleToCssCasing(from)] = domCasing[from]\n    }\n  }\n\n  return cssCasing\n}\n\n/**\n * Transform a DOM casing style field to a CSS casing style field.\n *\n * @param {string} from\n * @returns {string}\n */\nfunction transformStyleToCssCasing(from) {\n  let to = from.replace(cap, toDash)\n  // Handle `ms-xxx` -> `-ms-xxx`.\n  if (to.slice(0, 3) === 'ms-') to = '-' + to\n  return to\n}\n\n/**\n * Make `$1` capitalized.\n *\n * @param {string} _\n *   Whatever.\n * @param {string} $1\n *   Single ASCII alphabetical.\n * @returns {string}\n *   Capitalized `$1`.\n */\nfunction toCamel(_, $1) {\n  return $1.toUpperCase()\n}\n\n/**\n * Make `$0` dash cased.\n *\n * @param {string} $0\n *   Capitalized ASCII leter.\n * @returns {string}\n *   Dash and lower letter.\n */\nfunction toDash($0) {\n  return '-' + $0.toLowerCase()\n}\n","/**\n * HTML URL properties.\n *\n * Each key is a property name and each value is a list of tag names it applies\n * to or `null` if it applies to all elements.\n *\n * @type {Record<string, Array<string> | null>}\n */\nexport const urlAttributes = {\n  action: ['form'],\n  cite: ['blockquote', 'del', 'ins', 'q'],\n  data: ['object'],\n  formAction: ['button', 'input'],\n  href: ['a', 'area', 'base', 'link'],\n  icon: ['menuitem'],\n  itemId: null,\n  manifest: ['html'],\n  ping: ['a', 'area'],\n  poster: ['video'],\n  src: [\n    'audio',\n    'embed',\n    'iframe',\n    'img',\n    'input',\n    'script',\n    'source',\n    'track',\n    'video'\n  ]\n}\n","/**\n * @typedef {import('mdast').Nodes} Nodes\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [includeImageAlt=true]\n *   Whether to use `alt` for `image`s (default: `true`).\n * @property {boolean | null | undefined} [includeHtml=true]\n *   Whether to use `value` of HTML (default: `true`).\n */\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Get the text content of a node or list of nodes.\n *\n * Prefers the node’s plain-text fields, otherwise serializes its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} [value]\n *   Thing to serialize, typically `Node`.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {string}\n *   Serialized `value`.\n */\nexport function toString(value, options) {\n  const settings = options || emptyOptions\n  const includeImageAlt =\n    typeof settings.includeImageAlt === 'boolean'\n      ? settings.includeImageAlt\n      : true\n  const includeHtml =\n    typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true\n\n  return one(value, includeImageAlt, includeHtml)\n}\n\n/**\n * One node or several nodes.\n *\n * @param {unknown} value\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized node.\n */\nfunction one(value, includeImageAlt, includeHtml) {\n  if (node(value)) {\n    if ('value' in value) {\n      return value.type === 'html' && !includeHtml ? '' : value.value\n    }\n\n    if (includeImageAlt && 'alt' in value && value.alt) {\n      return value.alt\n    }\n\n    if ('children' in value) {\n      return all(value.children, includeImageAlt, includeHtml)\n    }\n  }\n\n  if (Array.isArray(value)) {\n    return all(value, includeImageAlt, includeHtml)\n  }\n\n  return ''\n}\n\n/**\n * Serialize a list of nodes.\n *\n * @param {Array<unknown>} values\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized nodes.\n */\nfunction all(values, includeImageAlt, includeHtml) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n\n  while (++index < values.length) {\n    result[index] = one(values[index], includeImageAlt, includeHtml)\n  }\n\n  return result.join('')\n}\n\n/**\n * Check if `value` looks like a node.\n *\n * @param {unknown} value\n *   Thing.\n * @returns {value is Nodes}\n *   Whether `value` is a node.\n */\nfunction node(value) {\n  return Boolean(value && typeof value === 'object')\n}\n","/**\n * Like `Array#splice`, but smarter for giant arrays.\n *\n * `Array#splice` takes all items to be inserted as individual argument which\n * causes a stack overflow in V8 when trying to insert 100k items for instance.\n *\n * Otherwise, this does not return the removed items, and takes `items` as an\n * array instead of rest parameters.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {number} start\n *   Index to remove/insert at (can be negative).\n * @param {number} remove\n *   Number of items to remove.\n * @param {Array<T>} items\n *   Items to inject into `list`.\n * @returns {undefined}\n *   Nothing.\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length\n  let chunkStart = 0\n  /** @type {Array<unknown>} */\n  let parameters\n\n  // Make start between zero and `end` (included).\n  if (start < 0) {\n    start = -start > end ? 0 : end + start\n  } else {\n    start = start > end ? end : start\n  }\n  remove = remove > 0 ? remove : 0\n\n  // No need to chunk the items if there’s only a couple (10k) items.\n  if (items.length < 10000) {\n    parameters = Array.from(items)\n    parameters.unshift(start, remove)\n    // @ts-expect-error Hush, it’s fine.\n    list.splice(...parameters)\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) list.splice(start, remove)\n\n    // Insert the items in chunks to not cause stack overflows.\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000)\n      parameters.unshift(start, 0)\n      // @ts-expect-error Hush, it’s fine.\n      list.splice(...parameters)\n      chunkStart += 10000\n      start += 10000\n    }\n  }\n}\n\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {Array<T>} items\n *   Items to add to `list`.\n * @returns {Array<T>}\n *   Either `list` or `items`.\n */\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items)\n    return list\n  }\n  return items\n}\n","/**\n * Some of the internal operations of micromark do lots of editing\n * operations on very large arrays. This runs into problems with two\n * properties of most circa-2020 JavaScript interpreters:\n *\n *  - Array-length modifications at the high end of an array (push/pop) are\n *    expected to be common and are implemented in (amortized) time\n *    proportional to the number of elements added or removed, whereas\n *    other operations (shift/unshift and splice) are much less efficient.\n *  - Function arguments are passed on the stack, so adding tens of thousands\n *    of elements to an array with `arr.push[...newElements]` will frequently\n *    cause stack overflows. (see <https://stackoverflow.com/questions/22123769/rangeerror-maximum-call-stack-size-exceeded-why>)\n *\n * SpliceBuffers are an implementation of gap buffers, which are a\n * generalization of the \"queue made of two stacks\" idea. The splice buffer\n * maintains a cursor, and moving the cursor has cost proportional to the\n * distance the cursor moves, but inserting, deleting, or splicing in\n * new information at the cursor is as efficient as the push/pop operation.\n * This allows for an efficient sequence of splices (or pushes, pops, shifts,\n * or unshifts) as long such edits happen at the same part of the array or\n * generally sweep through the array from the beginning to the end.\n *\n * The interface for splice buffers also supports large numbers of inputs by\n * passing a single array argument rather passing multiple arguments on the\n * function call stack.\n *\n * @template T\n *   Item type.\n */\nexport class SpliceBuffer {\n  /**\n   * @param {ReadonlyArray<T> | null | undefined} [initial]\n   *   Initial items (optional).\n   * @returns\n   *   Splice buffer.\n   */\n  constructor(initial) {\n    /** @type {Array<T>} */\n    this.left = initial ? [...initial] : [];\n    /** @type {Array<T>} */\n    this.right = [];\n  }\n\n  /**\n   * Array access;\n   * does not move the cursor.\n   *\n   * @param {number} index\n   *   Index.\n   * @return {T}\n   *   Item.\n   */\n  get(index) {\n    if (index < 0 || index >= this.left.length + this.right.length) {\n      throw new RangeError('Cannot access index `' + index + '` in a splice buffer of size `' + (this.left.length + this.right.length) + '`');\n    }\n    if (index < this.left.length) return this.left[index];\n    return this.right[this.right.length - index + this.left.length - 1];\n  }\n\n  /**\n   * The length of the splice buffer, one greater than the largest index in the\n   * array.\n   */\n  get length() {\n    return this.left.length + this.right.length;\n  }\n\n  /**\n   * Remove and return `list[0]`;\n   * moves the cursor to `0`.\n   *\n   * @returns {T | undefined}\n   *   Item, optional.\n   */\n  shift() {\n    this.setCursor(0);\n    return this.right.pop();\n  }\n\n  /**\n   * Slice the buffer to get an array;\n   * does not move the cursor.\n   *\n   * @param {number} start\n   *   Start.\n   * @param {number | null | undefined} [end]\n   *   End (optional).\n   * @returns {Array<T>}\n   *   Array of items.\n   */\n  slice(start, end) {\n    /** @type {number} */\n    const stop = end === null || end === undefined ? Number.POSITIVE_INFINITY : end;\n    if (stop < this.left.length) {\n      return this.left.slice(start, stop);\n    }\n    if (start > this.left.length) {\n      return this.right.slice(this.right.length - stop + this.left.length, this.right.length - start + this.left.length).reverse();\n    }\n    return this.left.slice(start).concat(this.right.slice(this.right.length - stop + this.left.length).reverse());\n  }\n\n  /**\n   * Mimics the behavior of Array.prototype.splice() except for the change of\n   * interface necessary to avoid segfaults when patching in very large arrays.\n   *\n   * This operation moves cursor is moved to `start` and results in the cursor\n   * placed after any inserted items.\n   *\n   * @param {number} start\n   *   Start;\n   *   zero-based index at which to start changing the array;\n   *   negative numbers count backwards from the end of the array and values\n   *   that are out-of bounds are clamped to the appropriate end of the array.\n   * @param {number | null | undefined} [deleteCount=0]\n   *   Delete count (default: `0`);\n   *   maximum number of elements to delete, starting from start.\n   * @param {Array<T> | null | undefined} [items=[]]\n   *   Items to include in place of the deleted items (default: `[]`).\n   * @return {Array<T>}\n   *   Any removed items.\n   */\n  splice(start, deleteCount, items) {\n    /** @type {number} */\n    const count = deleteCount || 0;\n    this.setCursor(Math.trunc(start));\n    const removed = this.right.splice(this.right.length - count, Number.POSITIVE_INFINITY);\n    if (items) chunkedPush(this.left, items);\n    return removed.reverse();\n  }\n\n  /**\n   * Remove and return the highest-numbered item in the array, so\n   * `list[list.length - 1]`;\n   * Moves the cursor to `length`.\n   *\n   * @returns {T | undefined}\n   *   Item, optional.\n   */\n  pop() {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    return this.left.pop();\n  }\n\n  /**\n   * Inserts a single item to the high-numbered side of the array;\n   * moves the cursor to `length`.\n   *\n   * @param {T} item\n   *   Item.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  push(item) {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    this.left.push(item);\n  }\n\n  /**\n   * Inserts many items to the high-numbered side of the array.\n   * Moves the cursor to `length`.\n   *\n   * @param {Array<T>} items\n   *   Items.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  pushMany(items) {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    chunkedPush(this.left, items);\n  }\n\n  /**\n   * Inserts a single item to the low-numbered side of the array;\n   * Moves the cursor to `0`.\n   *\n   * @param {T} item\n   *   Item.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  unshift(item) {\n    this.setCursor(0);\n    this.right.push(item);\n  }\n\n  /**\n   * Inserts many items to the low-numbered side of the array;\n   * moves the cursor to `0`.\n   *\n   * @param {Array<T>} items\n   *   Items.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  unshiftMany(items) {\n    this.setCursor(0);\n    chunkedPush(this.right, items.reverse());\n  }\n\n  /**\n   * Move the cursor to a specific position in the array. Requires\n   * time proportional to the distance moved.\n   *\n   * If `n < 0`, the cursor will end up at the beginning.\n   * If `n > length`, the cursor will end up at the end.\n   *\n   * @param {number} n\n   *   Position.\n   * @return {undefined}\n   *   Nothing.\n   */\n  setCursor(n) {\n    if (n === this.left.length || n > this.left.length && this.right.length === 0 || n < 0 && this.left.length === 0) return;\n    if (n < this.left.length) {\n      // Move cursor to the this.left\n      const removed = this.left.splice(n, Number.POSITIVE_INFINITY);\n      chunkedPush(this.right, removed.reverse());\n    } else {\n      // Move cursor to the this.right\n      const removed = this.right.splice(this.left.length + this.right.length - n, Number.POSITIVE_INFINITY);\n      chunkedPush(this.left, removed.reverse());\n    }\n  }\n}\n\n/**\n * Avoid stack overflow by pushing items onto the stack in segments\n *\n * @template T\n *   Item type.\n * @param {Array<T>} list\n *   List to inject into.\n * @param {ReadonlyArray<T>} right\n *   Items to inject.\n * @return {undefined}\n *   Nothing.\n */\nfunction chunkedPush(list, right) {\n  /** @type {number} */\n  let chunkStart = 0;\n  if (right.length < 10000) {\n    list.push(...right);\n  } else {\n    while (chunkStart < right.length) {\n      list.push(...right.slice(chunkStart, chunkStart + 10000));\n      chunkStart += 10000;\n    }\n  }\n}","/**\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Token} Token\n */\n\nimport { splice } from 'micromark-util-chunked';\nimport { SpliceBuffer } from './lib/splice-buffer.js';\n\n// Hidden API exposed for testing.\nexport { SpliceBuffer } from './lib/splice-buffer.js';\n\n/**\n * Tokenize subcontent.\n *\n * @param {Array<Event>} eventsArray\n *   List of events.\n * @returns {boolean}\n *   Whether subtokens were found.\n */\n// eslint-disable-next-line complexity\nexport function subtokenize(eventsArray) {\n  /** @type {Record<string, number>} */\n  const jumps = {};\n  let index = -1;\n  /** @type {Event} */\n  let event;\n  /** @type {number | undefined} */\n  let lineIndex;\n  /** @type {number} */\n  let otherIndex;\n  /** @type {Event} */\n  let otherEvent;\n  /** @type {Array<Event>} */\n  let parameters;\n  /** @type {Array<Event>} */\n  let subevents;\n  /** @type {boolean | undefined} */\n  let more;\n  const events = new SpliceBuffer(eventsArray);\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index];\n    }\n    event = events.get(index);\n\n    // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n    if (index && event[1].type === \"chunkFlow\" && events.get(index - 1)[1].type === \"listItemPrefix\") {\n      subevents = event[1]._tokenizer.events;\n      otherIndex = 0;\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === \"lineEndingBlank\") {\n        otherIndex += 2;\n      }\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === \"content\") {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === \"content\") {\n            break;\n          }\n          if (subevents[otherIndex][1].type === \"chunkText\") {\n            subevents[otherIndex][1]._isInFirstContentOfListItem = true;\n            otherIndex++;\n          }\n        }\n      }\n    }\n\n    // Enter.\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        Object.assign(jumps, subcontent(events, index));\n        index = jumps[index];\n        more = true;\n      }\n    }\n    // Exit.\n    else if (event[1]._container) {\n      otherIndex = index;\n      lineIndex = undefined;\n      while (otherIndex--) {\n        otherEvent = events.get(otherIndex);\n        if (otherEvent[1].type === \"lineEnding\" || otherEvent[1].type === \"lineEndingBlank\") {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events.get(lineIndex)[1].type = \"lineEndingBlank\";\n            }\n            otherEvent[1].type = \"lineEnding\";\n            lineIndex = otherIndex;\n          }\n        } else {\n          break;\n        }\n      }\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = Object.assign({}, events.get(lineIndex)[1].start);\n\n        // Switch container exit w/ line endings.\n        parameters = events.slice(lineIndex, index);\n        parameters.unshift(event);\n        events.splice(lineIndex, index - lineIndex + 1, parameters);\n      }\n    }\n  }\n\n  // The changes to the `events` buffer must be copied back into the eventsArray\n  splice(eventsArray, 0, Number.POSITIVE_INFINITY, events.slice(0));\n  return !more;\n}\n\n/**\n * Tokenize embedded tokens.\n *\n * @param {SpliceBuffer<Event>} events\n * @param {number} eventIndex\n * @returns {Record<string, number>}\n */\nfunction subcontent(events, eventIndex) {\n  const token = events.get(eventIndex)[1];\n  const context = events.get(eventIndex)[2];\n  let startPosition = eventIndex - 1;\n  /** @type {Array<number>} */\n  const startPositions = [];\n  const tokenizer = token._tokenizer || context.parser[token.contentType](token.start);\n  const childEvents = tokenizer.events;\n  /** @type {Array<[number, number]>} */\n  const jumps = [];\n  /** @type {Record<string, number>} */\n  const gaps = {};\n  /** @type {Array<Chunk>} */\n  let stream;\n  /** @type {Token | undefined} */\n  let previous;\n  let index = -1;\n  /** @type {Token | undefined} */\n  let current = token;\n  let adjust = 0;\n  let start = 0;\n  const breaks = [start];\n\n  // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n  while (current) {\n    // Find the position of the event for this token.\n    while (events.get(++startPosition)[1] !== current) {\n      // Empty.\n    }\n    startPositions.push(startPosition);\n    if (!current._tokenizer) {\n      stream = context.sliceStream(current);\n      if (!current.next) {\n        stream.push(null);\n      }\n      if (previous) {\n        tokenizer.defineSkip(current.start);\n      }\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true;\n      }\n      tokenizer.write(stream);\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined;\n      }\n    }\n\n    // Unravel the next token.\n    previous = current;\n    current = current.next;\n  }\n\n  // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n  current = token;\n  while (++index < childEvents.length) {\n    if (\n    // Find a void token that includes a break.\n    childEvents[index][0] === 'exit' && childEvents[index - 1][0] === 'enter' && childEvents[index][1].type === childEvents[index - 1][1].type && childEvents[index][1].start.line !== childEvents[index][1].end.line) {\n      start = index + 1;\n      breaks.push(start);\n      // Help GC.\n      current._tokenizer = undefined;\n      current.previous = undefined;\n      current = current.next;\n    }\n  }\n\n  // Help GC.\n  tokenizer.events = [];\n\n  // If there’s one more token (which is the cases for lines that end in an\n  // EOF), that’s perfect: the last point we found starts it.\n  // If there isn’t then make sure any remaining content is added to it.\n  if (current) {\n    // Help GC.\n    current._tokenizer = undefined;\n    current.previous = undefined;\n  } else {\n    breaks.pop();\n  }\n\n  // Now splice the events from the subtokenizer into the current events,\n  // moving back to front so that splice indices aren’t affected.\n  index = breaks.length;\n  while (index--) {\n    const slice = childEvents.slice(breaks[index], breaks[index + 1]);\n    const start = startPositions.pop();\n    jumps.push([start, start + slice.length - 1]);\n    events.splice(start, 2, slice);\n  }\n  jumps.reverse();\n  index = -1;\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1];\n    adjust += jumps[index][1] - jumps[index][0] - 1;\n  }\n  return gaps;\n}","/**\n * @typedef {import('micromark-util-types').Event} Event\n */\n\nimport {subtokenize} from 'micromark-util-subtokenize'\n\n/**\n * @param {Array<Event>} events\n * @returns {Array<Event>}\n */\nexport function postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n  return events\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Handles} Handles\n * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension\n * @typedef {import('micromark-util-types').NormalizedExtension} NormalizedExtension\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine multiple syntax extensions into one.\n *\n * @param {Array<Extension>} extensions\n *   List of syntax extensions.\n * @returns {NormalizedExtension}\n *   A single combined extension.\n */\nexport function combineExtensions(extensions) {\n  /** @type {NormalizedExtension} */\n  const all = {}\n  let index = -1\n\n  while (++index < extensions.length) {\n    syntaxExtension(all, extensions[index])\n  }\n\n  return all\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {NormalizedExtension} all\n *   Extension to merge into.\n * @param {Extension} extension\n *   Extension to merge.\n * @returns {undefined}\n */\nfunction syntaxExtension(all, extension) {\n  /** @type {keyof Extension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    /** @type {Record<string, unknown>} */\n    const left = maybe || (all[hook] = {})\n    /** @type {Record<string, unknown> | undefined} */\n    const right = extension[hook]\n    /** @type {string} */\n    let code\n\n    if (right) {\n      for (code in right) {\n        if (!hasOwnProperty.call(left, code)) left[code] = []\n        const value = right[code]\n        constructs(\n          // @ts-expect-error Looks like a list.\n          left[code],\n          Array.isArray(value) ? value : value ? [value] : []\n        )\n      }\n    }\n  }\n}\n\n/**\n * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {Array<unknown>} existing\n * @param {Array<unknown>} list\n * @returns {undefined}\n */\nfunction constructs(existing, list) {\n  let index = -1\n  /** @type {Array<unknown>} */\n  const before = []\n\n  while (++index < list.length) {\n    // @ts-expect-error Looks like an object.\n    ;(list[index].add === 'after' ? existing : before).push(list[index])\n  }\n\n  splice(existing, 0, 0, before)\n}\n\n/**\n * Combine multiple HTML extensions into one.\n *\n * @param {Array<HtmlExtension>} htmlExtensions\n *   List of HTML extensions.\n * @returns {HtmlExtension}\n *   A single combined HTML extension.\n */\nexport function combineHtmlExtensions(htmlExtensions) {\n  /** @type {HtmlExtension} */\n  const handlers = {}\n  let index = -1\n\n  while (++index < htmlExtensions.length) {\n    htmlExtension(handlers, htmlExtensions[index])\n  }\n\n  return handlers\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {HtmlExtension} all\n *   Extension to merge into.\n * @param {HtmlExtension} extension\n *   Extension to merge.\n * @returns {undefined}\n */\nfunction htmlExtension(all, extension) {\n  /** @type {keyof HtmlExtension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    const left = maybe || (all[hook] = {})\n    const right = extension[hook]\n    /** @type {keyof Handles} */\n    let type\n\n    if (right) {\n      for (type in right) {\n        // @ts-expect-error assume document vs regular handler are managed correctly.\n        left[type] = right[type]\n      }\n    }\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\n\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlpha = regexCheck(/[A-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\n\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  );\n}\n\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiDigit = regexCheck(/\\d/);\n\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\n\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\n\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2;\n}\n\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32);\n}\n\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32;\n}\n\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodePunctuation = regexCheck(/\\p{P}|\\p{S}/u);\n\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/);\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n * @returns {(code: Code) => boolean}\n */\nfunction regexCheck(regex) {\n  return check;\n\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code\n   *   Character code.\n   * @returns {boolean}\n   *   Whether the character code matches the bound regex.\n   */\n  function check(code) {\n    return code !== null && code > -1 && regex.test(String.fromCharCode(code));\n  }\n}","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {markdownSpace} from 'micromark-util-character'\n\n// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.\n\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   spaces in markdown are often optional, in which case this factory can be\n *     used and `ok` will be switched to whether spaces were found or not\n * *   one line ending or space can be detected with `markdownSpace(code)` right\n *     before using `factorySpace`\n *\n * ###### Examples\n *\n * Where `␉` represents a tab (plus how much it expands) and `␠` represents a\n * single space.\n *\n * ```markdown\n * ␉\n * ␠␠␠␠\n * ␉␠\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {TokenType} type\n *   Type (`' \\t'`).\n * @param {number | undefined} [max=Infinity]\n *   Max (exclusive).\n * @returns {State}\n *   Start state.\n */\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Number.POSITIVE_INFINITY\n  let size = 0\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type)\n      return prefix(code)\n    }\n    return ok(code)\n  }\n\n  /** @type {State} */\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code)\n      return prefix\n    }\n    effects.exit(type)\n    return ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n/** @type {InitialConstruct} */\nexport const content = {\n  tokenize: initializeContent\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Initializer}\n */\nfunction initializeContent(effects) {\n  const contentStart = effects.attempt(\n    this.parser.constructs.contentInitial,\n    afterContentStartConstruct,\n    paragraphInitial\n  )\n  /** @type {Token} */\n  let previous\n  return contentStart\n\n  /** @type {State} */\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, contentStart, 'linePrefix')\n  }\n\n  /** @type {State} */\n  function paragraphInitial(code) {\n    effects.enter('paragraph')\n    return lineStart(code)\n  }\n\n  /** @type {State} */\n  function lineStart(code) {\n    const token = effects.enter('chunkText', {\n      contentType: 'text',\n      previous\n    })\n    if (previous) {\n      previous.next = token\n    }\n    previous = token\n    return data(code)\n  }\n\n  /** @type {State} */\n  function data(code) {\n    if (code === null) {\n      effects.exit('chunkText')\n      effects.exit('paragraph')\n      effects.consume(code)\n      return\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      effects.exit('chunkText')\n      return lineStart\n    }\n\n    // Data.\n    effects.consume(code)\n    return data\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').ContainerState} ContainerState\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\n/**\n * @typedef {[Construct, ContainerState]} StackItem\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {splice} from 'micromark-util-chunked'\n/** @type {InitialConstruct} */\nexport const document = {\n  tokenize: initializeDocument\n}\n\n/** @type {Construct} */\nconst containerConstruct = {\n  tokenize: tokenizeContainer\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Initializer}\n */\nfunction initializeDocument(effects) {\n  const self = this\n  /** @type {Array<StackItem>} */\n  const stack = []\n  let continued = 0\n  /** @type {TokenizeContext | undefined} */\n  let childFlow\n  /** @type {Token | undefined} */\n  let childToken\n  /** @type {number} */\n  let lineStartOffset\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    // First we iterate through the open blocks, starting with the root\n    // document, and descending through last children down to the last open\n    // block.\n    // Each block imposes a condition that the line must satisfy if the block is\n    // to remain open.\n    // For example, a block quote requires a `>` character.\n    // A paragraph requires a non-blank line.\n    // In this phase we may match all or just some of the open blocks.\n    // But we cannot close unmatched blocks yet, because we may have a lazy\n    // continuation line.\n    if (continued < stack.length) {\n      const item = stack[continued]\n      self.containerState = item[1]\n      return effects.attempt(\n        item[0].continuation,\n        documentContinue,\n        checkNewContainers\n      )(code)\n    }\n\n    // Done.\n    return checkNewContainers(code)\n  }\n\n  /** @type {State} */\n  function documentContinue(code) {\n    continued++\n\n    // Note: this field is called `_closeFlow` but it also closes containers.\n    // Perhaps a good idea to rename it but it’s already used in the wild by\n    // extensions.\n    if (self.containerState._closeFlow) {\n      self.containerState._closeFlow = undefined\n      if (childFlow) {\n        closeFlow()\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when dealing with lazy lines in `writeToChild`.\n      const indexBeforeExits = self.events.length\n      let indexBeforeFlow = indexBeforeExits\n      /** @type {Point | undefined} */\n      let point\n\n      // Find the flow chunk.\n      while (indexBeforeFlow--) {\n        if (\n          self.events[indexBeforeFlow][0] === 'exit' &&\n          self.events[indexBeforeFlow][1].type === 'chunkFlow'\n        ) {\n          point = self.events[indexBeforeFlow][1].end\n          break\n        }\n      }\n      exitContainers(continued)\n\n      // Fix positions.\n      let index = indexBeforeExits\n      while (index < self.events.length) {\n        self.events[index][1].end = Object.assign({}, point)\n        index++\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(\n        self.events,\n        indexBeforeFlow + 1,\n        0,\n        self.events.slice(indexBeforeExits)\n      )\n\n      // Discard the duplicate exits.\n      self.events.length = index\n      return checkNewContainers(code)\n    }\n    return start(code)\n  }\n\n  /** @type {State} */\n  function checkNewContainers(code) {\n    // Next, after consuming the continuation markers for existing blocks, we\n    // look for new block starts (e.g. `>` for a block quote).\n    // If we encounter a new block start, we close any blocks unmatched in\n    // step 1 before creating the new block as a child of the last matched\n    // block.\n    if (continued === stack.length) {\n      // No need to `check` whether there’s a container, of `exitContainers`\n      // would be moot.\n      // We can instead immediately `attempt` to parse one.\n      if (!childFlow) {\n        return documentContinued(code)\n      }\n\n      // If we have concrete content, such as block HTML or fenced code,\n      // we can’t have containers “pierce” into them, so we can immediately\n      // start.\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        return flowStart(code)\n      }\n\n      // If we do have flow, it could still be a blank line,\n      // but we’d be interrupting it w/ a new container if there’s a current\n      // construct.\n      // To do: next major: remove `_gfmTableDynamicInterruptHack` (no longer\n      // needed in micromark-extension-gfm-table@1.0.6).\n      self.interrupt = Boolean(\n        childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack\n      )\n    }\n\n    // Check if there is a new container.\n    self.containerState = {}\n    return effects.check(\n      containerConstruct,\n      thereIsANewContainer,\n      thereIsNoNewContainer\n    )(code)\n  }\n\n  /** @type {State} */\n  function thereIsANewContainer(code) {\n    if (childFlow) closeFlow()\n    exitContainers(continued)\n    return documentContinued(code)\n  }\n\n  /** @type {State} */\n  function thereIsNoNewContainer(code) {\n    self.parser.lazy[self.now().line] = continued !== stack.length\n    lineStartOffset = self.now().offset\n    return flowStart(code)\n  }\n\n  /** @type {State} */\n  function documentContinued(code) {\n    // Try new containers.\n    self.containerState = {}\n    return effects.attempt(\n      containerConstruct,\n      containerContinue,\n      flowStart\n    )(code)\n  }\n\n  /** @type {State} */\n  function containerContinue(code) {\n    continued++\n    stack.push([self.currentConstruct, self.containerState])\n    // Try another.\n    return documentContinued(code)\n  }\n\n  /** @type {State} */\n  function flowStart(code) {\n    if (code === null) {\n      if (childFlow) closeFlow()\n      exitContainers(0)\n      effects.consume(code)\n      return\n    }\n    childFlow = childFlow || self.parser.flow(self.now())\n    effects.enter('chunkFlow', {\n      contentType: 'flow',\n      previous: childToken,\n      _tokenizer: childFlow\n    })\n    return flowContinue(code)\n  }\n\n  /** @type {State} */\n  function flowContinue(code) {\n    if (code === null) {\n      writeToChild(effects.exit('chunkFlow'), true)\n      exitContainers(0)\n      effects.consume(code)\n      return\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      writeToChild(effects.exit('chunkFlow'))\n      // Get ready for the next line.\n      continued = 0\n      self.interrupt = undefined\n      return start\n    }\n    effects.consume(code)\n    return flowContinue\n  }\n\n  /**\n   * @param {Token} token\n   * @param {boolean | undefined} [eof]\n   * @returns {undefined}\n   */\n  function writeToChild(token, eof) {\n    const stream = self.sliceStream(token)\n    if (eof) stream.push(null)\n    token.previous = childToken\n    if (childToken) childToken.next = token\n    childToken = token\n    childFlow.defineSkip(token.start)\n    childFlow.write(stream)\n\n    // Alright, so we just added a lazy line:\n    //\n    // ```markdown\n    // > a\n    // b.\n    //\n    // Or:\n    //\n    // > ~~~c\n    // d\n    //\n    // Or:\n    //\n    // > | e |\n    // f\n    // ```\n    //\n    // The construct in the second example (fenced code) does not accept lazy\n    // lines, so it marked itself as done at the end of its first line, and\n    // then the content construct parses `d`.\n    // Most constructs in markdown match on the first line: if the first line\n    // forms a construct, a non-lazy line can’t “unmake” it.\n    //\n    // The construct in the third example is potentially a GFM table, and\n    // those are *weird*.\n    // It *could* be a table, from the first line, if the following line\n    // matches a condition.\n    // In this case, that second line is lazy, which “unmakes” the first line\n    // and turns the whole into one content block.\n    //\n    // We’ve now parsed the non-lazy and the lazy line, and can figure out\n    // whether the lazy line started a new flow block.\n    // If it did, we exit the current containers between the two flow blocks.\n    if (self.parser.lazy[token.start.line]) {\n      let index = childFlow.events.length\n      while (index--) {\n        if (\n          // The token starts before the line ending…\n          childFlow.events[index][1].start.offset < lineStartOffset &&\n          // …and either is not ended yet…\n          (!childFlow.events[index][1].end ||\n            // …or ends after it.\n            childFlow.events[index][1].end.offset > lineStartOffset)\n        ) {\n          // Exit: there’s still something open, which means it’s a lazy line\n          // part of something.\n          return\n        }\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when closing flow in `documentContinue`.\n      const indexBeforeExits = self.events.length\n      let indexBeforeFlow = indexBeforeExits\n      /** @type {boolean | undefined} */\n      let seen\n      /** @type {Point | undefined} */\n      let point\n\n      // Find the previous chunk (the one before the lazy line).\n      while (indexBeforeFlow--) {\n        if (\n          self.events[indexBeforeFlow][0] === 'exit' &&\n          self.events[indexBeforeFlow][1].type === 'chunkFlow'\n        ) {\n          if (seen) {\n            point = self.events[indexBeforeFlow][1].end\n            break\n          }\n          seen = true\n        }\n      }\n      exitContainers(continued)\n\n      // Fix positions.\n      index = indexBeforeExits\n      while (index < self.events.length) {\n        self.events[index][1].end = Object.assign({}, point)\n        index++\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(\n        self.events,\n        indexBeforeFlow + 1,\n        0,\n        self.events.slice(indexBeforeExits)\n      )\n\n      // Discard the duplicate exits.\n      self.events.length = index\n    }\n  }\n\n  /**\n   * @param {number} size\n   * @returns {undefined}\n   */\n  function exitContainers(size) {\n    let index = stack.length\n\n    // Exit open containers.\n    while (index-- > size) {\n      const entry = stack[index]\n      self.containerState = entry[1]\n      entry[0].exit.call(self, effects)\n    }\n    stack.length = size\n  }\n  function closeFlow() {\n    childFlow.write([null])\n    childToken = undefined\n    childFlow = undefined\n    self.containerState._closeFlow = undefined\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeContainer(effects, ok, nok) {\n  // Always populated by defaults.\n\n  return factorySpace(\n    effects,\n    effects.attempt(this.parser.constructs.document, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4\n  )\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blankLine = {\n  tokenize: tokenizeBlankLine,\n  partial: true\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of blank line.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *     ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    return markdownSpace(code) ? factorySpace(effects, after, \"linePrefix\")(code) : after(code);\n  }\n\n  /**\n   * At eof/eol, after optional whitespace.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *       ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { subtokenize } from 'micromark-util-subtokenize';\n/**\n * No name because it must not be turned off.\n * @type {Construct}\n */\nexport const content = {\n  tokenize: tokenizeContent,\n  resolve: resolveContent\n};\n\n/** @type {Construct} */\nconst continuationConstruct = {\n  tokenize: tokenizeContinuation,\n  partial: true\n};\n\n/**\n * Content is transparent: it’s parsed right now. That way, definitions are also\n * parsed right now: before text in paragraphs (specifically, media) are parsed.\n *\n * @type {Resolver}\n */\nfunction resolveContent(events) {\n  subtokenize(events);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeContent(effects, ok) {\n  /** @type {Token | undefined} */\n  let previous;\n  return chunkStart;\n\n  /**\n   * Before a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkStart(code) {\n    effects.enter(\"content\");\n    previous = effects.enter(\"chunkContent\", {\n      contentType: \"content\"\n    });\n    return chunkInside(code);\n  }\n\n  /**\n   * In a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkInside(code) {\n    if (code === null) {\n      return contentEnd(code);\n    }\n\n    // To do: in `markdown-rs`, each line is parsed on its own, and everything\n    // is stitched together resolving.\n    if (markdownLineEnding(code)) {\n      return effects.check(continuationConstruct, contentContinue, contentEnd)(code);\n    }\n\n    // Data.\n    effects.consume(code);\n    return chunkInside;\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentEnd(code) {\n    effects.exit(\"chunkContent\");\n    effects.exit(\"content\");\n    return ok(code);\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentContinue(code) {\n    effects.consume(code);\n    effects.exit(\"chunkContent\");\n    previous.next = effects.enter(\"chunkContent\", {\n      contentType: \"content\",\n      previous\n    });\n    previous = previous.next;\n    return chunkInside;\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeContinuation(effects, ok, nok) {\n  const self = this;\n  return startLookahead;\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function startLookahead(code) {\n    effects.exit(\"chunkContent\");\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, prefixed, \"linePrefix\");\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    // Always populated by defaults.\n\n    const tail = self.events[self.events.length - 1];\n    if (!self.parser.constructs.disable.null.includes('codeIndented') && tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4) {\n      return ok(code);\n    }\n    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\nimport {blankLine, content} from 'micromark-core-commonmark'\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n/** @type {InitialConstruct} */\nexport const flow = {\n  tokenize: initializeFlow\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Initializer}\n */\nfunction initializeFlow(effects) {\n  const self = this\n  const initial = effects.attempt(\n    // Try to parse a blank line.\n    blankLine,\n    atBlankEnding,\n    // Try to parse initial flow (essentially, only code).\n    effects.attempt(\n      this.parser.constructs.flowInitial,\n      afterConstruct,\n      factorySpace(\n        effects,\n        effects.attempt(\n          this.parser.constructs.flow,\n          afterConstruct,\n          effects.attempt(content, afterConstruct)\n        ),\n        'linePrefix'\n      )\n    )\n  )\n  return initial\n\n  /** @type {State} */\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n    effects.enter('lineEndingBlank')\n    effects.consume(code)\n    effects.exit('lineEndingBlank')\n    self.currentConstruct = undefined\n    return initial\n  }\n\n  /** @type {State} */\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    self.currentConstruct = undefined\n    return initial\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\nexport const resolver = {\n  resolveAll: createResolver()\n}\nexport const string = initializeFactory('string')\nexport const text = initializeFactory('text')\n\n/**\n * @param {'string' | 'text'} field\n * @returns {InitialConstruct}\n */\nfunction initializeFactory(field) {\n  return {\n    tokenize: initializeText,\n    resolveAll: createResolver(\n      field === 'text' ? resolveAllLineSuffixes : undefined\n    )\n  }\n\n  /**\n   * @this {TokenizeContext}\n   * @type {Initializer}\n   */\n  function initializeText(effects) {\n    const self = this\n    const constructs = this.parser.constructs[field]\n    const text = effects.attempt(constructs, start, notText)\n    return start\n\n    /** @type {State} */\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code)\n    }\n\n    /** @type {State} */\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code)\n        return\n      }\n      effects.enter('data')\n      effects.consume(code)\n      return data\n    }\n\n    /** @type {State} */\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit('data')\n        return text(code)\n      }\n\n      // Data.\n      effects.consume(code)\n      return data\n    }\n\n    /**\n     * @param {Code} code\n     * @returns {boolean}\n     */\n    function atBreak(code) {\n      if (code === null) {\n        return true\n      }\n      const list = constructs[code]\n      let index = -1\n      if (list) {\n        // Always populated by defaults.\n\n        while (++index < list.length) {\n          const item = list[index]\n          if (!item.previous || item.previous.call(self, self.previous)) {\n            return true\n          }\n        }\n      }\n      return false\n    }\n  }\n}\n\n/**\n * @param {Resolver | undefined} [extraResolver]\n * @returns {Resolver}\n */\nfunction createResolver(extraResolver) {\n  return resolveAllText\n\n  /** @type {Resolver} */\n  function resolveAllText(events, context) {\n    let index = -1\n    /** @type {number | undefined} */\n    let enter\n\n    // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === 'data') {\n          enter = index\n          index++\n        }\n      } else if (!events[index] || events[index][1].type !== 'data') {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end\n          events.splice(enter + 2, index - enter - 2)\n          index = enter + 2\n        }\n        enter = undefined\n      }\n    }\n    return extraResolver ? extraResolver(events, context) : events\n  }\n}\n\n/**\n * A rather ugly set of instructions which again looks at chunks in the input\n * stream.\n * The reason to do this here is that it is *much* faster to parse in reverse.\n * And that we can’t hook into `null` to split the line suffix before an EOF.\n * To do: figure out if we can make this into a clean utility, or even in core.\n * As it will be useful for GFMs literal autolink extension (and maybe even\n * tables?)\n *\n * @type {Resolver}\n */\nfunction resolveAllLineSuffixes(events, context) {\n  let eventIndex = 0 // Skip first.\n\n  while (++eventIndex <= events.length) {\n    if (\n      (eventIndex === events.length ||\n        events[eventIndex][1].type === 'lineEnding') &&\n      events[eventIndex - 1][1].type === 'data'\n    ) {\n      const data = events[eventIndex - 1][1]\n      const chunks = context.sliceStream(data)\n      let index = chunks.length\n      let bufferIndex = -1\n      let size = 0\n      /** @type {boolean | undefined} */\n      let tabs\n      while (index--) {\n        const chunk = chunks[index]\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++\n            bufferIndex--\n          }\n          if (bufferIndex) break\n          bufferIndex = -1\n        }\n        // Number\n        else if (chunk === -2) {\n          tabs = true\n          size++\n        } else if (chunk === -1) {\n          // Empty\n        } else {\n          // Replacement character, exit.\n          index++\n          break\n        }\n      }\n      if (size) {\n        const token = {\n          type:\n            eventIndex === events.length || tabs || size < 2\n              ? 'lineSuffix'\n              : 'hardBreakTrailing',\n          start: {\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size,\n            _index: data.start._index + index,\n            _bufferIndex: index\n              ? bufferIndex\n              : data.start._bufferIndex + bufferIndex\n          },\n          end: Object.assign({}, data.end)\n        }\n        data.end = Object.assign({}, token.start)\n        if (data.start.offset === data.end.offset) {\n          Object.assign(data, token)\n        } else {\n          events.splice(\n            eventIndex,\n            0,\n            ['enter', token, context],\n            ['exit', token, context]\n          )\n          eventIndex += 2\n        }\n      }\n      eventIndex++\n    }\n  }\n  return events\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {Array<{resolveAll?: Resolver | undefined}>} constructs\n *   List of constructs, optionally with `resolveAll`s.\n * @param {Array<Event>} events\n *   List of events.\n * @param {TokenizeContext} context\n *   Context used by `tokenize`.\n * @returns {Array<Event>}\n *   Changed events.\n */\nexport function resolveAll(constructs, events, context) {\n  /** @type {Array<Resolver>} */\n  const called = []\n  let index = -1\n\n  while (++index < constructs.length) {\n    const resolve = constructs[index].resolveAll\n\n    if (resolve && !called.includes(resolve)) {\n      events = resolve(events, context)\n      called.push(resolve)\n    }\n  }\n\n  return events\n}\n","/**\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenType} TokenType\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\n/**\n * @callback Restore\n * @returns {undefined}\n *\n * @typedef Info\n * @property {Restore} restore\n * @property {number} from\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n * @param {Info} info\n * @returns {undefined}\n */\n\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {push, splice} from 'micromark-util-chunked'\nimport {resolveAll} from 'micromark-util-resolve-all'\n/**\n * Create a tokenizer.\n * Tokenizers deal with one type of data (e.g., containers, flow, text).\n * The parser is the object dealing with it all.\n * `initialize` works like other constructs, except that only its `tokenize`\n * function is used, in which case it doesn’t receive an `ok` or `nok`.\n * `from` can be given to set the point before the first character, although\n * when further lines are indented, they must be set with `defineSkip`.\n *\n * @param {ParseContext} parser\n * @param {InitialConstruct} initialize\n * @param {Omit<Point, '_bufferIndex' | '_index'> | undefined} [from]\n * @returns {TokenizeContext}\n */\nexport function createTokenizer(parser, initialize, from) {\n  /** @type {Point} */\n  let point = Object.assign(\n    from\n      ? Object.assign({}, from)\n      : {\n          line: 1,\n          column: 1,\n          offset: 0\n        },\n    {\n      _index: 0,\n      _bufferIndex: -1\n    }\n  )\n  /** @type {Record<string, number>} */\n  const columnStart = {}\n  /** @type {Array<Construct>} */\n  const resolveAllConstructs = []\n  /** @type {Array<Chunk>} */\n  let chunks = []\n  /** @type {Array<Token>} */\n  let stack = []\n  /** @type {boolean | undefined} */\n  let consumed = true\n\n  /**\n   * Tools used for tokenizing.\n   *\n   * @type {Effects}\n   */\n  const effects = {\n    consume,\n    enter,\n    exit,\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    })\n  }\n\n  /**\n   * State and tools for resolving and serializing.\n   *\n   * @type {TokenizeContext}\n   */\n  const context = {\n    previous: null,\n    code: null,\n    containerState: {},\n    events: [],\n    parser,\n    sliceStream,\n    sliceSerialize,\n    now,\n    defineSkip,\n    write\n  }\n\n  /**\n   * The state function.\n   *\n   * @type {State | undefined}\n   */\n  let state = initialize.tokenize.call(context, effects)\n\n  /**\n   * Track which character we expect to be consumed, to catch bugs.\n   *\n   * @type {Code}\n   */\n  let expectedCode\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize)\n  }\n  return context\n\n  /** @type {TokenizeContext['write']} */\n  function write(slice) {\n    chunks = push(chunks, slice)\n    main()\n\n    // Exit if we’re not done, resolve might change stuff.\n    if (chunks[chunks.length - 1] !== null) {\n      return []\n    }\n    addResult(initialize, 0)\n\n    // Otherwise, resolve, and exit.\n    context.events = resolveAll(resolveAllConstructs, context.events, context)\n    return context.events\n  }\n\n  //\n  // Tools.\n  //\n\n  /** @type {TokenizeContext['sliceSerialize']} */\n  function sliceSerialize(token, expandTabs) {\n    return serializeChunks(sliceStream(token), expandTabs)\n  }\n\n  /** @type {TokenizeContext['sliceStream']} */\n  function sliceStream(token) {\n    return sliceChunks(chunks, token)\n  }\n\n  /** @type {TokenizeContext['now']} */\n  function now() {\n    // This is a hot path, so we clone manually instead of `Object.assign({}, point)`\n    const {line, column, offset, _index, _bufferIndex} = point\n    return {\n      line,\n      column,\n      offset,\n      _index,\n      _bufferIndex\n    }\n  }\n\n  /** @type {TokenizeContext['defineSkip']} */\n  function defineSkip(value) {\n    columnStart[value.line] = value.column\n    accountForPotentialSkip()\n  }\n\n  //\n  // State management.\n  //\n\n  /**\n   * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n   * `consume`).\n   * Here is where we walk through the chunks, which either include strings of\n   * several characters, or numerical character codes.\n   * The reason to do this in a loop instead of a call is so the stack can\n   * drain.\n   *\n   * @returns {undefined}\n   */\n  function main() {\n    /** @type {number} */\n    let chunkIndex\n    while (point._index < chunks.length) {\n      const chunk = chunks[point._index]\n\n      // If we’re in a buffer chunk, loop through it.\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0\n        }\n        while (\n          point._index === chunkIndex &&\n          point._bufferIndex < chunk.length\n        ) {\n          go(chunk.charCodeAt(point._bufferIndex))\n        }\n      } else {\n        go(chunk)\n      }\n    }\n  }\n\n  /**\n   * Deal with one code.\n   *\n   * @param {Code} code\n   * @returns {undefined}\n   */\n  function go(code) {\n    consumed = undefined\n    expectedCode = code\n    state = state(code)\n  }\n\n  /** @type {Effects['consume']} */\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++\n      point.column = 1\n      point.offset += code === -3 ? 2 : 1\n      accountForPotentialSkip()\n    } else if (code !== -1) {\n      point.column++\n      point.offset++\n    }\n\n    // Not in a string chunk.\n    if (point._bufferIndex < 0) {\n      point._index++\n    } else {\n      point._bufferIndex++\n\n      // At end of string chunk.\n      // @ts-expect-error Points w/ non-negative `_bufferIndex` reference\n      // strings.\n      if (point._bufferIndex === chunks[point._index].length) {\n        point._bufferIndex = -1\n        point._index++\n      }\n    }\n\n    // Expose the previous character.\n    context.previous = code\n\n    // Mark as consumed.\n    consumed = true\n  }\n\n  /** @type {Effects['enter']} */\n  function enter(type, fields) {\n    /** @type {Token} */\n    // @ts-expect-error Patch instead of assign required fields to help GC.\n    const token = fields || {}\n    token.type = type\n    token.start = now()\n    context.events.push(['enter', token, context])\n    stack.push(token)\n    return token\n  }\n\n  /** @type {Effects['exit']} */\n  function exit(type) {\n    const token = stack.pop()\n    token.end = now()\n    context.events.push(['exit', token, context])\n    return token\n  }\n\n  /**\n   * Use results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from)\n  }\n\n  /**\n   * Discard results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulcheck(_, info) {\n    info.restore()\n  }\n\n  /**\n   * Factory to attempt/check/interrupt.\n   *\n   * @param {ReturnHandle} onreturn\n   * @param {{interrupt?: boolean | undefined} | undefined} [fields]\n   */\n  function constructFactory(onreturn, fields) {\n    return hook\n\n    /**\n     * Handle either an object mapping codes to constructs, a list of\n     * constructs, or a single construct.\n     *\n     * @param {Array<Construct> | Construct | ConstructRecord} constructs\n     * @param {State} returnState\n     * @param {State | undefined} [bogusState]\n     * @returns {State}\n     */\n    function hook(constructs, returnState, bogusState) {\n      /** @type {Array<Construct>} */\n      let listOfConstructs\n      /** @type {number} */\n      let constructIndex\n      /** @type {Construct} */\n      let currentConstruct\n      /** @type {Info} */\n      let info\n      return Array.isArray(constructs) /* c8 ignore next 1 */\n        ? handleListOfConstructs(constructs)\n        : 'tokenize' in constructs\n        ? // @ts-expect-error Looks like a construct.\n          handleListOfConstructs([constructs])\n        : handleMapOfConstructs(constructs)\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       * @returns {State}\n       */\n      function handleMapOfConstructs(map) {\n        return start\n\n        /** @type {State} */\n        function start(code) {\n          const def = code !== null && map[code]\n          const all = code !== null && map.null\n          const list = [\n            // To do: add more extension tests.\n            /* c8 ignore next 2 */\n            ...(Array.isArray(def) ? def : def ? [def] : []),\n            ...(Array.isArray(all) ? all : all ? [all] : [])\n          ]\n          return handleListOfConstructs(list)(code)\n        }\n      }\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {Array<Construct>} list\n       * @returns {State}\n       */\n      function handleListOfConstructs(list) {\n        listOfConstructs = list\n        constructIndex = 0\n        if (list.length === 0) {\n          return bogusState\n        }\n        return handleConstruct(list[constructIndex])\n      }\n\n      /**\n       * Handle a single construct.\n       *\n       * @param {Construct} construct\n       * @returns {State}\n       */\n      function handleConstruct(construct) {\n        return start\n\n        /** @type {State} */\n        function start(code) {\n          // To do: not needed to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store()\n          currentConstruct = construct\n          if (!construct.partial) {\n            context.currentConstruct = construct\n          }\n\n          // Always populated by defaults.\n\n          if (\n            construct.name &&\n            context.parser.constructs.disable.null.includes(construct.name)\n          ) {\n            return nok(code)\n          }\n          return construct.tokenize.call(\n            // If we do have fields, create an object w/ `context` as its\n            // prototype.\n            // This allows a “live binding”, which is needed for `interrupt`.\n            fields ? Object.assign(Object.create(context), fields) : context,\n            effects,\n            ok,\n            nok\n          )(code)\n        }\n      }\n\n      /** @type {State} */\n      function ok(code) {\n        consumed = true\n        onreturn(currentConstruct, info)\n        return returnState\n      }\n\n      /** @type {State} */\n      function nok(code) {\n        consumed = true\n        info.restore()\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex])\n        }\n        return bogusState\n      }\n    }\n  }\n\n  /**\n   * @param {Construct} construct\n   * @param {number} from\n   * @returns {undefined}\n   */\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct)\n    }\n    if (construct.resolve) {\n      splice(\n        context.events,\n        from,\n        context.events.length - from,\n        construct.resolve(context.events.slice(from), context)\n      )\n    }\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context)\n    }\n  }\n\n  /**\n   * Store state.\n   *\n   * @returns {Info}\n   */\n  function store() {\n    const startPoint = now()\n    const startPrevious = context.previous\n    const startCurrentConstruct = context.currentConstruct\n    const startEventsIndex = context.events.length\n    const startStack = Array.from(stack)\n    return {\n      restore,\n      from: startEventsIndex\n    }\n\n    /**\n     * Restore state.\n     *\n     * @returns {undefined}\n     */\n    function restore() {\n      point = startPoint\n      context.previous = startPrevious\n      context.currentConstruct = startCurrentConstruct\n      context.events.length = startEventsIndex\n      stack = startStack\n      accountForPotentialSkip()\n    }\n  }\n\n  /**\n   * Move the current point a bit forward in the line when it’s on a column\n   * skip.\n   *\n   * @returns {undefined}\n   */\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line]\n      point.offset += columnStart[point.line] - 1\n    }\n  }\n}\n\n/**\n * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {Array<Chunk>} chunks\n * @param {Pick<Token, 'end' | 'start'>} token\n * @returns {Array<Chunk>}\n */\nfunction sliceChunks(chunks, token) {\n  const startIndex = token.start._index\n  const startBufferIndex = token.start._bufferIndex\n  const endIndex = token.end._index\n  const endBufferIndex = token.end._bufferIndex\n  /** @type {Array<Chunk>} */\n  let view\n  if (startIndex === endIndex) {\n    // @ts-expect-error `_bufferIndex` is used on string chunks.\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)]\n  } else {\n    view = chunks.slice(startIndex, endIndex)\n    if (startBufferIndex > -1) {\n      const head = view[0]\n      if (typeof head === 'string') {\n        view[0] = head.slice(startBufferIndex)\n      } else {\n        view.shift()\n      }\n    }\n    if (endBufferIndex > 0) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view.push(chunks[endIndex].slice(0, endBufferIndex))\n    }\n  }\n  return view\n}\n\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {Array<Chunk>} chunks\n * @param {boolean | undefined} [expandTabs=false]\n * @returns {string}\n */\nfunction serializeChunks(chunks, expandTabs) {\n  let index = -1\n  /** @type {Array<string>} */\n  const result = []\n  /** @type {boolean | undefined} */\n  let atTab\n  while (++index < chunks.length) {\n    const chunk = chunks[index]\n    /** @type {string} */\n    let value\n    if (typeof chunk === 'string') {\n      value = chunk\n    } else\n      switch (chunk) {\n        case -5: {\n          value = '\\r'\n          break\n        }\n        case -4: {\n          value = '\\n'\n          break\n        }\n        case -3: {\n          value = '\\r' + '\\n'\n          break\n        }\n        case -2: {\n          value = expandTabs ? ' ' : '\\t'\n          break\n        }\n        case -1: {\n          if (!expandTabs && atTab) continue\n          value = ' '\n          break\n        }\n        default: {\n          // Currently only replacement character.\n          value = String.fromCharCode(chunk)\n        }\n      }\n    atTab = chunk === -2\n    result.push(value)\n  }\n  return result.join('')\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  let size = 0;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of thematic break.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"thematicBreak\");\n    // To do: parse indent like `markdown-rs`.\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at marker.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    marker = code;\n    return atBreak(code);\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter(\"thematicBreakSequence\");\n      return sequence(code);\n    }\n    if (size >= 3 && (code === null || markdownLineEnding(code))) {\n      effects.exit(\"thematicBreak\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      size++;\n      return sequence;\n    }\n    effects.exit(\"thematicBreakSequence\");\n    return markdownSpace(code) ? factorySpace(effects, atBreak, \"whitespace\")(code) : atBreak(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').ContainerState} ContainerState\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { asciiDigit, markdownSpace } from 'micromark-util-character';\nimport { blankLine } from './blank-line.js';\nimport { thematicBreak } from './thematic-break.js';\n\n/** @type {Construct} */\nexport const list = {\n  name: 'list',\n  tokenize: tokenizeListStart,\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd\n};\n\n/** @type {Construct} */\nconst listItemPrefixWhitespaceConstruct = {\n  tokenize: tokenizeListItemPrefixWhitespace,\n  partial: true\n};\n\n/** @type {Construct} */\nconst indentConstruct = {\n  tokenize: tokenizeIndent,\n  partial: true\n};\n\n// To do: `markdown-rs` parses list items on their own and later stitches them\n// together.\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeListStart(effects, ok, nok) {\n  const self = this;\n  const tail = self.events[self.events.length - 1];\n  let initialSize = tail && tail[1].type === \"linePrefix\" ? tail[2].sliceSerialize(tail[1], true).length : 0;\n  let size = 0;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    const kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? \"listUnordered\" : \"listOrdered\");\n    if (kind === \"listUnordered\" ? !self.containerState.marker || code === self.containerState.marker : asciiDigit(code)) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind;\n        effects.enter(kind, {\n          _container: true\n        });\n      }\n      if (kind === \"listUnordered\") {\n        effects.enter(\"listItemPrefix\");\n        return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code);\n      }\n      if (!self.interrupt || code === 49) {\n        effects.enter(\"listItemPrefix\");\n        effects.enter(\"listItemValue\");\n        return inside(code);\n      }\n    }\n    return nok(code);\n  }\n\n  /** @type {State} */\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code);\n      return inside;\n    }\n    if ((!self.interrupt || size < 2) && (self.containerState.marker ? code === self.containerState.marker : code === 41 || code === 46)) {\n      effects.exit(\"listItemValue\");\n      return atMarker(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * @type {State}\n   **/\n  function atMarker(code) {\n    effects.enter(\"listItemMarker\");\n    effects.consume(code);\n    effects.exit(\"listItemMarker\");\n    self.containerState.marker = self.containerState.marker || code;\n    return effects.check(blankLine,\n    // Can’t be empty when interrupting.\n    self.interrupt ? nok : onBlank, effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix));\n  }\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true;\n    initialSize++;\n    return endOfPrefix(code);\n  }\n\n  /** @type {State} */\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter(\"listItemPrefixWhitespace\");\n      effects.consume(code);\n      effects.exit(\"listItemPrefixWhitespace\");\n      return endOfPrefix;\n    }\n    return nok(code);\n  }\n\n  /** @type {State} */\n  function endOfPrefix(code) {\n    self.containerState.size = initialSize + self.sliceSerialize(effects.exit(\"listItemPrefix\"), true).length;\n    return ok(code);\n  }\n}\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeListContinuation(effects, ok, nok) {\n  const self = this;\n  self.containerState._closeFlow = undefined;\n  return effects.check(blankLine, onBlank, notBlank);\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.furtherBlankLines = self.containerState.furtherBlankLines || self.containerState.initialBlankLine;\n\n    // We have a blank line.\n    // Still, try to consume at most the items size.\n    return factorySpace(effects, ok, \"listItemIndent\", self.containerState.size + 1)(code);\n  }\n\n  /** @type {State} */\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = undefined;\n      self.containerState.initialBlankLine = undefined;\n      return notInCurrentItem(code);\n    }\n    self.containerState.furtherBlankLines = undefined;\n    self.containerState.initialBlankLine = undefined;\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code);\n  }\n\n  /** @type {State} */\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true;\n    // As we’re closing flow, we’re no longer interrupting.\n    self.interrupt = undefined;\n    // Always populated by defaults.\n\n    return factorySpace(effects, effects.attempt(list, ok, nok), \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n  }\n}\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this;\n  return factorySpace(effects, afterPrefix, \"listItemIndent\", self.containerState.size + 1);\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"listItemIndent\" && tail[2].sliceSerialize(tail[1], true).length === self.containerState.size ? ok(code) : nok(code);\n  }\n}\n\n/**\n * @type {Exiter}\n * @this {TokenizeContext}\n */\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type);\n}\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  const self = this;\n\n  // Always populated by defaults.\n\n  return factorySpace(effects, afterPrefix, \"listItemPrefixWhitespace\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4 + 1);\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return !markdownSpace(code) && tail && tail[1].type === \"listItemPrefixWhitespace\" ? ok(code) : nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of block quote.\n   *\n   * ```markdown\n   * > | > a\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 62) {\n      const state = self.containerState;\n      if (!state.open) {\n        effects.enter(\"blockQuote\", {\n          _container: true\n        });\n        state.open = true;\n      }\n      effects.enter(\"blockQuotePrefix\");\n      effects.enter(\"blockQuoteMarker\");\n      effects.consume(code);\n      effects.exit(\"blockQuoteMarker\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `>`, before optional whitespace.\n   *\n   * ```markdown\n   * > | > a\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter(\"blockQuotePrefixWhitespace\");\n      effects.consume(code);\n      effects.exit(\"blockQuotePrefixWhitespace\");\n      effects.exit(\"blockQuotePrefix\");\n      return ok;\n    }\n    effects.exit(\"blockQuotePrefix\");\n    return ok(code);\n  }\n}\n\n/**\n * Start of block quote continuation.\n *\n * ```markdown\n *   | > a\n * > | > b\n *     ^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  const self = this;\n  return contStart;\n\n  /**\n   * Start of block quote continuation.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contStart(code) {\n    if (markdownSpace(code)) {\n      // Always populated by defaults.\n\n      return factorySpace(effects, contBefore, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n    }\n    return contBefore(code);\n  }\n\n  /**\n   * At `>`, after optional whitespace.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contBefore(code) {\n    return effects.attempt(blockQuote, ok, nok)(code);\n  }\n}\n\n/** @type {Exiter} */\nfunction exit(effects) {\n  effects.exit(\"blockQuote\");\n}","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {\n  asciiControl,\n  markdownLineEndingOrSpace,\n  markdownLineEnding\n} from 'micromark-util-character'\n/**\n * Parse destinations.\n *\n * ###### Examples\n *\n * ```markdown\n * <a>\n * <a\\>b>\n * <a b>\n * <a)>\n * a\n * a\\)b\n * a(b)c\n * a(b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type for whole (`<a>` or `b`).\n * @param {TokenType} literalType\n *   Type when enclosed (`<a>`).\n * @param {TokenType} literalMarkerType\n *   Type for enclosing (`<` and `>`).\n * @param {TokenType} rawType\n *   Type when not enclosed (`b`).\n * @param {TokenType} stringType\n *   Type for the value (`a` or `b`).\n * @param {number | undefined} [max=Infinity]\n *   Depth of nested parens (inclusive).\n * @returns {State}\n *   Start state.\n */ // eslint-disable-next-line max-params\nexport function factoryDestination(\n  effects,\n  ok,\n  nok,\n  type,\n  literalType,\n  literalMarkerType,\n  rawType,\n  stringType,\n  max\n) {\n  const limit = max || Number.POSITIVE_INFINITY\n  let balance = 0\n  return start\n\n  /**\n   * Start of destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *     ^\n   * > | aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type)\n      effects.enter(literalType)\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      return enclosedBefore\n    }\n\n    // ASCII control, space, closing paren.\n    if (code === null || code === 32 || code === 41 || asciiControl(code)) {\n      return nok(code)\n    }\n    effects.enter(type)\n    effects.enter(rawType)\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return raw(code)\n  }\n\n  /**\n   * After `<`, at an enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      effects.exit(literalType)\n      effects.exit(type)\n      return ok\n    }\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return enclosed(code)\n  }\n\n  /**\n   * In enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      return enclosedBefore(code)\n    }\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return code === 92 ? enclosedEscape : enclosed\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | <a\\*a>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code)\n      return enclosed\n    }\n    return enclosed(code)\n  }\n\n  /**\n   * In raw destination.\n   *\n   * ```markdown\n   * > | aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function raw(code) {\n    if (\n      !balance &&\n      (code === null || code === 41 || markdownLineEndingOrSpace(code))\n    ) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      effects.exit(rawType)\n      effects.exit(type)\n      return ok(code)\n    }\n    if (balance < limit && code === 40) {\n      effects.consume(code)\n      balance++\n      return raw\n    }\n    if (code === 41) {\n      effects.consume(code)\n      balance--\n      return raw\n    }\n\n    // ASCII control (but *not* `\\0`) and space and `(`.\n    // Note: in `markdown-rs`, `\\0` exists in codes, in `micromark-js` it\n    // doesn’t.\n    if (code === null || code === 32 || code === 40 || asciiControl(code)) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return code === 92 ? rawEscape : raw\n  }\n\n  /**\n   * After `\\`, at special character.\n   *\n   * ```markdown\n   * > | a\\*a\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function rawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code)\n      return raw\n    }\n    return raw(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/**\n * Parse labels.\n *\n * > 👉 **Note**: labels in markdown are capped at 999 characters in the string.\n *\n * ###### Examples\n *\n * ```markdown\n * [a]\n * [a\n * b]\n * [a\\]b]\n * ```\n *\n * @this {TokenizeContext}\n *   Tokenize context.\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole label (`[a]`).\n * @param {TokenType} markerType\n *   Type for the markers (`[` and `]`).\n * @param {TokenType} stringType\n *   Type for the identifier (`a`).\n * @returns {State}\n *   Start state.\n */ // eslint-disable-next-line max-params\nexport function factoryLabel(effects, ok, nok, type, markerType, stringType) {\n  const self = this\n  let size = 0\n  /** @type {boolean} */\n  let seen\n  return start\n\n  /**\n   * Start of label.\n   *\n   * ```markdown\n   * > | [a]\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(type)\n    effects.enter(markerType)\n    effects.consume(code)\n    effects.exit(markerType)\n    effects.enter(stringType)\n    return atBreak\n  }\n\n  /**\n   * In label, at something, before something else.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (\n      size > 999 ||\n      code === null ||\n      code === 91 ||\n      (code === 93 && !seen) ||\n      // To do: remove in the future once we’ve switched from\n      // `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n      // which doesn’t need this.\n      // Hidden footnotes hook.\n      /* c8 ignore next 3 */\n      (code === 94 &&\n        !size &&\n        '_hiddenFootnoteSupport' in self.parser.constructs)\n    ) {\n      return nok(code)\n    }\n    if (code === 93) {\n      effects.exit(stringType)\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n\n    // To do: indent? Link chunks and EOLs together?\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return atBreak\n    }\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return labelInside(code)\n  }\n\n  /**\n   * In label, in text.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelInside(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      code === 93 ||\n      markdownLineEnding(code) ||\n      size++ > 999\n    ) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n    effects.consume(code)\n    if (!seen) seen = !markdownSpace(code)\n    return code === 92 ? labelEscape : labelInside\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | [a\\*a]\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code)\n      size++\n      return labelInside\n    }\n    return labelInside(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n/**\n * Parse titles.\n *\n * ###### Examples\n *\n * ```markdown\n * \"a\"\n * 'b'\n * (c)\n * \"a\n * b\"\n * 'a\n *     b'\n * (a\\)b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole title (`\"a\"`, `'b'`, `(c)`).\n * @param {TokenType} markerType\n *   Type for the markers (`\"`, `'`, `(`, and `)`).\n * @param {TokenType} stringType\n *   Type for the value (`a`).\n * @returns {State}\n *   Start state.\n */ // eslint-disable-next-line max-params\nexport function factoryTitle(effects, ok, nok, type, markerType, stringType) {\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n\n  /**\n   * Start of title.\n   *\n   * ```markdown\n   * > | \"a\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      effects.enter(type)\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      marker = code === 40 ? 41 : code\n      return begin\n    }\n    return nok(code)\n  }\n\n  /**\n   * After opening marker.\n   *\n   * This is also used at the closing marker.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function begin(code) {\n    if (code === marker) {\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n    effects.enter(stringType)\n    return atBreak(code)\n  }\n\n  /**\n   * At something, before something else.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType)\n      return begin(marker)\n    }\n    if (code === null) {\n      return nok(code)\n    }\n\n    // Note: blank lines can’t exist in content.\n    if (markdownLineEnding(code)) {\n      // To do: use `space_or_tab_eol_with_options`, connect.\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return factorySpace(effects, atBreak, 'linePrefix')\n    }\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return inside(code)\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n    effects.consume(code)\n    return code === 92 ? escape : inside\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | \"a\\*b\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function escape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code)\n      return inside\n    }\n    return inside(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   line endings or spaces in markdown are often optional, in which case this\n *     factory can be used and `ok` will be switched to whether spaces were found\n *     or not\n * *   one line ending or space can be detected with\n *     `markdownLineEndingOrSpace(code)` right before using `factoryWhitespace`\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @returns {State}\n *   Start state.\n */\nexport function factoryWhitespace(effects, ok) {\n  /** @type {boolean} */\n  let seen\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      seen = true\n      return start\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(\n        effects,\n        start,\n        seen ? 'linePrefix' : 'lineSuffix'\n      )(code)\n    }\n    return ok(code)\n  }\n}\n","/**\n * Normalize an identifier (as found in references, definitions).\n *\n * Collapses markdown whitespace, trim, and then lower- and uppercase.\n *\n * Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their\n * lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different\n * uppercase character (U+0398 (`Θ`)).\n * So, to get a canonical form, we perform both lower- and uppercase.\n *\n * Using uppercase last makes sure keys will never interact with default\n * prototypal values (such as `constructor`): nothing in the prototype of\n * `Object` is uppercase.\n *\n * @param {string} value\n *   Identifier to normalize.\n * @returns {string}\n *   Normalized identifier.\n */\nexport function normalizeIdentifier(value) {\n  return (\n    value\n      // Collapse markdown whitespace.\n      .replace(/[\\t\\n\\r ]+/g, ' ')\n      // Trim.\n      .replace(/^ | $/g, '')\n      // Some characters are considered “uppercase”, but if their lowercase\n      // counterpart is uppercased will result in a different uppercase\n      // character.\n      // Hence, to get that form, we perform both lower- and uppercase.\n      // Upper case makes sure keys will not interact with default prototypal\n      // methods: no method is uppercase.\n      .toLowerCase()\n      .toUpperCase()\n  )\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factoryDestination } from 'micromark-factory-destination';\nimport { factoryLabel } from 'micromark-factory-label';\nimport { factorySpace } from 'micromark-factory-space';\nimport { factoryTitle } from 'micromark-factory-title';\nimport { factoryWhitespace } from 'micromark-factory-whitespace';\nimport { markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\n/** @type {Construct} */\nexport const definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n};\n\n/** @type {Construct} */\nconst titleBefore = {\n  tokenize: tokenizeTitleBefore,\n  partial: true\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinition(effects, ok, nok) {\n  const self = this;\n  /** @type {string} */\n  let identifier;\n  return start;\n\n  /**\n   * At start of a definition.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // Do not interrupt paragraphs (but do follow definitions).\n    // To do: do `interrupt` the way `markdown-rs` does.\n    // To do: parse whitespace the way `markdown-rs` does.\n    effects.enter(\"definition\");\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at `[`.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    // To do: parse whitespace the way `markdown-rs` does.\n\n    return factoryLabel.call(self, effects, labelAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionLabel\", \"definitionLabelMarker\", \"definitionLabelString\")(code);\n  }\n\n  /**\n   * After label.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));\n    if (code === 58) {\n      effects.enter(\"definitionMarker\");\n      effects.consume(code);\n      effects.exit(\"definitionMarker\");\n      return markerAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After marker.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function markerAfter(code) {\n    // Note: whitespace is optional.\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, destinationBefore)(code) : destinationBefore(code);\n  }\n\n  /**\n   * Before destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationBefore(code) {\n    return factoryDestination(effects, destinationAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionDestination\", \"definitionDestinationLiteral\", \"definitionDestinationLiteralMarker\", \"definitionDestinationRaw\", \"definitionDestinationString\")(code);\n  }\n\n  /**\n   * After destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationAfter(code) {\n    return effects.attempt(titleBefore, after, after)(code);\n  }\n\n  /**\n   * After definition.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return markdownSpace(code) ? factorySpace(effects, afterWhitespace, \"whitespace\")(code) : afterWhitespace(code);\n  }\n\n  /**\n   * After definition, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterWhitespace(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"definition\");\n\n      // Note: we don’t care about uniqueness.\n      // It’s likely that that doesn’t happen very frequently.\n      // It is more likely that it wastes precious time.\n      self.parser.defined.push(identifier);\n\n      // To do: `markdown-rs` interrupt.\n      // // You’d be interrupting.\n      // tokenizer.interrupt = true\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTitleBefore(effects, ok, nok) {\n  return titleBefore;\n\n  /**\n   * After destination, at whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleBefore(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, beforeMarker)(code) : nok(code);\n  }\n\n  /**\n   * At title.\n   *\n   * ```markdown\n   *   | [a]: b\n   * > | \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeMarker(code) {\n    return factoryTitle(effects, titleAfter, nok, \"definitionTitle\", \"definitionTitleMarker\", \"definitionTitleString\")(code);\n  }\n\n  /**\n   * After title.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfter(code) {\n    return markdownSpace(code) ? factorySpace(effects, titleAfterOptionalWhitespace, \"whitespace\")(code) : titleAfterOptionalWhitespace(code);\n  }\n\n  /**\n   * After title, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfterOptionalWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented\n};\n\n/** @type {Construct} */\nconst furtherStart = {\n  tokenize: tokenizeFurtherStart,\n  partial: true\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of code (indented).\n   *\n   * > **Parsing note**: it is not needed to check if this first line is a\n   * > filled line (that it has a non-whitespace character), because blank lines\n   * > are parsed already, so we never run into that.\n   *\n   * ```markdown\n   * > |     aaa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: manually check if interrupting like `markdown-rs`.\n\n    effects.enter(\"codeIndented\");\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, \"linePrefix\", 4 + 1)(code);\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? atBreak(code) : nok(code);\n  }\n\n  /**\n   * At a break.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === null) {\n      return after(code);\n    }\n    if (markdownLineEnding(code)) {\n      return effects.attempt(furtherStart, atBreak, after)(code);\n    }\n    effects.enter(\"codeFlowValue\");\n    return inside(code);\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFlowValue\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return inside;\n  }\n\n  /** @type {State} */\n  function after(code) {\n    effects.exit(\"codeIndented\");\n    // To do: allow interrupting like `markdown-rs`.\n    // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeFurtherStart(effects, ok, nok) {\n  const self = this;\n  return furtherStart;\n\n  /**\n   * At eol, trying to parse another indent.\n   *\n   * ```markdown\n   * > |     aaa\n   *            ^\n   *   |     bbb\n   * ```\n   *\n   * @type {State}\n   */\n  function furtherStart(code) {\n    // To do: improve `lazy` / `pierce` handling.\n    // If this is a lazy line, it can’t be code.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return furtherStart;\n    }\n\n    // To do: the code here in `micromark-js` is a bit different from\n    // `markdown-rs` because there it can attempt spaces.\n    // We can’t yet.\n    //\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, \"linePrefix\", 4 + 1)(code);\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? ok(code) : markdownLineEnding(code) ? furtherStart(code) : nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\nimport { splice } from 'micromark-util-chunked';\n/** @type {Construct} */\nexport const headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\n};\n\n/** @type {Resolver} */\nfunction resolveHeadingAtx(events, context) {\n  let contentEnd = events.length - 2;\n  let contentStart = 3;\n  /** @type {Token} */\n  let content;\n  /** @type {Token} */\n  let text;\n\n  // Prefix whitespace, part of the opening.\n  if (events[contentStart][1].type === \"whitespace\") {\n    contentStart += 2;\n  }\n\n  // Suffix whitespace, part of the closing.\n  if (contentEnd - 2 > contentStart && events[contentEnd][1].type === \"whitespace\") {\n    contentEnd -= 2;\n  }\n  if (events[contentEnd][1].type === \"atxHeadingSequence\" && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === \"whitespace\")) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;\n  }\n  if (contentEnd > contentStart) {\n    content = {\n      type: \"atxHeadingText\",\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end\n    };\n    text = {\n      type: \"chunkText\",\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end,\n      contentType: \"text\"\n    };\n    splice(events, contentStart, contentEnd - contentStart + 1, [['enter', content, context], ['enter', text, context], ['exit', text, context], ['exit', content, context]]);\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  let size = 0;\n  return start;\n\n  /**\n   * Start of a heading (atx).\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    effects.enter(\"atxHeading\");\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at `#`.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"atxHeadingSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code);\n      return sequenceOpen;\n    }\n\n    // Always at least one `#`.\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"atxHeadingSequence\");\n      return atBreak(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ## aa\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === 35) {\n      effects.enter(\"atxHeadingSequence\");\n      return sequenceFurther(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"atxHeading\");\n      // To do: interrupt like `markdown-rs`.\n      // // Feel free to interrupt.\n      // tokenizer.interrupt = false\n      return ok(code);\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, \"whitespace\")(code);\n    }\n\n    // To do: generate `data` tokens, add the `text` token later.\n    // Needs edit map, see: `markdown.rs`.\n    effects.enter(\"atxHeadingText\");\n    return data(code);\n  }\n\n  /**\n   * In further sequence (after whitespace).\n   *\n   * Could be normal “visible” hashes in the heading or a final sequence.\n   *\n   * ```markdown\n   * > | ## aa ##\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceFurther(code) {\n    if (code === 35) {\n      effects.consume(code);\n      return sequenceFurther;\n    }\n    effects.exit(\"atxHeadingSequence\");\n    return atBreak(code);\n  }\n\n  /**\n   * In text.\n   *\n   * ```markdown\n   * > | ## aa\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"atxHeadingText\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n}","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\n};\n\n/** @type {Resolver} */\nfunction resolveToSetextUnderline(events, context) {\n  // To do: resolve like `markdown-rs`.\n  let index = events.length;\n  /** @type {number | undefined} */\n  let content;\n  /** @type {number | undefined} */\n  let text;\n  /** @type {number | undefined} */\n  let definition;\n\n  // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === \"content\") {\n        content = index;\n        break;\n      }\n      if (events[index][1].type === \"paragraph\") {\n        text = index;\n      }\n    }\n    // Exit\n    else {\n      if (events[index][1].type === \"content\") {\n        // Remove the content end (if needed we’ll add it later)\n        events.splice(index, 1);\n      }\n      if (!definition && events[index][1].type === \"definition\") {\n        definition = index;\n      }\n    }\n  }\n  const heading = {\n    type: \"setextHeading\",\n    start: Object.assign({}, events[text][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  };\n\n  // Change the paragraph to setext heading text.\n  events[text][1].type = \"setextHeadingText\";\n\n  // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context]);\n    events.splice(definition + 1, 0, ['exit', events[content][1], context]);\n    events[content][1].end = Object.assign({}, events[definition][1].end);\n  } else {\n    events[content][1] = heading;\n  }\n\n  // Add the heading exit at the end.\n  events.push(['exit', heading, context]);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  const self = this;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * At start of heading (setext) underline.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    let index = self.events.length;\n    /** @type {boolean | undefined} */\n    let paragraph;\n    // Find an opening.\n    while (index--) {\n      // Skip enter/exit of line ending, line prefix, and content.\n      // We can now either have a definition or a paragraph.\n      if (self.events[index][1].type !== \"lineEnding\" && self.events[index][1].type !== \"linePrefix\" && self.events[index][1].type !== \"content\") {\n        paragraph = self.events[index][1].type === \"paragraph\";\n        break;\n      }\n    }\n\n    // To do: handle lazy/pierce like `markdown-rs`.\n    // To do: parse indent like `markdown-rs`.\n    if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {\n      effects.enter(\"setextHeadingLine\");\n      marker = code;\n      return before(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * After optional whitespace, at `-` or `=`.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"setextHeadingLineSequence\");\n    return inside(code);\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return inside;\n    }\n    effects.exit(\"setextHeadingLineSequence\");\n    return markdownSpace(code) ? factorySpace(effects, after, \"lineSuffix\")(code) : after(code);\n  }\n\n  /**\n   * After sequence, after optional whitespace.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"setextHeadingLine\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n}","/**\n * List of lowercase HTML “block” tag names.\n *\n * The list, when parsing HTML (flow), results in more relaxed rules (condition\n * 6).\n * Because they are known blocks, the HTML-like syntax doesn’t have to be\n * strictly parsed.\n * For tag names not in this list, a more strict algorithm (condition 7) is used\n * to detect whether the HTML-like syntax is seen as HTML (flow) or not.\n *\n * This is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `search` was added in `CommonMark@0.31`.\n */\nexport const htmlBlockNames = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'search',\n  'section',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n]\n\n/**\n * List of lowercase HTML “raw” tag names.\n *\n * The list, when parsing HTML (flow), results in HTML that can include lines\n * without exiting, until a closing tag also in this list is found (condition\n * 1).\n *\n * This module is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `textarea` was added in `CommonMark@0.30`.\n */\nexport const htmlRawNames = ['pre', 'script', 'style', 'textarea']\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { asciiAlpha, asciiAlphanumeric, markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\nimport { htmlBlockNames, htmlRawNames } from 'micromark-util-html-tag-name';\nimport { blankLine } from './blank-line.js';\n\n/** @type {Construct} */\nexport const htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n};\n\n/** @type {Construct} */\nconst blankLineBefore = {\n  tokenize: tokenizeBlankLineBefore,\n  partial: true\n};\nconst nonLazyContinuationStart = {\n  tokenize: tokenizeNonLazyContinuationStart,\n  partial: true\n};\n\n/** @type {Resolver} */\nfunction resolveToHtmlFlow(events) {\n  let index = events.length;\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === \"htmlFlow\") {\n      break;\n    }\n  }\n  if (index > 1 && events[index - 2][1].type === \"linePrefix\") {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start;\n    // Add the prefix start to the HTML line token.\n    events[index + 1][1].start = events[index - 2][1].start;\n    // Remove the line prefix.\n    events.splice(index - 2, 2);\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  const self = this;\n  /** @type {number} */\n  let marker;\n  /** @type {boolean} */\n  let closingTag;\n  /** @type {string} */\n  let buffer;\n  /** @type {number} */\n  let index;\n  /** @type {Code} */\n  let markerB;\n  return start;\n\n  /**\n   * Start of HTML (flow).\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    return before(code);\n  }\n\n  /**\n   * At `<`, after optional whitespace.\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"htmlFlow\");\n    effects.enter(\"htmlFlowData\");\n    effects.consume(code);\n    return open;\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | <x />\n   *      ^\n   * > | <!doctype>\n   *      ^\n   * > | <!--xxx-->\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      closingTag = true;\n      return tagCloseStart;\n    }\n    if (code === 63) {\n      effects.consume(code);\n      marker = 3;\n      // To do:\n      // tokenizer.concrete = true\n      // To do: use `markdown-rs` style interrupt.\n      // While we’re in an instruction instead of a declaration, we’re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      // @ts-expect-error: not null.\n      buffer = String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *       ^\n   * > | <!--xxx-->\n   *       ^\n   * > | <![CDATA[>&<]]>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      marker = 2;\n      return commentOpenInside;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      marker = 5;\n      index = 0;\n      return cdataOpenInside;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      marker = 4;\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!-`, inside a comment, at another `-`.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<![`, inside CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *        ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = \"CDATA[\";\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code);\n      if (index === value.length) {\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok : continuation;\n      }\n      return cdataOpenInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | </x>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      // @ts-expect-error: not null.\n      buffer = String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In tag name.\n   *\n   * ```markdown\n   * > | <ab>\n   *      ^^\n   * > | </ab>\n   *       ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagName(code) {\n    if (code === null || code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      const slash = code === 47;\n      const name = buffer.toLowerCase();\n      if (!slash && !closingTag && htmlRawNames.includes(name)) {\n        marker = 1;\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n      if (htmlBlockNames.includes(buffer.toLowerCase())) {\n        marker = 6;\n        if (slash) {\n          effects.consume(code);\n          return basicSelfClosing;\n        }\n\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n      marker = 7;\n      // Do not support complete HTML when interrupting.\n      return self.interrupt && !self.parser.lazy[self.now().line] ? nok(code) : closingTag ? completeClosingTagAfter(code) : completeAttributeNameBefore(code);\n    }\n\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      buffer += String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After closing slash of a basic tag name.\n   *\n   * ```markdown\n   * > | <div/>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code);\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuation;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After closing slash of a complete tag name.\n   *\n   * ```markdown\n   * > | <x/>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeClosingTagAfter;\n    }\n    return completeEnd(code);\n  }\n\n  /**\n   * At an attribute name.\n   *\n   * At first, this state is used after a complete tag name, after whitespace,\n   * where it expects optional attributes or the end of the tag.\n   * It is also reused after attributes, when expecting more optional\n   * attributes.\n   *\n   * ```markdown\n   * > | <a />\n   *        ^\n   * > | <a :b>\n   *        ^\n   * > | <a _b>\n   *        ^\n   * > | <a b>\n   *        ^\n   * > | <a >\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return completeEnd;\n    }\n\n    // ASCII alphanumerical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameBefore;\n    }\n    return completeEnd(code);\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | <a :b>\n   *         ^\n   * > | <a _b>\n   *         ^\n   * > | <a b>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeName(code) {\n    // ASCII alphanumerical and `-`, `.`, `:`, and `_`.\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n    return completeAttributeNameAfter(code);\n  }\n\n  /**\n   * After attribute name, at an optional initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b>\n   *         ^\n   * > | <a b=c>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameAfter;\n    }\n    return completeAttributeNameBefore(code);\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * > | <a b=\"c\">\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      markerB = code;\n      return completeAttributeValueQuoted;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    return completeAttributeValueUnquoted(code);\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *           ^\n   * > | <a b='c'>\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuoted(code) {\n    if (code === markerB) {\n      effects.consume(code);\n      markerB = null;\n      return completeAttributeValueQuotedAfter;\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return completeAttributeValueQuoted;\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 47 || code === 60 || code === 61 || code === 62 || code === 96 || markdownLineEndingOrSpace(code)) {\n      return completeAttributeNameAfter(code);\n    }\n    effects.consume(code);\n    return completeAttributeValueUnquoted;\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the\n   * end of the tag.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In certain circumstances of a complete tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `>` in a complete tag.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return continuation(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In continuation of any HTML kind.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuation(code) {\n    if (code === 45 && marker === 2) {\n      effects.consume(code);\n      return continuationCommentInside;\n    }\n    if (code === 60 && marker === 1) {\n      effects.consume(code);\n      return continuationRawTagOpen;\n    }\n    if (code === 62 && marker === 4) {\n      effects.consume(code);\n      return continuationClose;\n    }\n    if (code === 63 && marker === 3) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    if (code === 93 && marker === 5) {\n      effects.consume(code);\n      return continuationCdataInside;\n    }\n    if (markdownLineEnding(code) && (marker === 6 || marker === 7)) {\n      effects.exit(\"htmlFlowData\");\n      return effects.check(blankLineBefore, continuationAfter, continuationStart)(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"htmlFlowData\");\n      return continuationStart(code);\n    }\n    effects.consume(code);\n    return continuation;\n  }\n\n  /**\n   * In continuation, at eol.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStart(code) {\n    return effects.check(nonLazyContinuationStart, continuationStartNonLazy, continuationAfter)(code);\n  }\n\n  /**\n   * In continuation, at eol, before non-lazy content.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStartNonLazy(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return continuationBefore;\n  }\n\n  /**\n   * In continuation, before non-lazy content.\n   *\n   * ```markdown\n   *   | <x>\n   * > | asd\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return continuationStart(code);\n    }\n    effects.enter(\"htmlFlowData\");\n    return continuation(code);\n  }\n\n  /**\n   * In comment continuation, after one `-`, expecting another.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In raw continuation, after `<`, at `/`.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code);\n      buffer = '';\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In raw continuation, after `</`, in a raw tag name.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                             ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawEndTag(code) {\n    if (code === 62) {\n      const name = buffer.toLowerCase();\n      if (htmlRawNames.includes(name)) {\n        effects.consume(code);\n        return continuationClose;\n      }\n      return continuation(code);\n    }\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code);\n      // @ts-expect-error: not null.\n      buffer += String.fromCharCode(code);\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In cdata continuation, after `]`, expecting `]>`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *                  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCdataInside(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In declaration or instruction continuation, at `>`.\n   *\n   * ```markdown\n   * > | <!-->\n   *         ^\n   * > | <?>\n   *       ^\n   * > | <!q>\n   *        ^\n   * > | <!--ab-->\n   *             ^\n   * > | <![CDATA[>&<]]>\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    // More dashes.\n    if (code === 45 && marker === 2) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In closed continuation: everything we get until the eol/eof is part of it.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"htmlFlowData\");\n      return continuationAfter(code);\n    }\n    effects.consume(code);\n    return continuationClose;\n  }\n\n  /**\n   * Done.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationAfter(code) {\n    effects.exit(\"htmlFlow\");\n    // // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    // // No longer concrete.\n    // tokenizer.concrete = false\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuationStart(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * At eol, before continuation.\n   *\n   * ```markdown\n   * > | * ```js\n   *            ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * A continuation.\n   *\n   * ```markdown\n   *   | * ```js\n   * > | b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLineBefore(effects, ok, nok) {\n  return start;\n\n  /**\n   * Before eol, expecting blank line.\n   *\n   * ```markdown\n   * > | <div>\n   *          ^\n   *   |\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return effects.attempt(blankLine, ok, nok);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nconst nonLazyContinuation = {\n  tokenize: tokenizeNonLazyContinuation,\n  partial: true\n};\n\n/** @type {Construct} */\nexport const codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  const self = this;\n  /** @type {Construct} */\n  const closeStart = {\n    tokenize: tokenizeCloseStart,\n    partial: true\n  };\n  let initialPrefix = 0;\n  let sizeOpen = 0;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of code.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse whitespace like `markdown-rs`.\n    return beforeSequenceOpen(code);\n  }\n\n  /**\n   * In opening fence, after prefix, at sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeSequenceOpen(code) {\n    const tail = self.events[self.events.length - 1];\n    initialPrefix = tail && tail[1].type === \"linePrefix\" ? tail[2].sliceSerialize(tail[1], true).length : 0;\n    marker = code;\n    effects.enter(\"codeFenced\");\n    effects.enter(\"codeFencedFence\");\n    effects.enter(\"codeFencedFenceSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening fence sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *      ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === marker) {\n      sizeOpen++;\n      effects.consume(code);\n      return sequenceOpen;\n    }\n    if (sizeOpen < 3) {\n      return nok(code);\n    }\n    effects.exit(\"codeFencedFenceSequence\");\n    return markdownSpace(code) ? factorySpace(effects, infoBefore, \"whitespace\")(code) : infoBefore(code);\n  }\n\n  /**\n   * In opening fence, after the sequence (and optional whitespace), before info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function infoBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFencedFence\");\n      return self.interrupt ? ok(code) : effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);\n    }\n    effects.enter(\"codeFencedFenceInfo\");\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return info(code);\n  }\n\n  /**\n   * In info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function info(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceInfo\");\n      return infoBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceInfo\");\n      return factorySpace(effects, metaBefore, \"whitespace\")(code);\n    }\n    if (code === 96 && code === marker) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return info;\n  }\n\n  /**\n   * In opening fence, after info and whitespace, before meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function metaBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return infoBefore(code);\n    }\n    effects.enter(\"codeFencedFenceMeta\");\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return meta(code);\n  }\n\n  /**\n   * In meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceMeta\");\n      return infoBefore(code);\n    }\n    if (code === 96 && code === marker) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return meta;\n  }\n\n  /**\n   * At eol/eof in code, before a non-lazy closing fence or content.\n   *\n   * ```markdown\n   * > | ~~~js\n   *          ^\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function atNonLazyBreak(code) {\n    return effects.attempt(closeStart, after, contentBefore)(code);\n  }\n\n  /**\n   * Before code content, not a closing fence, at eol.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentBefore(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return contentStart;\n  }\n\n  /**\n   * Before code content, not a closing fence.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentStart(code) {\n    return initialPrefix > 0 && markdownSpace(code) ? factorySpace(effects, beforeContentChunk, \"linePrefix\", initialPrefix + 1)(code) : beforeContentChunk(code);\n  }\n\n  /**\n   * Before code content, after optional prefix.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeContentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);\n    }\n    effects.enter(\"codeFlowValue\");\n    return contentChunk(code);\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^^^^^^^^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFlowValue\");\n      return beforeContentChunk(code);\n    }\n    effects.consume(code);\n    return contentChunk;\n  }\n\n  /**\n   * After code.\n   *\n   * ```markdown\n   *   | ~~~js\n   *   | alert(1)\n   * > | ~~~\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    effects.exit(\"codeFenced\");\n    return ok(code);\n  }\n\n  /**\n   * @this {TokenizeContext}\n   * @type {Tokenizer}\n   */\n  function tokenizeCloseStart(effects, ok, nok) {\n    let size = 0;\n    return startBefore;\n\n    /**\n     *\n     *\n     * @type {State}\n     */\n    function startBefore(code) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return start;\n    }\n\n    /**\n     * Before closing fence, at optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function start(code) {\n      // Always populated by defaults.\n\n      // To do: `enter` here or in next state?\n      effects.enter(\"codeFencedFence\");\n      return markdownSpace(code) ? factorySpace(effects, beforeSequenceClose, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : beforeSequenceClose(code);\n    }\n\n    /**\n     * In closing fence, after optional whitespace, at sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function beforeSequenceClose(code) {\n      if (code === marker) {\n        effects.enter(\"codeFencedFenceSequence\");\n        return sequenceClose(code);\n      }\n      return nok(code);\n    }\n\n    /**\n     * In closing fence sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceClose(code) {\n      if (code === marker) {\n        size++;\n        effects.consume(code);\n        return sequenceClose;\n      }\n      if (size >= sizeOpen) {\n        effects.exit(\"codeFencedFenceSequence\");\n        return markdownSpace(code) ? factorySpace(effects, sequenceCloseAfter, \"whitespace\")(code) : sequenceCloseAfter(code);\n      }\n      return nok(code);\n    }\n\n    /**\n     * After closing fence sequence, after optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *        ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceCloseAfter(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit(\"codeFencedFence\");\n        return ok(code);\n      }\n      return nok(code);\n    }\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuation(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return lineStart;\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function lineStart(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);\n  }\n}","/// <reference lib=\"dom\" />\n\n/* eslint-env browser */\n\nconst element = document.createElement('i')\n\n/**\n * @param {string} value\n * @returns {string|false}\n */\nexport function decodeNamedCharacterReference(value) {\n  const characterReference = '&' + value + ';'\n  element.innerHTML = characterReference\n  const char = element.textContent\n\n  // Some named character references do not require the closing semicolon\n  // (`&not`, for instance), which leads to situations where parsing the assumed\n  // named reference of `&notit;` will result in the string `¬it;`.\n  // When we encounter a trailing semicolon after parsing, and the character\n  // reference to decode was not a semicolon (`&semi;`), we can assume that the\n  // matching was not complete.\n  // @ts-expect-error: TypeScript is wrong that `textContent` on elements can\n  // yield `null`.\n  if (char.charCodeAt(char.length - 1) === 59 /* `;` */ && value !== 'semi') {\n    return false\n  }\n\n  // If the decoded string is equal to the input, the character reference was\n  // not valid.\n  // @ts-expect-error: TypeScript is wrong that `textContent` on elements can\n  // yield `null`.\n  return char === characterReference ? false : char\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { asciiAlphanumeric, asciiDigit, asciiHexDigit } from 'micromark-util-character';\n/** @type {Construct} */\nexport const characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  const self = this;\n  let size = 0;\n  /** @type {number} */\n  let max;\n  /** @type {(code: Code) => boolean} */\n  let test;\n  return start;\n\n  /**\n   * Start of character reference.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *      ^\n   * > | a&#123;b\n   *      ^\n   * > | a&#x9;b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"characterReference\");\n    effects.enter(\"characterReferenceMarker\");\n    effects.consume(code);\n    effects.exit(\"characterReferenceMarker\");\n    return open;\n  }\n\n  /**\n   * After `&`, at `#` for numeric references or alphanumeric for named\n   * references.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^\n   * > | a&#123;b\n   *       ^\n   * > | a&#x9;b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 35) {\n      effects.enter(\"characterReferenceMarkerNumeric\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarkerNumeric\");\n      return numeric;\n    }\n    effects.enter(\"characterReferenceValue\");\n    max = 31;\n    test = asciiAlphanumeric;\n    return value(code);\n  }\n\n  /**\n   * After `#`, at `x` for hexadecimals or digit for decimals.\n   *\n   * ```markdown\n   * > | a&#123;b\n   *        ^\n   * > | a&#x9;b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter(\"characterReferenceMarkerHexadecimal\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarkerHexadecimal\");\n      effects.enter(\"characterReferenceValue\");\n      max = 6;\n      test = asciiHexDigit;\n      return value;\n    }\n    effects.enter(\"characterReferenceValue\");\n    max = 7;\n    test = asciiDigit;\n    return value(code);\n  }\n\n  /**\n   * After markers (`&#x`, `&#`, or `&`), in value, before `;`.\n   *\n   * The character reference kind defines what and how many characters are\n   * allowed.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^^^\n   * > | a&#123;b\n   *        ^^^\n   * > | a&#x9;b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function value(code) {\n    if (code === 59 && size) {\n      const token = effects.exit(\"characterReferenceValue\");\n      if (test === asciiAlphanumeric && !decodeNamedCharacterReference(self.sliceSerialize(token))) {\n        return nok(code);\n      }\n\n      // To do: `markdown-rs` uses a different name:\n      // `CharacterReferenceMarkerSemi`.\n      effects.enter(\"characterReferenceMarker\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarker\");\n      effects.exit(\"characterReference\");\n      return ok;\n    }\n    if (test(code) && size++ < max) {\n      effects.consume(code);\n      return value;\n    }\n    return nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { asciiPunctuation } from 'micromark-util-character';\n/** @type {Construct} */\nexport const characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of character escape.\n   *\n   * ```markdown\n   * > | a\\*b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"characterEscape\");\n    effects.enter(\"escapeMarker\");\n    effects.consume(code);\n    effects.exit(\"escapeMarker\");\n    return inside;\n  }\n\n  /**\n   * After `\\`, at punctuation.\n   *\n   * ```markdown\n   * > | a\\*b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    // ASCII punctuation.\n    if (asciiPunctuation(code)) {\n      effects.enter(\"characterEscapeValue\");\n      effects.consume(code);\n      effects.exit(\"characterEscapeValue\");\n      effects.exit(\"characterEscape\");\n      return ok;\n    }\n    return nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLineEnding(effects, ok) {\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, ok, \"linePrefix\");\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factoryDestination } from 'micromark-factory-destination';\nimport { factoryLabel } from 'micromark-factory-label';\nimport { factoryTitle } from 'micromark-factory-title';\nimport { factoryWhitespace } from 'micromark-factory-whitespace';\nimport { markdownLineEndingOrSpace } from 'micromark-util-character';\nimport { push, splice } from 'micromark-util-chunked';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/** @type {Construct} */\nexport const labelEnd = {\n  name: 'labelEnd',\n  tokenize: tokenizeLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  resolveAll: resolveAllLabelEnd\n};\n\n/** @type {Construct} */\nconst resourceConstruct = {\n  tokenize: tokenizeResource\n};\n/** @type {Construct} */\nconst referenceFullConstruct = {\n  tokenize: tokenizeReferenceFull\n};\n/** @type {Construct} */\nconst referenceCollapsedConstruct = {\n  tokenize: tokenizeReferenceCollapsed\n};\n\n/** @type {Resolver} */\nfunction resolveAllLabelEnd(events) {\n  let index = -1;\n  while (++index < events.length) {\n    const token = events[index][1];\n    if (token.type === \"labelImage\" || token.type === \"labelLink\" || token.type === \"labelEnd\") {\n      // Remove the marker.\n      events.splice(index + 1, token.type === \"labelImage\" ? 4 : 2);\n      token.type = \"data\";\n      index++;\n    }\n  }\n  return events;\n}\n\n/** @type {Resolver} */\nfunction resolveToLabelEnd(events, context) {\n  let index = events.length;\n  let offset = 0;\n  /** @type {Token} */\n  let token;\n  /** @type {number | undefined} */\n  let open;\n  /** @type {number | undefined} */\n  let close;\n  /** @type {Array<Event>} */\n  let media;\n\n  // Find an opening.\n  while (index--) {\n    token = events[index][1];\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (token.type === \"link\" || token.type === \"labelLink\" && token._inactive) {\n        break;\n      }\n\n      // Mark other link openings as inactive, as we can’t have links in\n      // links.\n      if (events[index][0] === 'enter' && token.type === \"labelLink\") {\n        token._inactive = true;\n      }\n    } else if (close) {\n      if (events[index][0] === 'enter' && (token.type === \"labelImage\" || token.type === \"labelLink\") && !token._balanced) {\n        open = index;\n        if (token.type !== \"labelLink\") {\n          offset = 2;\n          break;\n        }\n      }\n    } else if (token.type === \"labelEnd\") {\n      close = index;\n    }\n  }\n  const group = {\n    type: events[open][1].type === \"labelLink\" ? \"link\" : \"image\",\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  };\n  const label = {\n    type: \"label\",\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[close][1].end)\n  };\n  const text = {\n    type: \"labelText\",\n    start: Object.assign({}, events[open + offset + 2][1].end),\n    end: Object.assign({}, events[close - 2][1].start)\n  };\n  media = [['enter', group, context], ['enter', label, context]];\n\n  // Opening marker.\n  media = push(media, events.slice(open + 1, open + offset + 3));\n\n  // Text open.\n  media = push(media, [['enter', text, context]]);\n\n  // Always populated by defaults.\n\n  // Between.\n  media = push(media, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + offset + 4, close - 3), context));\n\n  // Text close, marker close, label close.\n  media = push(media, [['exit', text, context], events[close - 2], events[close - 1], ['exit', label, context]]);\n\n  // Reference, resource, or so.\n  media = push(media, events.slice(close + 1));\n\n  // Media close.\n  media = push(media, [['exit', group, context]]);\n  splice(events, open, events.length, media);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  const self = this;\n  let index = self.events.length;\n  /** @type {Token} */\n  let labelStart;\n  /** @type {boolean} */\n  let defined;\n\n  // Find an opening.\n  while (index--) {\n    if ((self.events[index][1].type === \"labelImage\" || self.events[index][1].type === \"labelLink\") && !self.events[index][1]._balanced) {\n      labelStart = self.events[index][1];\n      break;\n    }\n  }\n  return start;\n\n  /**\n   * Start of label end.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // If there is not an okay opening.\n    if (!labelStart) {\n      return nok(code);\n    }\n\n    // If the corresponding label (link) start is marked as inactive,\n    // it means we’d be wrapping a link, like this:\n    //\n    // ```markdown\n    // > | a [b [c](d) e](f) g.\n    //                  ^\n    // ```\n    //\n    // We can’t have that, so it’s just balanced brackets.\n    if (labelStart._inactive) {\n      return labelEndNok(code);\n    }\n    defined = self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize({\n      start: labelStart.end,\n      end: self.now()\n    })));\n    effects.enter(\"labelEnd\");\n    effects.enter(\"labelMarker\");\n    effects.consume(code);\n    effects.exit(\"labelMarker\");\n    effects.exit(\"labelEnd\");\n    return after;\n  }\n\n  /**\n   * After `]`.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // Note: `markdown-rs` also parses GFM footnotes here, which for us is in\n    // an extension.\n\n    // Resource (`[asd](fgh)`)?\n    if (code === 40) {\n      return effects.attempt(resourceConstruct, labelEndOk, defined ? labelEndOk : labelEndNok)(code);\n    }\n\n    // Full (`[asd][fgh]`) or collapsed (`[asd][]`) reference?\n    if (code === 91) {\n      return effects.attempt(referenceFullConstruct, labelEndOk, defined ? referenceNotFull : labelEndNok)(code);\n    }\n\n    // Shortcut (`[asd]`) reference?\n    return defined ? labelEndOk(code) : labelEndNok(code);\n  }\n\n  /**\n   * After `]`, at `[`, but not at a full reference.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] b\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceNotFull(code) {\n    return effects.attempt(referenceCollapsedConstruct, labelEndOk, labelEndNok)(code);\n  }\n\n  /**\n   * Done, we found something.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *           ^\n   * > | [a][b] c\n   *           ^\n   * > | [a][] b\n   *          ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndOk(code) {\n    // Note: `markdown-rs` does a bunch of stuff here.\n    return ok(code);\n  }\n\n  /**\n   * Done, it’s nothing.\n   *\n   * There was an okay opening, but we didn’t match anything.\n   *\n   * ```markdown\n   * > | [a](b c\n   *        ^\n   * > | [a][b c\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndNok(code) {\n    labelStart._balanced = true;\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeResource(effects, ok, nok) {\n  return resourceStart;\n\n  /**\n   * At a resource.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceStart(code) {\n    effects.enter(\"resource\");\n    effects.enter(\"resourceMarker\");\n    effects.consume(code);\n    effects.exit(\"resourceMarker\");\n    return resourceBefore;\n  }\n\n  /**\n   * In resource, after `(`, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBefore(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceOpen)(code) : resourceOpen(code);\n  }\n\n  /**\n   * In resource, after optional whitespace, at `)` or a destination.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceOpen(code) {\n    if (code === 41) {\n      return resourceEnd(code);\n    }\n    return factoryDestination(effects, resourceDestinationAfter, resourceDestinationMissing, \"resourceDestination\", \"resourceDestinationLiteral\", \"resourceDestinationLiteralMarker\", \"resourceDestinationRaw\", \"resourceDestinationString\", 32)(code);\n  }\n\n  /**\n   * In resource, after destination, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceBetween)(code) : resourceEnd(code);\n  }\n\n  /**\n   * At invalid destination.\n   *\n   * ```markdown\n   * > | [a](<<) b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationMissing(code) {\n    return nok(code);\n  }\n\n  /**\n   * In resource, after destination and whitespace, at `(` or title.\n   *\n   * ```markdown\n   * > | [a](b ) c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBetween(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(effects, resourceTitleAfter, nok, \"resourceTitle\", \"resourceTitleMarker\", \"resourceTitleString\")(code);\n    }\n    return resourceEnd(code);\n  }\n\n  /**\n   * In resource, after title, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b \"c\") d\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceTitleAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceEnd)(code) : resourceEnd(code);\n  }\n\n  /**\n   * In resource, at `)`.\n   *\n   * ```markdown\n   * > | [a](b) d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceEnd(code) {\n    if (code === 41) {\n      effects.enter(\"resourceMarker\");\n      effects.consume(code);\n      effects.exit(\"resourceMarker\");\n      effects.exit(\"resource\");\n      return ok;\n    }\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceFull(effects, ok, nok) {\n  const self = this;\n  return referenceFull;\n\n  /**\n   * In a reference (full), at the `[`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFull(code) {\n    return factoryLabel.call(self, effects, referenceFullAfter, referenceFullMissing, \"reference\", \"referenceMarker\", \"referenceString\")(code);\n  }\n\n  /**\n   * In a reference (full), after `]`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullAfter(code) {\n    return self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1))) ? ok(code) : nok(code);\n  }\n\n  /**\n   * In reference (full) that was missing.\n   *\n   * ```markdown\n   * > | [a][b d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullMissing(code) {\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceCollapsed(effects, ok, nok) {\n  return referenceCollapsedStart;\n\n  /**\n   * In reference (collapsed), at `[`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceCollapsedStart(code) {\n    // We only attempt a collapsed label if there’s a `[`.\n\n    effects.enter(\"reference\");\n    effects.enter(\"referenceMarker\");\n    effects.consume(code);\n    effects.exit(\"referenceMarker\");\n    return referenceCollapsedOpen;\n  }\n\n  /**\n   * In reference (collapsed), at `]`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *         ^\n   * ```\n   *\n   *  @type {State}\n   */\n  function referenceCollapsedOpen(code) {\n    if (code === 93) {\n      effects.enter(\"referenceMarker\");\n      effects.consume(code);\n      effects.exit(\"referenceMarker\");\n      effects.exit(\"reference\");\n      return ok;\n    }\n    return nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { labelEnd } from './label-end.js';\n\n/** @type {Construct} */\nexport const labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of label (image) start.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"labelImage\");\n    effects.enter(\"labelImageMarker\");\n    effects.consume(code);\n    effects.exit(\"labelImageMarker\");\n    return open;\n  }\n\n  /**\n   * After `!`, at `[`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 91) {\n      effects.enter(\"labelMarker\");\n      effects.consume(code);\n      effects.exit(\"labelMarker\");\n      effects.exit(\"labelImage\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `![`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *         ^\n   * ```\n   *\n   * This is needed in because, when GFM footnotes are enabled, images never\n   * form when started with a `^`.\n   * Instead, links form:\n   *\n   * ```markdown\n   * ![^a](b)\n   *\n   * ![^a][b]\n   *\n   * [b]: c\n   * ```\n   *\n   * ```html\n   * <p>!<a href=\\\"b\\\">^a</a></p>\n   * <p>!<a href=\\\"c\\\">^a</a></p>\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // To do: use a new field to do this, this is still needed for\n    // `micromark-extension-gfm-footnote`, but the `label-start-link`\n    // behavior isn’t.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\n\nimport {\n  markdownLineEndingOrSpace,\n  unicodePunctuation,\n  unicodeWhitespace\n} from 'micromark-util-character'\n/**\n * Classify whether a code represents whitespace, punctuation, or something\n * else.\n *\n * Used for attention (emphasis, strong), whose sequences can open or close\n * based on the class of surrounding characters.\n *\n * > 👉 **Note**: eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n *   Code.\n * @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined}\n *   Group.\n */\nexport function classifyCharacter(code) {\n  if (\n    code === null ||\n    markdownLineEndingOrSpace(code) ||\n    unicodeWhitespace(code)\n  ) {\n    return 1\n  }\n  if (unicodePunctuation(code)) {\n    return 2\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { push, splice } from 'micromark-util-chunked';\nimport { classifyCharacter } from 'micromark-util-classify-character';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/** @type {Construct} */\nexport const attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\n};\n\n/**\n * Take all events and resolve attention to emphasis or strong.\n *\n * @type {Resolver}\n */\n// eslint-disable-next-line complexity\nfunction resolveAllAttention(events, context) {\n  let index = -1;\n  /** @type {number} */\n  let open;\n  /** @type {Token} */\n  let group;\n  /** @type {Token} */\n  let text;\n  /** @type {Token} */\n  let openingSequence;\n  /** @type {Token} */\n  let closingSequence;\n  /** @type {number} */\n  let use;\n  /** @type {Array<Event>} */\n  let nextEvents;\n  /** @type {number} */\n  let offset;\n\n  // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it’s\n  // a bottleneck for malicious stuff.\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (events[index][0] === 'enter' && events[index][1].type === 'attentionSequence' && events[index][1]._close) {\n      open = index;\n\n      // Now walk back to find an opener.\n      while (open--) {\n        // Find a token that can open the closer.\n        if (events[open][0] === 'exit' && events[open][1].type === 'attentionSequence' && events[open][1]._open &&\n        // If the markers are the same:\n        context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {\n          // If the opening can close or the closing can open,\n          // and the close size *is not* a multiple of three,\n          // but the sum of the opening and closing size *is* multiple of three,\n          // then don’t match.\n          if ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) {\n            continue;\n          }\n\n          // Number of markers to use from the sequence.\n          use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1;\n          const start = Object.assign({}, events[open][1].end);\n          const end = Object.assign({}, events[index][1].start);\n          movePoint(start, -use);\n          movePoint(end, use);\n          openingSequence = {\n            type: use > 1 ? \"strongSequence\" : \"emphasisSequence\",\n            start,\n            end: Object.assign({}, events[open][1].end)\n          };\n          closingSequence = {\n            type: use > 1 ? \"strongSequence\" : \"emphasisSequence\",\n            start: Object.assign({}, events[index][1].start),\n            end\n          };\n          text = {\n            type: use > 1 ? \"strongText\" : \"emphasisText\",\n            start: Object.assign({}, events[open][1].end),\n            end: Object.assign({}, events[index][1].start)\n          };\n          group = {\n            type: use > 1 ? \"strong\" : \"emphasis\",\n            start: Object.assign({}, openingSequence.start),\n            end: Object.assign({}, closingSequence.end)\n          };\n          events[open][1].end = Object.assign({}, openingSequence.start);\n          events[index][1].start = Object.assign({}, closingSequence.end);\n          nextEvents = [];\n\n          // If there are more markers in the opening, add them before.\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = push(nextEvents, [['enter', events[open][1], context], ['exit', events[open][1], context]]);\n          }\n\n          // Opening.\n          nextEvents = push(nextEvents, [['enter', group, context], ['enter', openingSequence, context], ['exit', openingSequence, context], ['enter', text, context]]);\n\n          // Always populated by defaults.\n\n          // Between.\n          nextEvents = push(nextEvents, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context));\n\n          // Closing.\n          nextEvents = push(nextEvents, [['exit', text, context], ['enter', closingSequence, context], ['exit', closingSequence, context], ['exit', group, context]]);\n\n          // If there are more markers in the closing, add them after.\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2;\n            nextEvents = push(nextEvents, [['enter', events[index][1], context], ['exit', events[index][1], context]]);\n          } else {\n            offset = 0;\n          }\n          splice(events, open - 1, index - open + 3, nextEvents);\n          index = open + nextEvents.length - offset - 2;\n          break;\n        }\n      }\n    }\n  }\n\n  // Remove remaining sequences.\n  index = -1;\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data';\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeAttention(effects, ok) {\n  const attentionMarkers = this.parser.constructs.attentionMarkers.null;\n  const previous = this.previous;\n  const before = classifyCharacter(previous);\n\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Before a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    marker = code;\n    effects.enter('attentionSequence');\n    return inside(code);\n  }\n\n  /**\n   * In a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return inside;\n    }\n    const token = effects.exit('attentionSequence');\n\n    // To do: next major: move this to resolver, just like `markdown-rs`.\n    const after = classifyCharacter(code);\n\n    // Always populated by defaults.\n\n    const open = !after || after === 2 && before || attentionMarkers.includes(code);\n    const close = !before || before === 2 && after || attentionMarkers.includes(previous);\n    token._open = Boolean(marker === 42 ? open : open && (before || !close));\n    token._close = Boolean(marker === 42 ? close : close && (after || !open));\n    return ok(code);\n  }\n}\n\n/**\n * Move a point a bit.\n *\n * Note: `move` only works inside lines! It’s not possible to move past other\n * chunks (replacement characters, tabs, or line endings).\n *\n * @param {Point} point\n * @param {number} offset\n * @returns {undefined}\n */\nfunction movePoint(point, offset) {\n  point.column += offset;\n  point.offset += offset;\n  point._bufferIndex += offset;\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { asciiAlpha, asciiAlphanumeric, asciiAtext, asciiControl } from 'micromark-util-character';\n/** @type {Construct} */\nexport const autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeAutolink(effects, ok, nok) {\n  let size = 0;\n  return start;\n\n  /**\n   * Start of an autolink.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *      ^\n   * > | a<user@example.com>b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"autolink\");\n    effects.enter(\"autolinkMarker\");\n    effects.consume(code);\n    effects.exit(\"autolinkMarker\");\n    effects.enter(\"autolinkProtocol\");\n    return open;\n  }\n\n  /**\n   * After `<`, at protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *       ^\n   * > | a<user@example.com>b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return schemeOrEmailAtext;\n    }\n    if (code === 64) {\n      return nok(code);\n    }\n    return emailAtext(code);\n  }\n\n  /**\n   * At second byte of protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeOrEmailAtext(code) {\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) {\n      // Count the previous alphabetical from `open` too.\n      size = 1;\n      return schemeInsideOrEmailAtext(code);\n    }\n    return emailAtext(code);\n  }\n\n  /**\n   * In ambiguous protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code);\n      size = 0;\n      return urlInside;\n    }\n\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) {\n      effects.consume(code);\n      return schemeInsideOrEmailAtext;\n    }\n    size = 0;\n    return emailAtext(code);\n  }\n\n  /**\n   * After protocol, in URL.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit(\"autolinkProtocol\");\n      effects.enter(\"autolinkMarker\");\n      effects.consume(code);\n      effects.exit(\"autolinkMarker\");\n      effects.exit(\"autolink\");\n      return ok;\n    }\n\n    // ASCII control, space, or `<`.\n    if (code === null || code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return urlInside;\n  }\n\n  /**\n   * In email atext.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code);\n      return emailAtSignOrDot;\n    }\n    if (asciiAtext(code)) {\n      effects.consume(code);\n      return emailAtext;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In label, after at-sign or dot.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                 ^       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code);\n  }\n\n  /**\n   * In label, where `.` and `>` are allowed.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n    if (code === 62) {\n      // Exit, then change the token type.\n      effects.exit(\"autolinkProtocol\").type = \"autolinkEmail\";\n      effects.enter(\"autolinkMarker\");\n      effects.consume(code);\n      effects.exit(\"autolinkMarker\");\n      effects.exit(\"autolink\");\n      return ok;\n    }\n    return emailValue(code);\n  }\n\n  /**\n   * In label, where `.` and `>` are *not* allowed.\n   *\n   * Though, this is also used in `emailLabel` to parse other values.\n   *\n   * ```markdown\n   * > | a<user.name@ex-ample.com>b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailValue(code) {\n    // ASCII alphanumeric or `-`.\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      const next = code === 45 ? emailValue : emailLabel;\n      effects.consume(code);\n      return next;\n    }\n    return nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { asciiAlpha, asciiAlphanumeric, markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlText(effects, ok, nok) {\n  const self = this;\n  /** @type {NonNullable<Code> | undefined} */\n  let marker;\n  /** @type {number} */\n  let index;\n  /** @type {State} */\n  let returnState;\n  return start;\n\n  /**\n   * Start of HTML (text).\n   *\n   * ```markdown\n   * > | a <b> c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"htmlText\");\n    effects.enter(\"htmlTextData\");\n    effects.consume(code);\n    return open;\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | a <b> c\n   *        ^\n   * > | a <!doctype> c\n   *        ^\n   * > | a <!--b--> c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instruction;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | a <!doctype> c\n   *         ^\n   * > | a <!--b--> c\n   *         ^\n   * > | a <![CDATA[>&<]]> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentOpenInside;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      index = 0;\n      return cdataOpenInside;\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return declaration;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In a comment, after `<!-`, at another `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentEnd;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In comment.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function comment(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 45) {\n      effects.consume(code);\n      return commentClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = comment;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return comment;\n  }\n\n  /**\n   * In comment, after `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentEnd;\n    }\n    return comment(code);\n  }\n\n  /**\n   * In comment, after `--`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentEnd(code) {\n    return code === 62 ? end(code) : code === 45 ? commentClose(code) : comment(code);\n  }\n\n  /**\n   * After `<![`, in CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *          ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = \"CDATA[\";\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === value.length ? cdata : cdataOpenInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In CDATA.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdata(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = cdata;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return cdata;\n  }\n\n  /**\n   * In CDATA, after `]`, at another `]`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n\n  /**\n   * In CDATA, after `]]`, at `>`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n\n  /**\n   * In declaration.\n   *\n   * ```markdown\n   * > | a <!b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = declaration;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return declaration;\n  }\n\n  /**\n   * In instruction.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instruction(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instructionClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = instruction;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return instruction;\n  }\n\n  /**\n   * In instruction, after `?`, at `>`.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code);\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `</x`, in a tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagClose(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return tagCloseBetween(code);\n  }\n\n  /**\n   * In closing tag, after tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagCloseBetween;\n    }\n    return end(code);\n  }\n\n  /**\n   * After `<x`, in opening tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpen(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In opening tag, after tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return end;\n    }\n\n    // ASCII alphabetical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenBetween;\n    }\n    return end(code);\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeName(code) {\n    // ASCII alphabetical and `-`, `.`, `:`, and `_`.\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n    return tagOpenAttributeNameAfter(code);\n  }\n\n  /**\n   * After attribute name, before initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeNameAfter;\n    }\n    return tagOpenBetween(code);\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return tagOpenAttributeValueQuoted;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      marker = undefined;\n      return tagOpenAttributeValueQuotedAfter;\n    }\n    if (code === null) {\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueQuoted;\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 96) {\n      return nok(code);\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the end\n   * of the tag.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In certain circumstances of a tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function end(code) {\n    if (code === 62) {\n      effects.consume(code);\n      effects.exit(\"htmlTextData\");\n      effects.exit(\"htmlText\");\n      return ok;\n    }\n    return nok(code);\n  }\n\n  /**\n   * At eol.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   * > | a <!--a\n   *            ^\n   *   | b-->\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingBefore(code) {\n    effects.exit(\"htmlTextData\");\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return lineEndingAfter;\n  }\n\n  /**\n   * After eol, at optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfter(code) {\n    // Always populated by defaults.\n\n    return markdownSpace(code) ? factorySpace(effects, lineEndingAfterPrefix, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : lineEndingAfterPrefix(code);\n  }\n\n  /**\n   * After eol, after optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfterPrefix(code) {\n    effects.enter(\"htmlTextData\");\n    return returnState(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { labelEnd } from './label-end.js';\n\n/** @type {Construct} */\nexport const labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of label (link) start.\n   *\n   * ```markdown\n   * > | a [b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"labelLink\");\n    effects.enter(\"labelMarker\");\n    effects.consume(code);\n    effects.exit(\"labelMarker\");\n    effects.exit(\"labelLink\");\n    return after;\n  }\n\n  /** @type {State} */\n  function after(code) {\n    // To do: this isn’t needed in `micromark-extension-gfm-footnote`,\n    // remove.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n};\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of a hard break (escape).\n   *\n   * ```markdown\n   * > | a\\\n   *      ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"hardBreakEscape\");\n    effects.consume(code);\n    return after;\n  }\n\n  /**\n   * After `\\`, at eol.\n   *\n   * ```markdown\n   * > | a\\\n   *       ^\n   *   | b\n   * ```\n   *\n   *  @type {State}\n   */\n  function after(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit(\"hardBreakEscape\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Previous} Previous\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous\n};\n\n// To do: next major: don’t resolve, like `markdown-rs`.\n/** @type {Resolver} */\nfunction resolveCodeText(events) {\n  let tailExitIndex = events.length - 4;\n  let headEnterIndex = 3;\n  /** @type {number} */\n  let index;\n  /** @type {number | undefined} */\n  let enter;\n\n  // If we start and end with an EOL or a space.\n  if ((events[headEnterIndex][1].type === \"lineEnding\" || events[headEnterIndex][1].type === 'space') && (events[tailExitIndex][1].type === \"lineEnding\" || events[tailExitIndex][1].type === 'space')) {\n    index = headEnterIndex;\n\n    // And we have data.\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === \"codeTextData\") {\n        // Then we have padding.\n        events[headEnterIndex][1].type = \"codeTextPadding\";\n        events[tailExitIndex][1].type = \"codeTextPadding\";\n        headEnterIndex += 2;\n        tailExitIndex -= 2;\n        break;\n      }\n    }\n  }\n\n  // Merge adjacent spaces and data.\n  index = headEnterIndex - 1;\n  tailExitIndex++;\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== \"lineEnding\") {\n        enter = index;\n      }\n    } else if (index === tailExitIndex || events[index][1].type === \"lineEnding\") {\n      events[enter][1].type = \"codeTextData\";\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end;\n        events.splice(enter + 2, index - enter - 2);\n        tailExitIndex -= index - enter - 2;\n        index = enter + 2;\n      }\n      enter = undefined;\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Previous}\n */\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return code !== 96 || this.events[this.events.length - 1][1].type === \"characterEscape\";\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCodeText(effects, ok, nok) {\n  const self = this;\n  let sizeOpen = 0;\n  /** @type {number} */\n  let size;\n  /** @type {Token} */\n  let token;\n  return start;\n\n  /**\n   * Start of code (text).\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * > | \\`a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"codeText\");\n    effects.enter(\"codeTextSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 96) {\n      effects.consume(code);\n      sizeOpen++;\n      return sequenceOpen;\n    }\n    effects.exit(\"codeTextSequence\");\n    return between(code);\n  }\n\n  /**\n   * Between something and something else.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function between(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code);\n    }\n\n    // To do: next major: don’t do spaces in resolve, but when compiling,\n    // like `markdown-rs`.\n    // Tabs don’t work, and virtual spaces don’t make sense.\n    if (code === 32) {\n      effects.enter('space');\n      effects.consume(code);\n      effects.exit('space');\n      return between;\n    }\n\n    // Closing fence? Could also be data.\n    if (code === 96) {\n      token = effects.enter(\"codeTextSequence\");\n      size = 0;\n      return sequenceClose(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return between;\n    }\n\n    // Data.\n    effects.enter(\"codeTextData\");\n    return data(code);\n  }\n\n  /**\n   * In data.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {\n      effects.exit(\"codeTextData\");\n      return between(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n\n  /**\n   * In closing sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceClose(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code);\n      size++;\n      return sequenceClose;\n    }\n\n    // Done!\n    if (size === sizeOpen) {\n      effects.exit(\"codeTextSequence\");\n      effects.exit(\"codeText\");\n      return ok(code);\n    }\n\n    // More or less accents: mark as data.\n    token.type = \"codeTextData\";\n    return data(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n */\n\nimport {\n  attention,\n  autolink,\n  blockQuote,\n  characterEscape,\n  characterReference,\n  codeFenced,\n  codeIndented,\n  codeText,\n  definition,\n  hardBreakEscape,\n  headingAtx,\n  htmlFlow,\n  htmlText,\n  labelEnd,\n  labelStartImage,\n  labelStartLink,\n  lineEnding,\n  list,\n  setextUnderline,\n  thematicBreak\n} from 'micromark-core-commonmark'\nimport {resolver as resolveText} from './initialize/text.js'\n\n/** @satisfies {Extension['document']} */\nexport const document = {\n  [42]: list,\n  [43]: list,\n  [45]: list,\n  [48]: list,\n  [49]: list,\n  [50]: list,\n  [51]: list,\n  [52]: list,\n  [53]: list,\n  [54]: list,\n  [55]: list,\n  [56]: list,\n  [57]: list,\n  [62]: blockQuote\n}\n\n/** @satisfies {Extension['contentInitial']} */\nexport const contentInitial = {\n  [91]: definition\n}\n\n/** @satisfies {Extension['flowInitial']} */\nexport const flowInitial = {\n  [-2]: codeIndented,\n  [-1]: codeIndented,\n  [32]: codeIndented\n}\n\n/** @satisfies {Extension['flow']} */\nexport const flow = {\n  [35]: headingAtx,\n  [42]: thematicBreak,\n  [45]: [setextUnderline, thematicBreak],\n  [60]: htmlFlow,\n  [61]: setextUnderline,\n  [95]: thematicBreak,\n  [96]: codeFenced,\n  [126]: codeFenced\n}\n\n/** @satisfies {Extension['string']} */\nexport const string = {\n  [38]: characterReference,\n  [92]: characterEscape\n}\n\n/** @satisfies {Extension['text']} */\nexport const text = {\n  [-5]: lineEnding,\n  [-4]: lineEnding,\n  [-3]: lineEnding,\n  [33]: labelStartImage,\n  [38]: characterReference,\n  [42]: attention,\n  [60]: [autolink, htmlText],\n  [91]: labelStartLink,\n  [92]: [hardBreakEscape, characterEscape],\n  [93]: labelEnd,\n  [95]: attention,\n  [96]: codeText\n}\n\n/** @satisfies {Extension['insideSpan']} */\nexport const insideSpan = {\n  null: [attention, resolveText]\n}\n\n/** @satisfies {Extension['attentionMarkers']} */\nexport const attentionMarkers = {\n  null: [42, 95]\n}\n\n/** @satisfies {Extension['disable']} */\nexport const disable = {\n  null: []\n}\n","/**\n * @typedef {import('micromark-util-types').Create} Create\n * @typedef {import('micromark-util-types').FullNormalizedExtension} FullNormalizedExtension\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n */\n\nimport {combineExtensions} from 'micromark-util-combine-extensions'\nimport {content} from './initialize/content.js'\nimport {document} from './initialize/document.js'\nimport {flow} from './initialize/flow.js'\nimport {string, text} from './initialize/text.js'\nimport {createTokenizer} from './create-tokenizer.js'\nimport * as defaultConstructs from './constructs.js'\n\n/**\n * @param {ParseOptions | null | undefined} [options]\n * @returns {ParseContext}\n */\nexport function parse(options) {\n  const settings = options || {}\n  const constructs =\n    /** @type {FullNormalizedExtension} */\n    combineExtensions([defaultConstructs, ...(settings.extensions || [])])\n\n  /** @type {ParseContext} */\n  const parser = {\n    defined: [],\n    lazy: {},\n    constructs,\n    content: create(content),\n    document: create(document),\n    flow: create(flow),\n    string: create(string),\n    text: create(text)\n  }\n  return parser\n\n  /**\n   * @param {InitialConstruct} initial\n   */\n  function create(initial) {\n    return creator\n    /** @type {Create} */\n    function creator(from) {\n      return createTokenizer(parser, initial, from)\n    }\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Value} Value\n */\n\n/**\n * @callback Preprocessor\n * @param {Value} value\n * @param {Encoding | null | undefined} [encoding]\n * @param {boolean | null | undefined} [end=false]\n * @returns {Array<Chunk>}\n */\n\nconst search = /[\\0\\t\\n\\r]/g\n\n/**\n * @returns {Preprocessor}\n */\nexport function preprocess() {\n  let column = 1\n  let buffer = ''\n  /** @type {boolean | undefined} */\n  let start = true\n  /** @type {boolean | undefined} */\n  let atCarriageReturn\n  return preprocessor\n\n  /** @type {Preprocessor} */\n  // eslint-disable-next-line complexity\n  function preprocessor(value, encoding, end) {\n    /** @type {Array<Chunk>} */\n    const chunks = []\n    /** @type {RegExpMatchArray | null} */\n    let match\n    /** @type {number} */\n    let next\n    /** @type {number} */\n    let startPosition\n    /** @type {number} */\n    let endPosition\n    /** @type {Code} */\n    let code\n    value =\n      buffer +\n      (typeof value === 'string'\n        ? value.toString()\n        : new TextDecoder(encoding || undefined).decode(value))\n    startPosition = 0\n    buffer = ''\n    if (start) {\n      // To do: `markdown-rs` actually parses BOMs (byte order mark).\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++\n      }\n      start = undefined\n    }\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition\n      match = search.exec(value)\n      endPosition =\n        match && match.index !== undefined ? match.index : value.length\n      code = value.charCodeAt(endPosition)\n      if (!match) {\n        buffer = value.slice(startPosition)\n        break\n      }\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3)\n        atCarriageReturn = undefined\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5)\n          atCarriageReturn = undefined\n        }\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition))\n          column += endPosition - startPosition\n        }\n        switch (code) {\n          case 0: {\n            chunks.push(65533)\n            column++\n            break\n          }\n          case 9: {\n            next = Math.ceil(column / 4) * 4\n            chunks.push(-2)\n            while (column++ < next) chunks.push(-1)\n            break\n          }\n          case 10: {\n            chunks.push(-4)\n            column = 1\n            break\n          }\n          default: {\n            atCarriageReturn = true\n            column = 1\n          }\n        }\n      }\n      startPosition = endPosition + 1\n    }\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5)\n      if (buffer) chunks.push(buffer)\n      chunks.push(null)\n    }\n    return chunks\n  }\n}\n","/**\n * Turn the number (in string form as either hexa- or plain decimal) coming from\n * a numeric character reference into a character.\n *\n * Sort of like `String.fromCodePoint(Number.parseInt(value, base))`, but makes\n * non-characters and control characters safe.\n *\n * @param {string} value\n *   Value to decode.\n * @param {number} base\n *   Numeric base.\n * @returns {string}\n *   Character.\n */\nexport function decodeNumericCharacterReference(value, base) {\n  const code = Number.parseInt(value, base);\n  if (\n  // C0 except for HT, LF, FF, CR, space.\n  code < 9 || code === 11 || code > 13 && code < 32 ||\n  // Control character (DEL) of C0, and C1 controls.\n  code > 126 && code < 160 ||\n  // Lone high surrogates and low surrogates.\n  code > 55_295 && code < 57_344 ||\n  // Noncharacters.\n  code > 64_975 && code < 65_008 || /* eslint-disable no-bitwise */\n  (code & 65_535) === 65_535 || (code & 65_535) === 65_534 || /* eslint-enable no-bitwise */\n  // Out of range\n  code > 1_114_111) {\n    return \"\\uFFFD\";\n  }\n  return String.fromCodePoint(code);\n}","import {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {decodeNumericCharacterReference} from 'micromark-util-decode-numeric-character-reference'\nconst characterEscapeOrReference =\n  /\\\\([!-/:-@[-`{-~])|&(#(?:\\d{1,7}|x[\\da-f]{1,6})|[\\da-z]{1,31});/gi\n\n/**\n * Decode markdown strings (which occur in places such as fenced code info\n * strings, destinations, labels, and titles).\n *\n * The “string” content type allows character escapes and -references.\n * This decodes those.\n *\n * @param {string} value\n *   Value to decode.\n * @returns {string}\n *   Decoded value.\n */\nexport function decodeString(value) {\n  return value.replace(characterEscapeOrReference, decode)\n}\n\n/**\n * @param {string} $0\n * @param {string} $1\n * @param {string} $2\n * @returns {string}\n */\nfunction decode($0, $1, $2) {\n  if ($1) {\n    // Escape.\n    return $1\n  }\n\n  // Reference.\n  const head = $2.charCodeAt(0)\n  if (head === 35) {\n    const head = $2.charCodeAt(1)\n    const hex = head === 120 || head === 88\n    return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10)\n  }\n  return decodeNamedCharacterReference($2) || $0\n}\n","/**\n * @typedef {import('mdast').Break} Break\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('mdast').Code} Code\n * @typedef {import('mdast').Definition} Definition\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('mdast').Html} Html\n * @typedef {import('mdast').Image} Image\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('mdast').Link} Link\n * @typedef {import('mdast').List} List\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Nodes} Nodes\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('mdast').Parent} Parent\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n * @typedef {import('mdast').ReferenceType} ReferenceType\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('mdast').Text} Text\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n *\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Value} Value\n *\n * @typedef {import('unist').Point} Point\n *\n * @typedef {import('../index.js').CompileData} CompileData\n */\n\n/**\n * @typedef {Omit<Parent, 'children' | 'type'> & {type: 'fragment', children: Array<PhrasingContent>}} Fragment\n */\n\n/**\n * @callback Transform\n *   Extra transform, to change the AST afterwards.\n * @param {Root} tree\n *   Tree to transform.\n * @returns {Root | null | undefined | void}\n *   New tree or nothing (in which case the current tree is used).\n *\n * @callback Handle\n *   Handle a token.\n * @param {CompileContext} this\n *   Context.\n * @param {Token} token\n *   Current token.\n * @returns {undefined | void}\n *   Nothing.\n *\n * @typedef {Record<string, Handle>} Handles\n *   Token types mapping to handles\n *\n * @callback OnEnterError\n *   Handle the case where the `right` token is open, but it is closed (by the\n *   `left` token) or because we reached the end of the document.\n * @param {Omit<CompileContext, 'sliceSerialize'>} this\n *   Context.\n * @param {Token | undefined} left\n *   Left token.\n * @param {Token} right\n *   Right token.\n * @returns {undefined}\n *   Nothing.\n *\n * @callback OnExitError\n *   Handle the case where the `right` token is open but it is closed by\n *   exiting the `left` token.\n * @param {Omit<CompileContext, 'sliceSerialize'>} this\n *   Context.\n * @param {Token} left\n *   Left token.\n * @param {Token} right\n *   Right token.\n * @returns {undefined}\n *   Nothing.\n *\n * @typedef {[Token, OnEnterError | undefined]} TokenTuple\n *   Open token on the stack, with an optional error handler for when\n *   that token isn’t closed properly.\n */\n\n/**\n * @typedef Config\n *   Configuration.\n *\n *   We have our defaults, but extensions will add more.\n * @property {Array<string>} canContainEols\n *   Token types where line endings are used.\n * @property {Handles} enter\n *   Opening handles.\n * @property {Handles} exit\n *   Closing handles.\n * @property {Array<Transform>} transforms\n *   Tree transforms.\n *\n * @typedef {Partial<Config>} Extension\n *   Change how markdown tokens from micromark are turned into mdast.\n *\n * @typedef CompileContext\n *   mdast compiler context.\n * @property {Array<Fragment | Nodes>} stack\n *   Stack of nodes.\n * @property {Array<TokenTuple>} tokenStack\n *   Stack of tokens.\n * @property {(this: CompileContext) => undefined} buffer\n *   Capture some of the output data.\n * @property {(this: CompileContext) => string} resume\n *   Stop capturing and access the output data.\n * @property {(this: CompileContext, node: Nodes, token: Token, onError?: OnEnterError) => undefined} enter\n *   Enter a node.\n * @property {(this: CompileContext, token: Token, onError?: OnExitError) => undefined} exit\n *   Exit a node.\n * @property {TokenizeContext['sliceSerialize']} sliceSerialize\n *   Get the string value of a token.\n * @property {Config} config\n *   Configuration.\n * @property {CompileData} data\n *   Info passed around; key/value store.\n *\n * @typedef FromMarkdownOptions\n *   Configuration for how to build mdast.\n * @property {Array<Extension | Array<Extension>> | null | undefined} [mdastExtensions]\n *   Extensions for this utility to change how tokens are turned into a tree.\n *\n * @typedef {ParseOptions & FromMarkdownOptions} Options\n *   Configuration.\n */\n\nimport { toString } from 'mdast-util-to-string';\nimport { parse, postprocess, preprocess } from 'micromark';\nimport { decodeNumericCharacterReference } from 'micromark-util-decode-numeric-character-reference';\nimport { decodeString } from 'micromark-util-decode-string';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nimport { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { stringifyPosition } from 'unist-util-stringify-position';\nconst own = {}.hasOwnProperty;\n\n/**\n * Turn markdown into a syntax tree.\n *\n * @overload\n * @param {Value} value\n * @param {Encoding | null | undefined} [encoding]\n * @param {Options | null | undefined} [options]\n * @returns {Root}\n *\n * @overload\n * @param {Value} value\n * @param {Options | null | undefined} [options]\n * @returns {Root}\n *\n * @param {Value} value\n *   Markdown to parse.\n * @param {Encoding | Options | null | undefined} [encoding]\n *   Character encoding for when `value` is `Buffer`.\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {Root}\n *   mdast tree.\n */\nexport function fromMarkdown(value, encoding, options) {\n  if (typeof encoding !== 'string') {\n    options = encoding;\n    encoding = undefined;\n  }\n  return compiler(options)(postprocess(parse(options).document().write(preprocess()(value, encoding, true))));\n}\n\n/**\n * Note this compiler only understand complete buffering, not streaming.\n *\n * @param {Options | null | undefined} [options]\n */\nfunction compiler(options) {\n  /** @type {Config} */\n  const config = {\n    transforms: [],\n    canContainEols: ['emphasis', 'fragment', 'heading', 'paragraph', 'strong'],\n    enter: {\n      autolink: opener(link),\n      autolinkProtocol: onenterdata,\n      autolinkEmail: onenterdata,\n      atxHeading: opener(heading),\n      blockQuote: opener(blockQuote),\n      characterEscape: onenterdata,\n      characterReference: onenterdata,\n      codeFenced: opener(codeFlow),\n      codeFencedFenceInfo: buffer,\n      codeFencedFenceMeta: buffer,\n      codeIndented: opener(codeFlow, buffer),\n      codeText: opener(codeText, buffer),\n      codeTextData: onenterdata,\n      data: onenterdata,\n      codeFlowValue: onenterdata,\n      definition: opener(definition),\n      definitionDestinationString: buffer,\n      definitionLabelString: buffer,\n      definitionTitleString: buffer,\n      emphasis: opener(emphasis),\n      hardBreakEscape: opener(hardBreak),\n      hardBreakTrailing: opener(hardBreak),\n      htmlFlow: opener(html, buffer),\n      htmlFlowData: onenterdata,\n      htmlText: opener(html, buffer),\n      htmlTextData: onenterdata,\n      image: opener(image),\n      label: buffer,\n      link: opener(link),\n      listItem: opener(listItem),\n      listItemValue: onenterlistitemvalue,\n      listOrdered: opener(list, onenterlistordered),\n      listUnordered: opener(list),\n      paragraph: opener(paragraph),\n      reference: onenterreference,\n      referenceString: buffer,\n      resourceDestinationString: buffer,\n      resourceTitleString: buffer,\n      setextHeading: opener(heading),\n      strong: opener(strong),\n      thematicBreak: opener(thematicBreak)\n    },\n    exit: {\n      atxHeading: closer(),\n      atxHeadingSequence: onexitatxheadingsequence,\n      autolink: closer(),\n      autolinkEmail: onexitautolinkemail,\n      autolinkProtocol: onexitautolinkprotocol,\n      blockQuote: closer(),\n      characterEscapeValue: onexitdata,\n      characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,\n      characterReferenceMarkerNumeric: onexitcharacterreferencemarker,\n      characterReferenceValue: onexitcharacterreferencevalue,\n      characterReference: onexitcharacterreference,\n      codeFenced: closer(onexitcodefenced),\n      codeFencedFence: onexitcodefencedfence,\n      codeFencedFenceInfo: onexitcodefencedfenceinfo,\n      codeFencedFenceMeta: onexitcodefencedfencemeta,\n      codeFlowValue: onexitdata,\n      codeIndented: closer(onexitcodeindented),\n      codeText: closer(onexitcodetext),\n      codeTextData: onexitdata,\n      data: onexitdata,\n      definition: closer(),\n      definitionDestinationString: onexitdefinitiondestinationstring,\n      definitionLabelString: onexitdefinitionlabelstring,\n      definitionTitleString: onexitdefinitiontitlestring,\n      emphasis: closer(),\n      hardBreakEscape: closer(onexithardbreak),\n      hardBreakTrailing: closer(onexithardbreak),\n      htmlFlow: closer(onexithtmlflow),\n      htmlFlowData: onexitdata,\n      htmlText: closer(onexithtmltext),\n      htmlTextData: onexitdata,\n      image: closer(onexitimage),\n      label: onexitlabel,\n      labelText: onexitlabeltext,\n      lineEnding: onexitlineending,\n      link: closer(onexitlink),\n      listItem: closer(),\n      listOrdered: closer(),\n      listUnordered: closer(),\n      paragraph: closer(),\n      referenceString: onexitreferencestring,\n      resourceDestinationString: onexitresourcedestinationstring,\n      resourceTitleString: onexitresourcetitlestring,\n      resource: onexitresource,\n      setextHeading: closer(onexitsetextheading),\n      setextHeadingLineSequence: onexitsetextheadinglinesequence,\n      setextHeadingText: onexitsetextheadingtext,\n      strong: closer(),\n      thematicBreak: closer()\n    }\n  };\n  configure(config, (options || {}).mdastExtensions || []);\n\n  /** @type {CompileData} */\n  const data = {};\n  return compile;\n\n  /**\n   * Turn micromark events into an mdast tree.\n   *\n   * @param {Array<Event>} events\n   *   Events.\n   * @returns {Root}\n   *   mdast tree.\n   */\n  function compile(events) {\n    /** @type {Root} */\n    let tree = {\n      type: 'root',\n      children: []\n    };\n    /** @type {Omit<CompileContext, 'sliceSerialize'>} */\n    const context = {\n      stack: [tree],\n      tokenStack: [],\n      config,\n      enter,\n      exit,\n      buffer,\n      resume,\n      data\n    };\n    /** @type {Array<number>} */\n    const listStack = [];\n    let index = -1;\n    while (++index < events.length) {\n      // We preprocess lists to add `listItem` tokens, and to infer whether\n      // items the list itself are spread out.\n      if (events[index][1].type === \"listOrdered\" || events[index][1].type === \"listUnordered\") {\n        if (events[index][0] === 'enter') {\n          listStack.push(index);\n        } else {\n          const tail = listStack.pop();\n          index = prepareList(events, tail, index);\n        }\n      }\n    }\n    index = -1;\n    while (++index < events.length) {\n      const handler = config[events[index][0]];\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(Object.assign({\n          sliceSerialize: events[index][2].sliceSerialize\n        }, context), events[index][1]);\n      }\n    }\n\n    // Handle tokens still being open.\n    if (context.tokenStack.length > 0) {\n      const tail = context.tokenStack[context.tokenStack.length - 1];\n      const handler = tail[1] || defaultOnError;\n      handler.call(context, undefined, tail[0]);\n    }\n\n    // Figure out `root` position.\n    tree.position = {\n      start: point(events.length > 0 ? events[0][1].start : {\n        line: 1,\n        column: 1,\n        offset: 0\n      }),\n      end: point(events.length > 0 ? events[events.length - 2][1].end : {\n        line: 1,\n        column: 1,\n        offset: 0\n      })\n    };\n\n    // Call transforms.\n    index = -1;\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree;\n    }\n    return tree;\n  }\n\n  /**\n   * @param {Array<Event>} events\n   * @param {number} start\n   * @param {number} length\n   * @returns {number}\n   */\n  function prepareList(events, start, length) {\n    let index = start - 1;\n    let containerBalance = -1;\n    let listSpread = false;\n    /** @type {Token | undefined} */\n    let listItem;\n    /** @type {number | undefined} */\n    let lineIndex;\n    /** @type {number | undefined} */\n    let firstBlankLineIndex;\n    /** @type {boolean | undefined} */\n    let atMarker;\n    while (++index <= length) {\n      const event = events[index];\n      switch (event[1].type) {\n        case \"listUnordered\":\n        case \"listOrdered\":\n        case \"blockQuote\":\n          {\n            if (event[0] === 'enter') {\n              containerBalance++;\n            } else {\n              containerBalance--;\n            }\n            atMarker = undefined;\n            break;\n          }\n        case \"lineEndingBlank\":\n          {\n            if (event[0] === 'enter') {\n              if (listItem && !atMarker && !containerBalance && !firstBlankLineIndex) {\n                firstBlankLineIndex = index;\n              }\n              atMarker = undefined;\n            }\n            break;\n          }\n        case \"linePrefix\":\n        case \"listItemValue\":\n        case \"listItemMarker\":\n        case \"listItemPrefix\":\n        case \"listItemPrefixWhitespace\":\n          {\n            // Empty.\n\n            break;\n          }\n        default:\n          {\n            atMarker = undefined;\n          }\n      }\n      if (!containerBalance && event[0] === 'enter' && event[1].type === \"listItemPrefix\" || containerBalance === -1 && event[0] === 'exit' && (event[1].type === \"listUnordered\" || event[1].type === \"listOrdered\")) {\n        if (listItem) {\n          let tailIndex = index;\n          lineIndex = undefined;\n          while (tailIndex--) {\n            const tailEvent = events[tailIndex];\n            if (tailEvent[1].type === \"lineEnding\" || tailEvent[1].type === \"lineEndingBlank\") {\n              if (tailEvent[0] === 'exit') continue;\n              if (lineIndex) {\n                events[lineIndex][1].type = \"lineEndingBlank\";\n                listSpread = true;\n              }\n              tailEvent[1].type = \"lineEnding\";\n              lineIndex = tailIndex;\n            } else if (tailEvent[1].type === \"linePrefix\" || tailEvent[1].type === \"blockQuotePrefix\" || tailEvent[1].type === \"blockQuotePrefixWhitespace\" || tailEvent[1].type === \"blockQuoteMarker\" || tailEvent[1].type === \"listItemIndent\") {\n              // Empty\n            } else {\n              break;\n            }\n          }\n          if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) {\n            listItem._spread = true;\n          }\n\n          // Fix position.\n          listItem.end = Object.assign({}, lineIndex ? events[lineIndex][1].start : event[1].end);\n          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]]);\n          index++;\n          length++;\n        }\n\n        // Create a new list item.\n        if (event[1].type === \"listItemPrefix\") {\n          /** @type {Token} */\n          const item = {\n            type: 'listItem',\n            _spread: false,\n            start: Object.assign({}, event[1].start),\n            // @ts-expect-error: we’ll add `end` in a second.\n            end: undefined\n          };\n          listItem = item;\n          events.splice(index, 0, ['enter', item, event[2]]);\n          index++;\n          length++;\n          firstBlankLineIndex = undefined;\n          atMarker = true;\n        }\n      }\n    }\n    events[start][1]._spread = listSpread;\n    return length;\n  }\n\n  /**\n   * Create an opener handle.\n   *\n   * @param {(token: Token) => Nodes} create\n   *   Create a node.\n   * @param {Handle | undefined} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function opener(create, and) {\n    return open;\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {undefined}\n     */\n    function open(token) {\n      enter.call(this, create(token), token);\n      if (and) and.call(this, token);\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @returns {undefined}\n   */\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    });\n  }\n\n  /**\n   * @this {CompileContext}\n   *   Context.\n   * @param {Nodes} node\n   *   Node to enter.\n   * @param {Token} token\n   *   Corresponding token.\n   * @param {OnEnterError | undefined} [errorHandler]\n   *   Handle the case where this token is open, but it is closed by something else.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function enter(node, token, errorHandler) {\n    const parent = this.stack[this.stack.length - 1];\n    /** @type {Array<Nodes>} */\n    const siblings = parent.children;\n    siblings.push(node);\n    this.stack.push(node);\n    this.tokenStack.push([token, errorHandler]);\n    node.position = {\n      start: point(token.start),\n      // @ts-expect-error: `end` will be patched later.\n      end: undefined\n    };\n  }\n\n  /**\n   * Create a closer handle.\n   *\n   * @param {Handle | undefined} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function closer(and) {\n    return close;\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {undefined}\n     */\n    function close(token) {\n      if (and) and.call(this, token);\n      exit.call(this, token);\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   *   Context.\n   * @param {Token} token\n   *   Corresponding token.\n   * @param {OnExitError | undefined} [onExitError]\n   *   Handle the case where another token is open.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function exit(token, onExitError) {\n    const node = this.stack.pop();\n    const open = this.tokenStack.pop();\n    if (!open) {\n      throw new Error('Cannot close `' + token.type + '` (' + stringifyPosition({\n        start: token.start,\n        end: token.end\n      }) + '): it’s not open');\n    } else if (open[0].type !== token.type) {\n      if (onExitError) {\n        onExitError.call(this, token, open[0]);\n      } else {\n        const handler = open[1] || defaultOnError;\n        handler.call(this, token, open[0]);\n      }\n    }\n    node.position.end = point(token.end);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @returns {string}\n   */\n  function resume() {\n    return toString(this.stack.pop());\n  }\n\n  //\n  // Handlers.\n  //\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistordered() {\n    this.data.expectingFirstListItemValue = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistitemvalue(token) {\n    if (this.data.expectingFirstListItemValue) {\n      const ancestor = this.stack[this.stack.length - 2];\n      ancestor.start = Number.parseInt(this.sliceSerialize(token), 10);\n      this.data.expectingFirstListItemValue = undefined;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfenceinfo() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.lang = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfencemeta() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.meta = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (this.data.flowCodeInside) return;\n    this.buffer();\n    this.data.flowCodeInside = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefenced() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '');\n    this.data.flowCodeInside = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodeindented() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data.replace(/(\\r?\\n|\\r)$/g, '');\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitionlabelstring(token) {\n    const label = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.label = label;\n    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiontitlestring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.title = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiondestinationstring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.url = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitatxheadingsequence(token) {\n    const node = this.stack[this.stack.length - 1];\n    if (!node.depth) {\n      const depth = this.sliceSerialize(token).length;\n      node.depth = depth;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadingtext() {\n    this.data.setextHeadingSlurpLineEnding = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadinglinesequence(token) {\n    const node = this.stack[this.stack.length - 1];\n    node.depth = this.sliceSerialize(token).codePointAt(0) === 61 ? 1 : 2;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheading() {\n    this.data.setextHeadingSlurpLineEnding = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterdata(token) {\n    const node = this.stack[this.stack.length - 1];\n    /** @type {Array<Nodes>} */\n    const siblings = node.children;\n    let tail = siblings[siblings.length - 1];\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text();\n      tail.position = {\n        start: point(token.start),\n        // @ts-expect-error: we’ll add `end` later.\n        end: undefined\n      };\n      siblings.push(tail);\n    }\n    this.stack.push(tail);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitdata(token) {\n    const tail = this.stack.pop();\n    tail.value += this.sliceSerialize(token);\n    tail.position.end = point(token.end);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlineending(token) {\n    const context = this.stack[this.stack.length - 1];\n    // If we’re at a hard break, include the line ending in there.\n    if (this.data.atHardBreak) {\n      const tail = context.children[context.children.length - 1];\n      tail.position.end = point(token.end);\n      this.data.atHardBreak = undefined;\n      return;\n    }\n    if (!this.data.setextHeadingSlurpLineEnding && config.canContainEols.includes(context.type)) {\n      onenterdata.call(this, token);\n      onexitdata.call(this, token);\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithardbreak() {\n    this.data.atHardBreak = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmlflow() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmltext() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcodetext() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlink() {\n    const node = this.stack[this.stack.length - 1];\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n\n    // To do: clean.\n    if (this.data.inReference) {\n      /** @type {ReferenceType} */\n      const referenceType = this.data.referenceType || 'shortcut';\n      node.type += 'Reference';\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType;\n      // @ts-expect-error: mutate.\n      delete node.url;\n      delete node.title;\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier;\n      // @ts-expect-error: mutate.\n      delete node.label;\n    }\n    this.data.referenceType = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitimage() {\n    const node = this.stack[this.stack.length - 1];\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n\n    // To do: clean.\n    if (this.data.inReference) {\n      /** @type {ReferenceType} */\n      const referenceType = this.data.referenceType || 'shortcut';\n      node.type += 'Reference';\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType;\n      // @ts-expect-error: mutate.\n      delete node.url;\n      delete node.title;\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier;\n      // @ts-expect-error: mutate.\n      delete node.label;\n    }\n    this.data.referenceType = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabeltext(token) {\n    const string = this.sliceSerialize(token);\n    const ancestor = this.stack[this.stack.length - 2];\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    ancestor.label = decodeString(string);\n    // @ts-expect-error: same as above.\n    ancestor.identifier = normalizeIdentifier(string).toLowerCase();\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabel() {\n    const fragment = this.stack[this.stack.length - 1];\n    const value = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    // Assume a reference.\n    this.data.inReference = true;\n    if (node.type === 'link') {\n      /** @type {Array<PhrasingContent>} */\n      const children = fragment.children;\n      node.children = children;\n    } else {\n      node.alt = value;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcedestinationstring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.url = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcetitlestring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.title = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresource() {\n    this.data.inReference = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterreference() {\n    this.data.referenceType = 'collapsed';\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitreferencestring(token) {\n    const label = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    node.label = label;\n    // @ts-expect-error: same as above.\n    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n    this.data.referenceType = 'full';\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcharacterreferencemarker(token) {\n    this.data.characterReferenceType = token.type;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcharacterreferencevalue(token) {\n    const data = this.sliceSerialize(token);\n    const type = this.data.characterReferenceType;\n    /** @type {string} */\n    let value;\n    if (type) {\n      value = decodeNumericCharacterReference(data, type === \"characterReferenceMarkerNumeric\" ? 10 : 16);\n      this.data.characterReferenceType = undefined;\n    } else {\n      const result = decodeNamedCharacterReference(data);\n      value = result;\n    }\n    const tail = this.stack[this.stack.length - 1];\n    tail.value += value;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcharacterreference(token) {\n    const tail = this.stack.pop();\n    tail.position.end = point(token.end);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token);\n    const node = this.stack[this.stack.length - 1];\n    node.url = this.sliceSerialize(token);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token);\n    const node = this.stack[this.stack.length - 1];\n    node.url = 'mailto:' + this.sliceSerialize(token);\n  }\n\n  //\n  // Creaters.\n  //\n\n  /** @returns {Blockquote} */\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    };\n  }\n\n  /** @returns {Code} */\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    };\n  }\n\n  /** @returns {InlineCode} */\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    };\n  }\n\n  /** @returns {Definition} */\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    };\n  }\n\n  /** @returns {Emphasis} */\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    };\n  }\n\n  /** @returns {Heading} */\n  function heading() {\n    return {\n      type: 'heading',\n      // @ts-expect-error `depth` will be set later.\n      depth: 0,\n      children: []\n    };\n  }\n\n  /** @returns {Break} */\n  function hardBreak() {\n    return {\n      type: 'break'\n    };\n  }\n\n  /** @returns {Html} */\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    };\n  }\n\n  /** @returns {Image} */\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    };\n  }\n\n  /** @returns {Link} */\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      children: []\n    };\n  }\n\n  /**\n   * @param {Token} token\n   * @returns {List}\n   */\n  function list(token) {\n    return {\n      type: 'list',\n      ordered: token.type === 'listOrdered',\n      start: null,\n      spread: token._spread,\n      children: []\n    };\n  }\n\n  /**\n   * @param {Token} token\n   * @returns {ListItem}\n   */\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      spread: token._spread,\n      checked: null,\n      children: []\n    };\n  }\n\n  /** @returns {Paragraph} */\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    };\n  }\n\n  /** @returns {Strong} */\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    };\n  }\n\n  /** @returns {Text} */\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    };\n  }\n\n  /** @returns {ThematicBreak} */\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    };\n  }\n}\n\n/**\n * Copy a point-like value.\n *\n * @param {Point} d\n *   Point-like value.\n * @returns {Point}\n *   unist point.\n */\nfunction point(d) {\n  return {\n    line: d.line,\n    column: d.column,\n    offset: d.offset\n  };\n}\n\n/**\n * @param {Config} combined\n * @param {Array<Array<Extension> | Extension>} extensions\n * @returns {undefined}\n */\nfunction configure(combined, extensions) {\n  let index = -1;\n  while (++index < extensions.length) {\n    const value = extensions[index];\n    if (Array.isArray(value)) {\n      configure(combined, value);\n    } else {\n      extension(combined, value);\n    }\n  }\n}\n\n/**\n * @param {Config} combined\n * @param {Extension} extension\n * @returns {undefined}\n */\nfunction extension(combined, extension) {\n  /** @type {keyof Extension} */\n  let key;\n  for (key in extension) {\n    if (own.call(extension, key)) {\n      switch (key) {\n        case 'canContainEols':\n          {\n            const right = extension[key];\n            if (right) {\n              combined[key].push(...right);\n            }\n            break;\n          }\n        case 'transforms':\n          {\n            const right = extension[key];\n            if (right) {\n              combined[key].push(...right);\n            }\n            break;\n          }\n        case 'enter':\n        case 'exit':\n          {\n            const right = extension[key];\n            if (right) {\n              Object.assign(combined[key], right);\n            }\n            break;\n          }\n        // No default\n      }\n    }\n  }\n}\n\n/** @type {OnEnterError} */\nfunction defaultOnError(left, right) {\n  if (left) {\n    throw new Error('Cannot close `' + left.type + '` (' + stringifyPosition({\n      start: left.start,\n      end: left.end\n    }) + '): a different token (`' + right.type + '`, ' + stringifyPosition({\n      start: right.start,\n      end: right.end\n    }) + ') is open');\n  } else {\n    throw new Error('Cannot close document, a token (`' + right.type + '`, ' + stringifyPosition({\n      start: right.start,\n      end: right.end\n    }) + ') is still open');\n  }\n}","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast-util-from-markdown').Options} FromMarkdownOptions\n * @typedef {import('unified').Parser<Root>} Parser\n * @typedef {import('unified').Processor<Root>} Processor\n */\n\n/**\n * @typedef {Omit<FromMarkdownOptions, 'extensions' | 'mdastExtensions'>} Options\n */\n\nimport {fromMarkdown} from 'mdast-util-from-markdown'\n\n/**\n * Aadd support for parsing from markdown.\n *\n * @param {Readonly<Options> | null | undefined} [options]\n *   Configuration (optional).\n * @returns {undefined}\n *   Nothing.\n */\nexport default function remarkParse(options) {\n  /** @type {Processor} */\n  // @ts-expect-error: TS in JSDoc generates wrong types if `this` is typed regularly.\n  const self = this\n\n  self.parser = parser\n\n  /**\n   * @type {Parser}\n   */\n  function parser(doc) {\n    return fromMarkdown(doc, {\n      ...self.data('settings'),\n      ...options,\n      // Note: these options are not in the readme.\n      // The goal is for them to be set by plugins on `data` instead of being\n      // passed by users.\n      extensions: self.data('micromarkExtensions') || [],\n      mdastExtensions: self.data('fromMarkdownExtensions') || []\n    })\n  }\n}\n","export const VOID       = -1;\nexport const PRIMITIVE  = 0;\nexport const ARRAY      = 1;\nexport const OBJECT     = 2;\nexport const DATE       = 3;\nexport const REGEXP     = 4;\nexport const MAP        = 5;\nexport const SET        = 6;\nexport const ERROR      = 7;\nexport const BIGINT     = 8;\n// export const SYMBOL = 9;\n","import {\n  VOID, PRIMITIVE,\n  ARRAY, OBJECT,\n  DATE, REGEXP, MAP, SET,\n  ERROR, BIGINT\n} from './types.js';\n\nconst env = typeof self === 'object' ? self : globalThis;\n\nconst deserializer = ($, _) => {\n  const as = (out, index) => {\n    $.set(index, out);\n    return out;\n  };\n\n  const unpair = index => {\n    if ($.has(index))\n      return $.get(index);\n\n    const [type, value] = _[index];\n    switch (type) {\n      case PRIMITIVE:\n      case VOID:\n        return as(value, index);\n      case ARRAY: {\n        const arr = as([], index);\n        for (const index of value)\n          arr.push(unpair(index));\n        return arr;\n      }\n      case OBJECT: {\n        const object = as({}, index);\n        for (const [key, index] of value)\n          object[unpair(key)] = unpair(index);\n        return object;\n      }\n      case DATE:\n        return as(new Date(value), index);\n      case REGEXP: {\n        const {source, flags} = value;\n        return as(new RegExp(source, flags), index);\n      }\n      case MAP: {\n        const map = as(new Map, index);\n        for (const [key, index] of value)\n          map.set(unpair(key), unpair(index));\n        return map;\n      }\n      case SET: {\n        const set = as(new Set, index);\n        for (const index of value)\n          set.add(unpair(index));\n        return set;\n      }\n      case ERROR: {\n        const {name, message} = value;\n        return as(new env[name](message), index);\n      }\n      case BIGINT:\n        return as(BigInt(value), index);\n      case 'BigInt':\n        return as(Object(BigInt(value)), index);\n    }\n    return as(new env[type](value), index);\n  };\n\n  return unpair;\n};\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns a deserialized value from a serialized array of Records.\n * @param {Record[]} serialized a previously serialized value.\n * @returns {any}\n */\nexport const deserialize = serialized => deserializer(new Map, serialized)(0);\n","import {\n  VOID, PRIMITIVE,\n  ARRAY, OBJECT,\n  DATE, REGEXP, MAP, SET,\n  ERROR, BIGINT\n} from './types.js';\n\nconst EMPTY = '';\n\nconst {toString} = {};\nconst {keys} = Object;\n\nconst typeOf = value => {\n  const type = typeof value;\n  if (type !== 'object' || !value)\n    return [PRIMITIVE, type];\n\n  const asString = toString.call(value).slice(8, -1);\n  switch (asString) {\n    case 'Array':\n      return [ARRAY, EMPTY];\n    case 'Object':\n      return [OBJECT, EMPTY];\n    case 'Date':\n      return [DATE, EMPTY];\n    case 'RegExp':\n      return [REGEXP, EMPTY];\n    case 'Map':\n      return [MAP, EMPTY];\n    case 'Set':\n      return [SET, EMPTY];\n  }\n\n  if (asString.includes('Array'))\n    return [ARRAY, asString];\n\n  if (asString.includes('Error'))\n    return [ERROR, asString];\n\n  return [OBJECT, asString];\n};\n\nconst shouldSkip = ([TYPE, type]) => (\n  TYPE === PRIMITIVE &&\n  (type === 'function' || type === 'symbol')\n);\n\nconst serializer = (strict, json, $, _) => {\n\n  const as = (out, value) => {\n    const index = _.push(out) - 1;\n    $.set(value, index);\n    return index;\n  };\n\n  const pair = value => {\n    if ($.has(value))\n      return $.get(value);\n\n    let [TYPE, type] = typeOf(value);\n    switch (TYPE) {\n      case PRIMITIVE: {\n        let entry = value;\n        switch (type) {\n          case 'bigint':\n            TYPE = BIGINT;\n            entry = value.toString();\n            break;\n          case 'function':\n          case 'symbol':\n            if (strict)\n              throw new TypeError('unable to serialize ' + type);\n            entry = null;\n            break;\n          case 'undefined':\n            return as([VOID], value);\n        }\n        return as([TYPE, entry], value);\n      }\n      case ARRAY: {\n        if (type)\n          return as([type, [...value]], value);\n  \n        const arr = [];\n        const index = as([TYPE, arr], value);\n        for (const entry of value)\n          arr.push(pair(entry));\n        return index;\n      }\n      case OBJECT: {\n        if (type) {\n          switch (type) {\n            case 'BigInt':\n              return as([type, value.toString()], value);\n            case 'Boolean':\n            case 'Number':\n            case 'String':\n              return as([type, value.valueOf()], value);\n          }\n        }\n\n        if (json && ('toJSON' in value))\n          return pair(value.toJSON());\n\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const key of keys(value)) {\n          if (strict || !shouldSkip(typeOf(value[key])))\n            entries.push([pair(key), pair(value[key])]);\n        }\n        return index;\n      }\n      case DATE:\n        return as([TYPE, value.toISOString()], value);\n      case REGEXP: {\n        const {source, flags} = value;\n        return as([TYPE, {source, flags}], value);\n      }\n      case MAP: {\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const [key, entry] of value) {\n          if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry))))\n            entries.push([pair(key), pair(entry)]);\n        }\n        return index;\n      }\n      case SET: {\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const entry of value) {\n          if (strict || !shouldSkip(typeOf(entry)))\n            entries.push(pair(entry));\n        }\n        return index;\n      }\n    }\n\n    const {message} = value;\n    return as([TYPE, {name: type, message}], value);\n  };\n\n  return pair;\n};\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns an array of serialized Records.\n * @param {any} value a serializable value.\n * @param {{json?: boolean, lossy?: boolean}?} options an object with a `lossy` or `json` property that,\n *  if `true`, will not throw errors on incompatible types, and behave more\n *  like JSON stringify would behave. Symbol and Function will be discarded.\n * @returns {Record[]}\n */\n export const serialize = (value, {json, lossy} = {}) => {\n  const _ = [];\n  return serializer(!(json || lossy), !!json, new Map, _)(value), _;\n};\n","import {deserialize} from './deserialize.js';\nimport {serialize} from './serialize.js';\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns an array of serialized Records.\n * @param {any} any a serializable value.\n * @param {{transfer?: any[], json?: boolean, lossy?: boolean}?} options an object with\n * a transfer option (ignored when polyfilled) and/or non standard fields that\n * fallback to the polyfill if present.\n * @returns {Record[]}\n */\nexport default typeof structuredClone === \"function\" ?\n  /* c8 ignore start */\n  (any, options) => (\n    options && ('json' in options || 'lossy' in options) ?\n      deserialize(serialize(any, options)) : structuredClone(any)\n  ) :\n  (any, options) => deserialize(serialize(any, options));\n  /* c8 ignore stop */\n\nexport {deserialize, serialize};\n","import {asciiAlphanumeric} from 'micromark-util-character'\nimport {encode} from 'micromark-util-encode'\n/**\n * Make a value safe for injection as a URL.\n *\n * This encodes unsafe characters with percent-encoding and skips already\n * encoded sequences (see `normalizeUri`).\n * Further unsafe characters are encoded as character references (see\n * `micromark-util-encode`).\n *\n * A regex of allowed protocols can be given, in which case the URL is\n * sanitized.\n * For example, `/^(https?|ircs?|mailto|xmpp)$/i` can be used for `a[href]`, or\n * `/^https?$/i` for `img[src]` (this is what `github.com` allows).\n * If the URL includes an unknown protocol (one not matched by `protocol`, such\n * as a dangerous example, `javascript:`), the value is ignored.\n *\n * @param {string | null | undefined} url\n *   URI to sanitize.\n * @param {RegExp | null | undefined} [protocol]\n *   Allowed protocols.\n * @returns {string}\n *   Sanitized URI.\n */\nexport function sanitizeUri(url, protocol) {\n  const value = encode(normalizeUri(url || ''))\n  if (!protocol) {\n    return value\n  }\n  const colon = value.indexOf(':')\n  const questionMark = value.indexOf('?')\n  const numberSign = value.indexOf('#')\n  const slash = value.indexOf('/')\n  if (\n    // If there is no protocol, it’s relative.\n    colon < 0 ||\n    // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.\n    (slash > -1 && colon > slash) ||\n    (questionMark > -1 && colon > questionMark) ||\n    (numberSign > -1 && colon > numberSign) ||\n    // It is a protocol, it should be allowed.\n    protocol.test(value.slice(0, colon))\n  ) {\n    return value\n  }\n  return ''\n}\n\n/**\n * Normalize a URL.\n *\n * Encode unsafe characters with percent-encoding, skipping already encoded\n * sequences.\n *\n * @param {string} value\n *   URI to normalize.\n * @returns {string}\n *   Normalized URI.\n */\nexport function normalizeUri(value) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n  let start = 0\n  let skip = 0\n  while (++index < value.length) {\n    const code = value.charCodeAt(index)\n    /** @type {string} */\n    let replace = ''\n\n    // A correct percent encoded value.\n    if (\n      code === 37 &&\n      asciiAlphanumeric(value.charCodeAt(index + 1)) &&\n      asciiAlphanumeric(value.charCodeAt(index + 2))\n    ) {\n      skip = 2\n    }\n    // ASCII.\n    else if (code < 128) {\n      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {\n        replace = String.fromCharCode(code)\n      }\n    }\n    // Astral.\n    else if (code > 55_295 && code < 57_344) {\n      const next = value.charCodeAt(index + 1)\n\n      // A correct surrogate pair.\n      if (code < 56_320 && next > 56_319 && next < 57_344) {\n        replace = String.fromCharCode(code, next)\n        skip = 1\n      }\n      // Lone surrogate.\n      else {\n        replace = '\\uFFFD'\n      }\n    }\n    // Unicode.\n    else {\n      replace = String.fromCharCode(code)\n    }\n    if (replace) {\n      result.push(value.slice(start, index), encodeURIComponent(replace))\n      start = index + skip + 1\n      replace = ''\n    }\n    if (skip) {\n      index += skip\n      skip = 0\n    }\n  }\n  return result.join('') + value.slice(start)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n *\n * @typedef {import('./state.js').State} State\n */\n\n/**\n * @callback FootnoteBackContentTemplate\n *   Generate content for the backreference dynamically.\n *\n *   For the following markdown:\n *\n *   ```markdown\n *   Alpha[^micromark], bravo[^micromark], and charlie[^remark].\n *\n *   [^remark]: things about remark\n *   [^micromark]: things about micromark\n *   ```\n *\n *   This function will be called with:\n *\n *   *  `0` and `0` for the backreference from `things about micromark` to\n *      `alpha`, as it is the first used definition, and the first call to it\n *   *  `0` and `1` for the backreference from `things about micromark` to\n *      `bravo`, as it is the first used definition, and the second call to it\n *   *  `1` and `0` for the backreference from `things about remark` to\n *      `charlie`, as it is the second used definition\n * @param {number} referenceIndex\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {Array<ElementContent> | ElementContent | string}\n *   Content for the backreference when linking back from definitions to their\n *   reference.\n *\n * @callback FootnoteBackLabelTemplate\n *   Generate a back label dynamically.\n *\n *   For the following markdown:\n *\n *   ```markdown\n *   Alpha[^micromark], bravo[^micromark], and charlie[^remark].\n *\n *   [^remark]: things about remark\n *   [^micromark]: things about micromark\n *   ```\n *\n *   This function will be called with:\n *\n *   *  `0` and `0` for the backreference from `things about micromark` to\n *      `alpha`, as it is the first used definition, and the first call to it\n *   *  `0` and `1` for the backreference from `things about micromark` to\n *      `bravo`, as it is the first used definition, and the second call to it\n *   *  `1` and `0` for the backreference from `things about remark` to\n *      `charlie`, as it is the second used definition\n * @param {number} referenceIndex\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {string}\n *   Back label to use when linking back from definitions to their reference.\n */\n\nimport structuredClone from '@ungap/structured-clone'\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Generate the default content that GitHub uses on backreferences.\n *\n * @param {number} _\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {Array<ElementContent>}\n *   Content.\n */\nexport function defaultFootnoteBackContent(_, rereferenceIndex) {\n  /** @type {Array<ElementContent>} */\n  const result = [{type: 'text', value: '↩'}]\n\n  if (rereferenceIndex > 1) {\n    result.push({\n      type: 'element',\n      tagName: 'sup',\n      properties: {},\n      children: [{type: 'text', value: String(rereferenceIndex)}]\n    })\n  }\n\n  return result\n}\n\n/**\n * Generate the default label that GitHub uses on backreferences.\n *\n * @param {number} referenceIndex\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {string}\n *   Label.\n */\nexport function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {\n  return (\n    'Back to reference ' +\n    (referenceIndex + 1) +\n    (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')\n  )\n}\n\n/**\n * Generate a hast footer for called footnote definitions.\n *\n * @param {State} state\n *   Info passed around.\n * @returns {Element | undefined}\n *   `section` element or `undefined`.\n */\n// eslint-disable-next-line complexity\nexport function footer(state) {\n  const clobberPrefix =\n    typeof state.options.clobberPrefix === 'string'\n      ? state.options.clobberPrefix\n      : 'user-content-'\n  const footnoteBackContent =\n    state.options.footnoteBackContent || defaultFootnoteBackContent\n  const footnoteBackLabel =\n    state.options.footnoteBackLabel || defaultFootnoteBackLabel\n  const footnoteLabel = state.options.footnoteLabel || 'Footnotes'\n  const footnoteLabelTagName = state.options.footnoteLabelTagName || 'h2'\n  const footnoteLabelProperties = state.options.footnoteLabelProperties || {\n    className: ['sr-only']\n  }\n  /** @type {Array<ElementContent>} */\n  const listItems = []\n  let referenceIndex = -1\n\n  while (++referenceIndex < state.footnoteOrder.length) {\n    const definition = state.footnoteById.get(\n      state.footnoteOrder[referenceIndex]\n    )\n\n    if (!definition) {\n      continue\n    }\n\n    const content = state.all(definition)\n    const id = String(definition.identifier).toUpperCase()\n    const safeId = normalizeUri(id.toLowerCase())\n    let rereferenceIndex = 0\n    /** @type {Array<ElementContent>} */\n    const backReferences = []\n    const counts = state.footnoteCounts.get(id)\n\n    // eslint-disable-next-line no-unmodified-loop-condition\n    while (counts !== undefined && ++rereferenceIndex <= counts) {\n      if (backReferences.length > 0) {\n        backReferences.push({type: 'text', value: ' '})\n      }\n\n      let children =\n        typeof footnoteBackContent === 'string'\n          ? footnoteBackContent\n          : footnoteBackContent(referenceIndex, rereferenceIndex)\n\n      if (typeof children === 'string') {\n        children = {type: 'text', value: children}\n      }\n\n      backReferences.push({\n        type: 'element',\n        tagName: 'a',\n        properties: {\n          href:\n            '#' +\n            clobberPrefix +\n            'fnref-' +\n            safeId +\n            (rereferenceIndex > 1 ? '-' + rereferenceIndex : ''),\n          dataFootnoteBackref: '',\n          ariaLabel:\n            typeof footnoteBackLabel === 'string'\n              ? footnoteBackLabel\n              : footnoteBackLabel(referenceIndex, rereferenceIndex),\n          className: ['data-footnote-backref']\n        },\n        children: Array.isArray(children) ? children : [children]\n      })\n    }\n\n    const tail = content[content.length - 1]\n\n    if (tail && tail.type === 'element' && tail.tagName === 'p') {\n      const tailTail = tail.children[tail.children.length - 1]\n      if (tailTail && tailTail.type === 'text') {\n        tailTail.value += ' '\n      } else {\n        tail.children.push({type: 'text', value: ' '})\n      }\n\n      tail.children.push(...backReferences)\n    } else {\n      content.push(...backReferences)\n    }\n\n    /** @type {Element} */\n    const listItem = {\n      type: 'element',\n      tagName: 'li',\n      properties: {id: clobberPrefix + 'fn-' + safeId},\n      children: state.wrap(content, true)\n    }\n\n    state.patch(definition, listItem)\n\n    listItems.push(listItem)\n  }\n\n  if (listItems.length === 0) {\n    return\n  }\n\n  return {\n    type: 'element',\n    tagName: 'section',\n    properties: {dataFootnotes: true, className: ['footnotes']},\n    children: [\n      {\n        type: 'element',\n        tagName: footnoteLabelTagName,\n        properties: {\n          ...structuredClone(footnoteLabelProperties),\n          id: 'footnote-label'\n        },\n        children: [{type: 'text', value: footnoteLabel}]\n      },\n      {type: 'text', value: '\\n'},\n      {\n        type: 'element',\n        tagName: 'ol',\n        properties: {},\n        children: state.wrap(listItems, true)\n      },\n      {type: 'text', value: '\\n'}\n    ]\n  }\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n */\n\n/**\n * @template Fn\n * @template Fallback\n * @typedef {Fn extends (value: any) => value is infer Thing ? Thing : Fallback} Predicate\n */\n\n/**\n * @callback Check\n *   Check that an arbitrary value is a node.\n * @param {unknown} this\n *   The given context.\n * @param {unknown} [node]\n *   Anything (typically a node).\n * @param {number | null | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean}\n *   Whether this is a node and passes a test.\n *\n * @typedef {Record<string, unknown> | Node} Props\n *   Object to check for equivalence.\n *\n *   Note: `Node` is included as it is common but is not indexable.\n *\n * @typedef {Array<Props | TestFunction | string> | Props | TestFunction | string | null | undefined} Test\n *   Check for an arbitrary node.\n *\n * @callback TestFunction\n *   Check if a node passes a test.\n * @param {unknown} this\n *   The given context.\n * @param {Node} node\n *   A node.\n * @param {number | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean | undefined | void}\n *   Whether this node passes the test.\n *\n *   Note: `void` is included until TS sees no return as `undefined`.\n */\n\n/**\n * Check if `node` is a `Node` and whether it passes the given test.\n *\n * @param {unknown} node\n *   Thing to check, typically `Node`.\n * @param {Test} test\n *   A check for a specific node.\n * @param {number | null | undefined} index\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} parent\n *   The node’s parent.\n * @param {unknown} context\n *   Context object (`this`) to pass to `test` functions.\n * @returns {boolean}\n *   Whether `node` is a node and passes a test.\n */\nexport const is =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends string>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n   *   (<Condition extends Props>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n   *   (<Condition extends TestFunction>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n   *   ((node?: null | undefined) => false) &\n   *   ((node: unknown, test?: null | undefined, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n   *   ((node: unknown, test?: Test, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => boolean)\n   * )}\n   */\n  (\n    /**\n     * @param {unknown} [node]\n     * @param {Test} [test]\n     * @param {number | null | undefined} [index]\n     * @param {Parent | null | undefined} [parent]\n     * @param {unknown} [context]\n     * @returns {boolean}\n     */\n    // eslint-disable-next-line max-params\n    function (node, test, index, parent, context) {\n      const check = convert(test)\n\n      if (\n        index !== undefined &&\n        index !== null &&\n        (typeof index !== 'number' ||\n          index < 0 ||\n          index === Number.POSITIVE_INFINITY)\n      ) {\n        throw new Error('Expected positive finite index')\n      }\n\n      if (\n        parent !== undefined &&\n        parent !== null &&\n        (!is(parent) || !parent.children)\n      ) {\n        throw new Error('Expected parent node')\n      }\n\n      if (\n        (parent === undefined || parent === null) !==\n        (index === undefined || index === null)\n      ) {\n        throw new Error('Expected both parent and index')\n      }\n\n      return looksLikeANode(node)\n        ? check.call(context, node, index, parent)\n        : false\n    }\n  )\n\n/**\n * Generate an assertion from a test.\n *\n * Useful if you’re going to test many nodes, for example when creating a\n * utility where something else passes a compatible test.\n *\n * The created function is a bit faster because it expects valid input only:\n * a `node`, `index`, and `parent`.\n *\n * @param {Test} test\n *   *   when nullish, checks if `node` is a `Node`.\n *   *   when `string`, works like passing `(node) => node.type === test`.\n *   *   when `function` checks if function passed the node is true.\n *   *   when `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n *   *   when `array`, checks if any one of the subtests pass.\n * @returns {Check}\n *   An assertion.\n */\nexport const convert =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n   *   (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n   *   (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n   *   ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n   *   ((test?: Test) => Check)\n   * )}\n   */\n  (\n    /**\n     * @param {Test} [test]\n     * @returns {Check}\n     */\n    function (test) {\n      if (test === null || test === undefined) {\n        return ok\n      }\n\n      if (typeof test === 'function') {\n        return castFactory(test)\n      }\n\n      if (typeof test === 'object') {\n        return Array.isArray(test) ? anyFactory(test) : propsFactory(test)\n      }\n\n      if (typeof test === 'string') {\n        return typeFactory(test)\n      }\n\n      throw new Error('Expected function, string, or object as test')\n    }\n  )\n\n/**\n * @param {Array<Props | TestFunction | string>} tests\n * @returns {Check}\n */\nfunction anyFactory(tests) {\n  /** @type {Array<Check>} */\n  const checks = []\n  let index = -1\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index])\n  }\n\n  return castFactory(any)\n\n  /**\n   * @this {unknown}\n   * @type {TestFunction}\n   */\n  function any(...parameters) {\n    let index = -1\n\n    while (++index < checks.length) {\n      if (checks[index].apply(this, parameters)) return true\n    }\n\n    return false\n  }\n}\n\n/**\n * Turn an object into a test for a node with a certain fields.\n *\n * @param {Props} check\n * @returns {Check}\n */\nfunction propsFactory(check) {\n  const checkAsRecord = /** @type {Record<string, unknown>} */ (check)\n\n  return castFactory(all)\n\n  /**\n   * @param {Node} node\n   * @returns {boolean}\n   */\n  function all(node) {\n    const nodeAsRecord = /** @type {Record<string, unknown>} */ (\n      /** @type {unknown} */ (node)\n    )\n\n    /** @type {string} */\n    let key\n\n    for (key in check) {\n      if (nodeAsRecord[key] !== checkAsRecord[key]) return false\n    }\n\n    return true\n  }\n}\n\n/**\n * Turn a string into a test for a node with a certain type.\n *\n * @param {string} check\n * @returns {Check}\n */\nfunction typeFactory(check) {\n  return castFactory(type)\n\n  /**\n   * @param {Node} node\n   */\n  function type(node) {\n    return node && node.type === check\n  }\n}\n\n/**\n * Turn a custom test into a test for a node that passes that test.\n *\n * @param {TestFunction} testFunction\n * @returns {Check}\n */\nfunction castFactory(testFunction) {\n  return check\n\n  /**\n   * @this {unknown}\n   * @type {Check}\n   */\n  function check(value, index, parent) {\n    return Boolean(\n      looksLikeANode(value) &&\n        testFunction.call(\n          this,\n          value,\n          typeof index === 'number' ? index : undefined,\n          parent || undefined\n        )\n    )\n  }\n}\n\nfunction ok() {\n  return true\n}\n\n/**\n * @param {unknown} value\n * @returns {value is Node}\n */\nfunction looksLikeANode(value) {\n  return value !== null && typeof value === 'object' && 'type' in value\n}\n","/**\n * @param {string} d\n * @returns {string}\n */\nexport function color(d) {\n  return d\n}\n","/**\n * @typedef {import('unist').Node} UnistNode\n * @typedef {import('unist').Parent} UnistParent\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends Array<any>\n *   ? MatchesOne<Value, Check[keyof Check]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {InternalAncestor<InclusiveDescendant<Tree>, Child>} Ancestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {'skip' | boolean} Action\n *   Union of the action types.\n *\n * @typedef {number} Index\n *   Move to the sibling at `index` next (after node itself is completely\n *   traversed).\n *\n *   Useful if mutating the tree, such as removing the node the visitor is\n *   currently on, or any of its previous siblings.\n *   Results less than 0 or greater than or equal to `children.length` stop\n *   traversing the parent.\n *\n * @typedef {[(Action | null | undefined | void)?, (Index | null | undefined)?]} ActionTuple\n *   List with one or two values, the first an action, the second an index.\n *\n * @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult\n *   Any value that can be returned from a visitor.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform the parent of node (the last of `ancestors`).\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of an ancestor still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Array<VisitedParents>} ancestors\n *   Ancestors of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [VisitedParents=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Matches<InclusiveDescendant<Tree>, Check>, Ancestor<Tree, Matches<InclusiveDescendant<Tree>, Check>>>} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parents`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Tree type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport {convert} from 'unist-util-is'\nimport {color} from 'unist-util-visit-parents/do-not-use-color'\n\n/** @type {Readonly<ActionTuple>} */\nconst empty = []\n\n/**\n * Continue traversing as normal.\n */\nexport const CONTINUE = true\n\n/**\n * Stop traversing immediately.\n */\nexport const EXIT = false\n\n/**\n * Do not traverse this node’s children.\n */\nexport const SKIP = 'skip'\n\n/**\n * Visit nodes, with ancestral information.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} test\n *   `unist-util-is`-compatible test\n * @param {Visitor | boolean | null | undefined} [visitor]\n *   Handle each node.\n * @param {boolean | null | undefined} [reverse]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visitParents(tree, test, visitor, reverse) {\n  /** @type {Test} */\n  let check\n\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor\n    // @ts-expect-error no visitor given, so `visitor` is test.\n    visitor = test\n  } else {\n    // @ts-expect-error visitor given, so `test` isn’t a visitor.\n    check = test\n  }\n\n  const is = convert(check)\n  const step = reverse ? -1 : 1\n\n  factory(tree, undefined, [])()\n\n  /**\n   * @param {UnistNode} node\n   * @param {number | undefined} index\n   * @param {Array<UnistParent>} parents\n   */\n  function factory(node, index, parents) {\n    const value = /** @type {Record<string, unknown>} */ (\n      node && typeof node === 'object' ? node : {}\n    )\n\n    if (typeof value.type === 'string') {\n      const name =\n        // `hast`\n        typeof value.tagName === 'string'\n          ? value.tagName\n          : // `xast`\n          typeof value.name === 'string'\n          ? value.name\n          : undefined\n\n      Object.defineProperty(visit, 'name', {\n        value:\n          'node (' + color(node.type + (name ? '<' + name + '>' : '')) + ')'\n      })\n    }\n\n    return visit\n\n    function visit() {\n      /** @type {Readonly<ActionTuple>} */\n      let result = empty\n      /** @type {Readonly<ActionTuple>} */\n      let subresult\n      /** @type {number} */\n      let offset\n      /** @type {Array<UnistParent>} */\n      let grandparents\n\n      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {\n        // @ts-expect-error: `visitor` is now a visitor.\n        result = toResult(visitor(node, parents))\n\n        if (result[0] === EXIT) {\n          return result\n        }\n      }\n\n      if ('children' in node && node.children) {\n        const nodeAsParent = /** @type {UnistParent} */ (node)\n\n        if (nodeAsParent.children && result[0] !== SKIP) {\n          offset = (reverse ? nodeAsParent.children.length : -1) + step\n          grandparents = parents.concat(nodeAsParent)\n\n          while (offset > -1 && offset < nodeAsParent.children.length) {\n            const child = nodeAsParent.children[offset]\n\n            subresult = factory(child, offset, grandparents)()\n\n            if (subresult[0] === EXIT) {\n              return subresult\n            }\n\n            offset =\n              typeof subresult[1] === 'number' ? subresult[1] : offset + step\n          }\n        }\n      }\n\n      return result\n    }\n  }\n}\n\n/**\n * Turn a return value into a clean result.\n *\n * @param {VisitorResult} value\n *   Valid return values from visitors.\n * @returns {Readonly<ActionTuple>}\n *   Clean result.\n */\nfunction toResult(value) {\n  if (Array.isArray(value)) {\n    return value\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value]\n  }\n\n  return value === null || value === undefined ? empty : [value]\n}\n","/**\n * @typedef {import('unist').Node} UnistNode\n * @typedef {import('unist').Parent} UnistParent\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n// To do: use types from `unist-util-visit-parents` when it’s released.\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends Array<any>\n *   ? MatchesOne<Value, Check[keyof Check]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform `parent`.\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of `parent` still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Visited extends UnistNode ? number | undefined : never} index\n *   Index of `node` in `parent`.\n * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent\n *   Parent of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [Ancestor=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch\n *   Build a typed `Visitor` function from a node and all possible parents.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Visited\n *   Node type.\n * @template {UnistParent} Ancestor\n *   Parent type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromMatch<\n *     Matches<Descendant, Check>,\n *     Extract<Descendant, UnistParent>\n *   >\n * )} BuildVisitorFromDescendants\n *   Build a typed `Visitor` function from a list of descendants and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Descendant\n *   Node type.\n * @template {Test} Check\n *   Test type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromDescendants<\n *     InclusiveDescendant<Tree>,\n *     Check\n *   >\n * )} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Node type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport {visitParents} from 'unist-util-visit-parents'\n\nexport {CONTINUE, EXIT, SKIP} from 'unist-util-visit-parents'\n\n/**\n * Visit nodes.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} testOrVisitor\n *   `unist-util-is`-compatible test (optional, omit to pass a visitor).\n * @param {Visitor | boolean | null | undefined} [visitorOrReverse]\n *   Handle each node (when test is omitted, pass `reverse`).\n * @param {boolean | null | undefined} [maybeReverse=false]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {\n  /** @type {boolean | null | undefined} */\n  let reverse\n  /** @type {Test} */\n  let test\n  /** @type {Visitor} */\n  let visitor\n\n  if (\n    typeof testOrVisitor === 'function' &&\n    typeof visitorOrReverse !== 'function'\n  ) {\n    test = undefined\n    visitor = testOrVisitor\n    reverse = visitorOrReverse\n  } else {\n    // @ts-expect-error: assume the overload with test was given.\n    test = testOrVisitor\n    // @ts-expect-error: assume the overload with test was given.\n    visitor = visitorOrReverse\n    reverse = maybeReverse\n  }\n\n  visitParents(tree, test, overload, reverse)\n\n  /**\n   * @param {UnistNode} node\n   * @param {Array<UnistParent>} parents\n   */\n  function overload(node, parents) {\n    const parent = parents[parents.length - 1]\n    const index = parent ? parent.children.indexOf(node) : undefined\n    return visitor(node, index, parent)\n  }\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `blockquote` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Blockquote} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function blockquote(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'blockquote',\n    properties: {},\n    children: state.wrap(state.all(node), true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('mdast').Break} Break\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `break` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Break} node\n *   mdast node.\n * @returns {Array<Element | Text>}\n *   hast element content.\n */\nexport function hardBreak(state, node) {\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'br', properties: {}, children: []}\n  state.patch(node, result)\n  return [state.applyData(node, result), {type: 'text', value: '\\n'}]\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Code} Code\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `code` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Code} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function code(state, node) {\n  const value = node.value ? node.value + '\\n' : ''\n  /** @type {Properties} */\n  const properties = {}\n\n  if (node.lang) {\n    properties.className = ['language-' + node.lang]\n  }\n\n  // Create `<code>`.\n  /** @type {Element} */\n  let result = {\n    type: 'element',\n    tagName: 'code',\n    properties,\n    children: [{type: 'text', value}]\n  }\n\n  if (node.meta) {\n    result.data = {meta: node.meta}\n  }\n\n  state.patch(node, result)\n  result = state.applyData(node, result)\n\n  // Create `<pre>`.\n  result = {type: 'element', tagName: 'pre', properties: {}, children: [result]}\n  state.patch(node, result)\n  return result\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Delete} Delete\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `delete` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Delete} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function strikethrough(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'del',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `emphasis` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Emphasis} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function emphasis(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'em',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').FootnoteReference} FootnoteReference\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `footnoteReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {FootnoteReference} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function footnoteReference(state, node) {\n  const clobberPrefix =\n    typeof state.options.clobberPrefix === 'string'\n      ? state.options.clobberPrefix\n      : 'user-content-'\n  const id = String(node.identifier).toUpperCase()\n  const safeId = normalizeUri(id.toLowerCase())\n  const index = state.footnoteOrder.indexOf(id)\n  /** @type {number} */\n  let counter\n\n  let reuseCounter = state.footnoteCounts.get(id)\n\n  if (reuseCounter === undefined) {\n    reuseCounter = 0\n    state.footnoteOrder.push(id)\n    counter = state.footnoteOrder.length\n  } else {\n    counter = index + 1\n  }\n\n  reuseCounter += 1\n  state.footnoteCounts.set(id, reuseCounter)\n\n  /** @type {Element} */\n  const link = {\n    type: 'element',\n    tagName: 'a',\n    properties: {\n      href: '#' + clobberPrefix + 'fn-' + safeId,\n      id:\n        clobberPrefix +\n        'fnref-' +\n        safeId +\n        (reuseCounter > 1 ? '-' + reuseCounter : ''),\n      dataFootnoteRef: true,\n      ariaDescribedBy: ['footnote-label']\n    },\n    children: [{type: 'text', value: String(counter)}]\n  }\n  state.patch(node, link)\n\n  /** @type {Element} */\n  const sup = {\n    type: 'element',\n    tagName: 'sup',\n    properties: {},\n    children: [link]\n  }\n  state.patch(node, sup)\n  return state.applyData(node, sup)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `heading` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Heading} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function heading(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'h' + node.depth,\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Html} Html\n * @typedef {import('../state.js').State} State\n * @typedef {import('../../index.js').Raw} Raw\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `html` node into hast (`raw` node in dangerous mode, otherwise\n * nothing).\n *\n * @param {State} state\n *   Info passed around.\n * @param {Html} node\n *   mdast node.\n * @returns {Element | Raw | undefined}\n *   hast node.\n */\nexport function html(state, node) {\n  if (state.options.allowDangerousHtml) {\n    /** @type {Raw} */\n    const result = {type: 'raw', value: node.value}\n    state.patch(node, result)\n    return state.applyData(node, result)\n  }\n\n  return undefined\n}\n","/**\n * @typedef {import('hast').ElementContent} ElementContent\n *\n * @typedef {import('mdast').Nodes} Nodes\n * @typedef {import('mdast').Reference} Reference\n *\n * @typedef {import('./state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Return the content of a reference without definition as plain text.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Extract<Nodes, Reference>} node\n *   Reference node (image, link).\n * @returns {Array<ElementContent>}\n *   hast content.\n */\nexport function revert(state, node) {\n  const subtype = node.referenceType\n  let suffix = ']'\n\n  if (subtype === 'collapsed') {\n    suffix += '[]'\n  } else if (subtype === 'full') {\n    suffix += '[' + (node.label || node.identifier) + ']'\n  }\n\n  if (node.type === 'imageReference') {\n    return [{type: 'text', value: '![' + node.alt + suffix}]\n  }\n\n  const contents = state.all(node)\n  const head = contents[0]\n\n  if (head && head.type === 'text') {\n    head.value = '[' + head.value\n  } else {\n    contents.unshift({type: 'text', value: '['})\n  }\n\n  const tail = contents[contents.length - 1]\n\n  if (tail && tail.type === 'text') {\n    tail.value += suffix\n  } else {\n    contents.push({type: 'text', value: suffix})\n  }\n\n  return contents\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\n\n/**\n * Turn an mdast `imageReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ImageReference} node\n *   mdast node.\n * @returns {Array<ElementContent> | ElementContent}\n *   hast node.\n */\nexport function imageReference(state, node) {\n  const id = String(node.identifier).toUpperCase()\n  const definition = state.definitionById.get(id)\n\n  if (!definition) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {src: normalizeUri(definition.url || ''), alt: node.alt}\n\n  if (definition.title !== null && definition.title !== undefined) {\n    properties.title = definition.title\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'img', properties, children: []}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Image} Image\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `image` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Image} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function image(state, node) {\n  /** @type {Properties} */\n  const properties = {src: normalizeUri(node.url)}\n\n  if (node.alt !== null && node.alt !== undefined) {\n    properties.alt = node.alt\n  }\n\n  if (node.title !== null && node.title !== undefined) {\n    properties.title = node.title\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'img', properties, children: []}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `inlineCode` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {InlineCode} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function inlineCode(state, node) {\n  /** @type {Text} */\n  const text = {type: 'text', value: node.value.replace(/\\r?\\n|\\r/g, ' ')}\n  state.patch(node, text)\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'code',\n    properties: {},\n    children: [text]\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\n\n/**\n * Turn an mdast `linkReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {LinkReference} node\n *   mdast node.\n * @returns {Array<ElementContent> | ElementContent}\n *   hast node.\n */\nexport function linkReference(state, node) {\n  const id = String(node.identifier).toUpperCase()\n  const definition = state.definitionById.get(id)\n\n  if (!definition) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {href: normalizeUri(definition.url || '')}\n\n  if (definition.title !== null && definition.title !== undefined) {\n    properties.title = definition.title\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'a',\n    properties,\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Link} Link\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `link` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Link} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function link(state, node) {\n  /** @type {Properties} */\n  const properties = {href: normalizeUri(node.url)}\n\n  if (node.title !== null && node.title !== undefined) {\n    properties.title = node.title\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'a',\n    properties,\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `listItem` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ListItem} node\n *   mdast node.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @returns {Element}\n *   hast node.\n */\nexport function listItem(state, node, parent) {\n  const results = state.all(node)\n  const loose = parent ? listLoose(parent) : listItemLoose(node)\n  /** @type {Properties} */\n  const properties = {}\n  /** @type {Array<ElementContent>} */\n  const children = []\n\n  if (typeof node.checked === 'boolean') {\n    const head = results[0]\n    /** @type {Element} */\n    let paragraph\n\n    if (head && head.type === 'element' && head.tagName === 'p') {\n      paragraph = head\n    } else {\n      paragraph = {type: 'element', tagName: 'p', properties: {}, children: []}\n      results.unshift(paragraph)\n    }\n\n    if (paragraph.children.length > 0) {\n      paragraph.children.unshift({type: 'text', value: ' '})\n    }\n\n    paragraph.children.unshift({\n      type: 'element',\n      tagName: 'input',\n      properties: {type: 'checkbox', checked: node.checked, disabled: true},\n      children: []\n    })\n\n    // According to github-markdown-css, this class hides bullet.\n    // See: <https://github.com/sindresorhus/github-markdown-css>.\n    properties.className = ['task-list-item']\n  }\n\n  let index = -1\n\n  while (++index < results.length) {\n    const child = results[index]\n\n    // Add eols before nodes, except if this is a loose, first paragraph.\n    if (\n      loose ||\n      index !== 0 ||\n      child.type !== 'element' ||\n      child.tagName !== 'p'\n    ) {\n      children.push({type: 'text', value: '\\n'})\n    }\n\n    if (child.type === 'element' && child.tagName === 'p' && !loose) {\n      children.push(...child.children)\n    } else {\n      children.push(child)\n    }\n  }\n\n  const tail = results[results.length - 1]\n\n  // Add a final eol.\n  if (tail && (loose || tail.type !== 'element' || tail.tagName !== 'p')) {\n    children.push({type: 'text', value: '\\n'})\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'li', properties, children}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n\n/**\n * @param {Parents} node\n * @return {Boolean}\n */\nfunction listLoose(node) {\n  let loose = false\n  if (node.type === 'list') {\n    loose = node.spread || false\n    const children = node.children\n    let index = -1\n\n    while (!loose && ++index < children.length) {\n      loose = listItemLoose(children[index])\n    }\n  }\n\n  return loose\n}\n\n/**\n * @param {ListItem} node\n * @return {Boolean}\n */\nfunction listItemLoose(node) {\n  const spread = node.spread\n\n  return spread === null || spread === undefined\n    ? node.children.length > 1\n    : spread\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').List} List\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `list` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {List} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function list(state, node) {\n  /** @type {Properties} */\n  const properties = {}\n  const results = state.all(node)\n  let index = -1\n\n  if (typeof node.start === 'number' && node.start !== 1) {\n    properties.start = node.start\n  }\n\n  // Like GitHub, add a class for custom styling.\n  while (++index < results.length) {\n    const child = results[index]\n\n    if (\n      child.type === 'element' &&\n      child.tagName === 'li' &&\n      child.properties &&\n      Array.isArray(child.properties.className) &&\n      child.properties.className.includes('task-list-item')\n    ) {\n      properties.className = ['contains-task-list']\n      break\n    }\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: node.ordered ? 'ol' : 'ul',\n    properties,\n    children: state.wrap(results, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `paragraph` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Paragraph} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function paragraph(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'p',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Parents} HastParents\n * @typedef {import('hast').Root} HastRoot\n * @typedef {import('mdast').Root} MdastRoot\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `root` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastRoot} node\n *   mdast node.\n * @returns {HastParents}\n *   hast node.\n */\nexport function root(state, node) {\n  /** @type {HastRoot} */\n  const result = {type: 'root', children: state.wrap(state.all(node))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `strong` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Strong} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function strong(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'strong',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Table} Table\n * @typedef {import('../state.js').State} State\n */\n\nimport {pointEnd, pointStart} from 'unist-util-position'\n\n/**\n * Turn an mdast `table` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Table} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function table(state, node) {\n  const rows = state.all(node)\n  const firstRow = rows.shift()\n  /** @type {Array<Element>} */\n  const tableContent = []\n\n  if (firstRow) {\n    /** @type {Element} */\n    const head = {\n      type: 'element',\n      tagName: 'thead',\n      properties: {},\n      children: state.wrap([firstRow], true)\n    }\n    state.patch(node.children[0], head)\n    tableContent.push(head)\n  }\n\n  if (rows.length > 0) {\n    /** @type {Element} */\n    const body = {\n      type: 'element',\n      tagName: 'tbody',\n      properties: {},\n      children: state.wrap(rows, true)\n    }\n\n    const start = pointStart(node.children[1])\n    const end = pointEnd(node.children[node.children.length - 1])\n    if (start && end) body.position = {start, end}\n    tableContent.push(body)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'table',\n    properties: {},\n    children: state.wrap(tableContent, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('mdast').TableRow} TableRow\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `tableRow` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableRow} node\n *   mdast node.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @returns {Element}\n *   hast node.\n */\nexport function tableRow(state, node, parent) {\n  const siblings = parent ? parent.children : undefined\n  // Generate a body row when without parent.\n  const rowIndex = siblings ? siblings.indexOf(node) : 1\n  const tagName = rowIndex === 0 ? 'th' : 'td'\n  // To do: option to use `style`?\n  const align = parent && parent.type === 'table' ? parent.align : undefined\n  const length = align ? align.length : node.children.length\n  let cellIndex = -1\n  /** @type {Array<ElementContent>} */\n  const cells = []\n\n  while (++cellIndex < length) {\n    // Note: can also be undefined.\n    const cell = node.children[cellIndex]\n    /** @type {Properties} */\n    const properties = {}\n    const alignValue = align ? align[cellIndex] : undefined\n\n    if (alignValue) {\n      properties.align = alignValue\n    }\n\n    /** @type {Element} */\n    let result = {type: 'element', tagName, properties, children: []}\n\n    if (cell) {\n      result.children = state.all(cell)\n      state.patch(cell, result)\n      result = state.applyData(cell, result)\n    }\n\n    cells.push(result)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'tr',\n    properties: {},\n    children: state.wrap(cells, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').TableCell} TableCell\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `tableCell` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableCell} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function tableCell(state, node) {\n  // Note: this function is normally not called: see `table-row` for how rows\n  // and their cells are compiled.\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'td', // Assume body cell.\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","const tab = 9 /* `\\t` */\nconst space = 32 /* ` ` */\n\n/**\n * Remove initial and final spaces and tabs at the line breaks in `value`.\n * Does not trim initial and final spaces and tabs of the value itself.\n *\n * @param {string} value\n *   Value to trim.\n * @returns {string}\n *   Trimmed value.\n */\nexport function trimLines(value) {\n  const source = String(value)\n  const search = /\\r?\\n|\\r/g\n  let match = search.exec(source)\n  let last = 0\n  /** @type {Array<string>} */\n  const lines = []\n\n  while (match) {\n    lines.push(\n      trimLine(source.slice(last, match.index), last > 0, true),\n      match[0]\n    )\n\n    last = match.index + match[0].length\n    match = search.exec(source)\n  }\n\n  lines.push(trimLine(source.slice(last), last > 0, false))\n\n  return lines.join('')\n}\n\n/**\n * @param {string} value\n *   Line to trim.\n * @param {boolean} start\n *   Whether to trim the start of the line.\n * @param {boolean} end\n *   Whether to trim the end of the line.\n * @returns {string}\n *   Trimmed line.\n */\nfunction trimLine(value, start, end) {\n  let startIndex = 0\n  let endIndex = value.length\n\n  if (start) {\n    let code = value.codePointAt(startIndex)\n\n    while (code === tab || code === space) {\n      startIndex++\n      code = value.codePointAt(startIndex)\n    }\n  }\n\n  if (end) {\n    let code = value.codePointAt(endIndex - 1)\n\n    while (code === tab || code === space) {\n      endIndex--\n      code = value.codePointAt(endIndex - 1)\n    }\n  }\n\n  return endIndex > startIndex ? value.slice(startIndex, endIndex) : ''\n}\n","/**\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').Text} HastText\n * @typedef {import('mdast').Text} MdastText\n * @typedef {import('../state.js').State} State\n */\n\nimport {trimLines} from 'trim-lines'\n\n/**\n * Turn an mdast `text` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastText} node\n *   mdast node.\n * @returns {HastElement | HastText}\n *   hast node.\n */\nexport function text(state, node) {\n  /** @type {HastText} */\n  const result = {type: 'text', value: trimLines(String(node.value))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `thematicBreak` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ThematicBreak} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function thematicBreak(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'hr',\n    properties: {},\n    children: []\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","import {blockquote} from './blockquote.js'\nimport {hardBreak} from './break.js'\nimport {code} from './code.js'\nimport {strikethrough} from './delete.js'\nimport {emphasis} from './emphasis.js'\nimport {footnoteReference} from './footnote-reference.js'\nimport {heading} from './heading.js'\nimport {html} from './html.js'\nimport {imageReference} from './image-reference.js'\nimport {image} from './image.js'\nimport {inlineCode} from './inline-code.js'\nimport {linkReference} from './link-reference.js'\nimport {link} from './link.js'\nimport {listItem} from './list-item.js'\nimport {list} from './list.js'\nimport {paragraph} from './paragraph.js'\nimport {root} from './root.js'\nimport {strong} from './strong.js'\nimport {table} from './table.js'\nimport {tableRow} from './table-row.js'\nimport {tableCell} from './table-cell.js'\nimport {text} from './text.js'\nimport {thematicBreak} from './thematic-break.js'\n\n/**\n * Default handlers for nodes.\n *\n * @satisfies {import('../state.js').Handlers}\n */\nexport const handlers = {\n  blockquote,\n  break: hardBreak,\n  code,\n  delete: strikethrough,\n  emphasis,\n  footnoteReference,\n  heading,\n  html,\n  imageReference,\n  image,\n  inlineCode,\n  linkReference,\n  link,\n  listItem,\n  list,\n  paragraph,\n  // @ts-expect-error: root is different, but hard to type.\n  root,\n  strong,\n  table,\n  tableCell,\n  tableRow,\n  text,\n  thematicBreak,\n  toml: ignore,\n  yaml: ignore,\n  definition: ignore,\n  footnoteDefinition: ignore\n}\n\n// Return nothing for nodes that are ignored.\nfunction ignore() {\n  return undefined\n}\n","/**\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').ElementContent} HastElementContent\n * @typedef {import('hast').Nodes} HastNodes\n * @typedef {import('hast').Properties} HastProperties\n * @typedef {import('hast').RootContent} HastRootContent\n * @typedef {import('hast').Text} HastText\n *\n * @typedef {import('mdast').Definition} MdastDefinition\n * @typedef {import('mdast').FootnoteDefinition} MdastFootnoteDefinition\n * @typedef {import('mdast').Nodes} MdastNodes\n * @typedef {import('mdast').Parents} MdastParents\n *\n * @typedef {import('vfile').VFile} VFile\n *\n * @typedef {import('./footer.js').FootnoteBackContentTemplate} FootnoteBackContentTemplate\n * @typedef {import('./footer.js').FootnoteBackLabelTemplate} FootnoteBackLabelTemplate\n */\n\n/**\n * @callback Handler\n *   Handle a node.\n * @param {State} state\n *   Info passed around.\n * @param {any} node\n *   mdast node to handle.\n * @param {MdastParents | undefined} parent\n *   Parent of `node`.\n * @returns {Array<HastElementContent> | HastElementContent | undefined}\n *   hast node.\n *\n * @typedef {Partial<Record<MdastNodes['type'], Handler>>} Handlers\n *   Handle nodes.\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [allowDangerousHtml=false]\n *   Whether to persist raw HTML in markdown in the hast tree (default:\n *   `false`).\n * @property {string | null | undefined} [clobberPrefix='user-content-']\n *   Prefix to use before the `id` property on footnotes to prevent them from\n *   *clobbering* (default: `'user-content-'`).\n *\n *   Pass `''` for trusted markdown and when you are careful with\n *   polyfilling.\n *   You could pass a different prefix.\n *\n *   DOM clobbering is this:\n *\n *   ```html\n *   <p id=\"x\"></p>\n *   <script>alert(x) // `x` now refers to the `p#x` DOM element</script>\n *   ```\n *\n *   The above example shows that elements are made available by browsers, by\n *   their ID, on the `window` object.\n *   This is a security risk because you might be expecting some other variable\n *   at that place.\n *   It can also break polyfills.\n *   Using a prefix solves these problems.\n * @property {VFile | null | undefined} [file]\n *   Corresponding virtual file representing the input document (optional).\n * @property {FootnoteBackContentTemplate | string | null | undefined} [footnoteBackContent]\n *   Content of the backreference back to references (default: `defaultFootnoteBackContent`).\n *\n *   The default value is:\n *\n *   ```js\n *   function defaultFootnoteBackContent(_, rereferenceIndex) {\n *     const result = [{type: 'text', value: '↩'}]\n *\n *     if (rereferenceIndex > 1) {\n *       result.push({\n *         type: 'element',\n *         tagName: 'sup',\n *         properties: {},\n *         children: [{type: 'text', value: String(rereferenceIndex)}]\n *       })\n *     }\n *\n *     return result\n *   }\n *   ```\n *\n *   This content is used in the `a` element of each backreference (the `↩`\n *   links).\n * @property {FootnoteBackLabelTemplate | string | null | undefined} [footnoteBackLabel]\n *   Label to describe the backreference back to references (default:\n *   `defaultFootnoteBackLabel`).\n *\n *   The default value is:\n *\n *   ```js\n *   function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {\n *    return (\n *      'Back to reference ' +\n *      (referenceIndex + 1) +\n *      (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')\n *    )\n *   }\n *   ```\n *\n *   Change it when the markdown is not in English.\n *\n *   This label is used in the `ariaLabel` property on each backreference\n *   (the `↩` links).\n *   It affects users of assistive technology.\n * @property {string | null | undefined} [footnoteLabel='Footnotes']\n *   Textual label to use for the footnotes section (default: `'Footnotes'`).\n *\n *   Change it when the markdown is not in English.\n *\n *   This label is typically hidden visually (assuming a `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass different properties with the `footnoteLabelProperties` option.\n * @property {HastProperties | null | undefined} [footnoteLabelProperties={className: ['sr-only']}]\n *   Properties to use on the footnote label (default: `{className:\n *   ['sr-only']}`).\n *\n *   Change it to show the label and add other properties.\n *\n *   This label is typically hidden visually (assuming an `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass an empty string.\n *   You can also add different properties.\n *\n *   > **Note**: `id: 'footnote-label'` is always added, because footnote\n *   > calls use it with `aria-describedby` to provide an accessible label.\n * @property {string | null | undefined} [footnoteLabelTagName='h2']\n *   HTML tag name to use for the footnote label element (default: `'h2'`).\n *\n *   Change it to match your document structure.\n *\n *   This label is typically hidden visually (assuming a `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass different properties with the `footnoteLabelProperties` option.\n * @property {Handlers | null | undefined} [handlers]\n *   Extra handlers for nodes (optional).\n * @property {Array<MdastNodes['type']> | null | undefined} [passThrough]\n *   List of custom mdast node types to pass through (keep) in hast (note that\n *   the node itself is passed, but eventual children are transformed)\n *   (optional).\n * @property {Handler | null | undefined} [unknownHandler]\n *   Handler for all unknown nodes (optional).\n *\n * @typedef State\n *   Info passed around.\n * @property {(node: MdastNodes) => Array<HastElementContent>} all\n *   Transform the children of an mdast parent to hast.\n * @property {<Type extends HastNodes>(from: MdastNodes, to: Type) => HastElement | Type} applyData\n *   Honor the `data` of `from`, and generate an element instead of `node`.\n * @property {Map<string, MdastDefinition>} definitionById\n *   Definitions by their identifier.\n * @property {Map<string, MdastFootnoteDefinition>} footnoteById\n *   Footnote definitions by their identifier.\n * @property {Map<string, number>} footnoteCounts\n *   Counts for how often the same footnote was called.\n * @property {Array<string>} footnoteOrder\n *   Identifiers of order when footnote calls first appear in tree order.\n * @property {Handlers} handlers\n *   Applied handlers.\n * @property {(node: MdastNodes, parent: MdastParents | undefined) => Array<HastElementContent> | HastElementContent | undefined} one\n *   Transform an mdast node to hast.\n * @property {Options} options\n *   Configuration.\n * @property {(from: MdastNodes, node: HastNodes) => undefined} patch\n *   Copy a node’s positional info.\n * @property {<Type extends HastRootContent>(nodes: Array<Type>, loose?: boolean | undefined) => Array<HastText | Type>} wrap\n *   Wrap `nodes` with line endings between each node, adds initial/final line endings when `loose`.\n */\n\nimport structuredClone from '@ungap/structured-clone'\nimport {visit} from 'unist-util-visit'\nimport {position} from 'unist-util-position'\nimport {handlers as defaultHandlers} from './handlers/index.js'\n\nconst own = {}.hasOwnProperty\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Create `state` from an mdast tree.\n *\n * @param {MdastNodes} tree\n *   mdast node to transform.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {State}\n *   `state` function.\n */\nexport function createState(tree, options) {\n  const settings = options || emptyOptions\n  /** @type {Map<string, MdastDefinition>} */\n  const definitionById = new Map()\n  /** @type {Map<string, MdastFootnoteDefinition>} */\n  const footnoteById = new Map()\n  /** @type {Map<string, number>} */\n  const footnoteCounts = new Map()\n  /** @type {Handlers} */\n  // @ts-expect-error: the root handler returns a root.\n  // Hard to type.\n  const handlers = {...defaultHandlers, ...settings.handlers}\n\n  /** @type {State} */\n  const state = {\n    all,\n    applyData,\n    definitionById,\n    footnoteById,\n    footnoteCounts,\n    footnoteOrder: [],\n    handlers,\n    one,\n    options: settings,\n    patch,\n    wrap\n  }\n\n  visit(tree, function (node) {\n    if (node.type === 'definition' || node.type === 'footnoteDefinition') {\n      const map = node.type === 'definition' ? definitionById : footnoteById\n      const id = String(node.identifier).toUpperCase()\n\n      // Mimick CM behavior of link definitions.\n      // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/9032189/lib/index.js#L20-L21>.\n      if (!map.has(id)) {\n        // @ts-expect-error: node type matches map.\n        map.set(id, node)\n      }\n    }\n  })\n\n  return state\n\n  /**\n   * Transform an mdast node into a hast node.\n   *\n   * @param {MdastNodes} node\n   *   mdast node.\n   * @param {MdastParents | undefined} [parent]\n   *   Parent of `node`.\n   * @returns {Array<HastElementContent> | HastElementContent | undefined}\n   *   Resulting hast node.\n   */\n  function one(node, parent) {\n    const type = node.type\n    const handle = state.handlers[type]\n\n    if (own.call(state.handlers, type) && handle) {\n      return handle(state, node, parent)\n    }\n\n    if (state.options.passThrough && state.options.passThrough.includes(type)) {\n      if ('children' in node) {\n        const {children, ...shallow} = node\n        const result = structuredClone(shallow)\n        // @ts-expect-error: TS doesn’t understand…\n        result.children = state.all(node)\n        // @ts-expect-error: TS doesn’t understand…\n        return result\n      }\n\n      // @ts-expect-error: it’s custom.\n      return structuredClone(node)\n    }\n\n    const unknown = state.options.unknownHandler || defaultUnknownHandler\n\n    return unknown(state, node, parent)\n  }\n\n  /**\n   * Transform the children of an mdast node into hast nodes.\n   *\n   * @param {MdastNodes} parent\n   *   mdast node to compile\n   * @returns {Array<HastElementContent>}\n   *   Resulting hast nodes.\n   */\n  function all(parent) {\n    /** @type {Array<HastElementContent>} */\n    const values = []\n\n    if ('children' in parent) {\n      const nodes = parent.children\n      let index = -1\n      while (++index < nodes.length) {\n        const result = state.one(nodes[index], parent)\n\n        // To do: see if we van clean this? Can we merge texts?\n        if (result) {\n          if (index && nodes[index - 1].type === 'break') {\n            if (!Array.isArray(result) && result.type === 'text') {\n              result.value = trimMarkdownSpaceStart(result.value)\n            }\n\n            if (!Array.isArray(result) && result.type === 'element') {\n              const head = result.children[0]\n\n              if (head && head.type === 'text') {\n                head.value = trimMarkdownSpaceStart(head.value)\n              }\n            }\n          }\n\n          if (Array.isArray(result)) {\n            values.push(...result)\n          } else {\n            values.push(result)\n          }\n        }\n      }\n    }\n\n    return values\n  }\n}\n\n/**\n * Copy a node’s positional info.\n *\n * @param {MdastNodes} from\n *   mdast node to copy from.\n * @param {HastNodes} to\n *   hast node to copy into.\n * @returns {undefined}\n *   Nothing.\n */\nfunction patch(from, to) {\n  if (from.position) to.position = position(from)\n}\n\n/**\n * Honor the `data` of `from` and maybe generate an element instead of `to`.\n *\n * @template {HastNodes} Type\n *   Node type.\n * @param {MdastNodes} from\n *   mdast node to use data from.\n * @param {Type} to\n *   hast node to change.\n * @returns {HastElement | Type}\n *   Nothing.\n */\nfunction applyData(from, to) {\n  /** @type {HastElement | Type} */\n  let result = to\n\n  // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n  if (from && from.data) {\n    const hName = from.data.hName\n    const hChildren = from.data.hChildren\n    const hProperties = from.data.hProperties\n\n    if (typeof hName === 'string') {\n      // Transforming the node resulted in an element with a different name\n      // than wanted:\n      if (result.type === 'element') {\n        result.tagName = hName\n      }\n      // Transforming the node resulted in a non-element, which happens for\n      // raw, text, and root nodes (unless custom handlers are passed).\n      // The intent of `hName` is to create an element, but likely also to keep\n      // the content around (otherwise: pass `hChildren`).\n      else {\n        /** @type {Array<HastElementContent>} */\n        // @ts-expect-error: assume no doctypes in `root`.\n        const children = 'children' in result ? result.children : [result]\n        result = {type: 'element', tagName: hName, properties: {}, children}\n      }\n    }\n\n    if (result.type === 'element' && hProperties) {\n      Object.assign(result.properties, structuredClone(hProperties))\n    }\n\n    if (\n      'children' in result &&\n      result.children &&\n      hChildren !== null &&\n      hChildren !== undefined\n    ) {\n      result.children = hChildren\n    }\n  }\n\n  return result\n}\n\n/**\n * Transform an unknown node.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastNodes} node\n *   Unknown mdast node.\n * @returns {HastElement | HastText}\n *   Resulting hast node.\n */\nfunction defaultUnknownHandler(state, node) {\n  const data = node.data || {}\n  /** @type {HastElement | HastText} */\n  const result =\n    'value' in node &&\n    !(own.call(data, 'hProperties') || own.call(data, 'hChildren'))\n      ? {type: 'text', value: node.value}\n      : {\n          type: 'element',\n          tagName: 'div',\n          properties: {},\n          children: state.all(node)\n        }\n\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n\n/**\n * Wrap `nodes` with line endings between each node.\n *\n * @template {HastRootContent} Type\n *   Node type.\n * @param {Array<Type>} nodes\n *   List of nodes to wrap.\n * @param {boolean | undefined} [loose=false]\n *   Whether to add line endings at start and end (default: `false`).\n * @returns {Array<HastText | Type>}\n *   Wrapped nodes.\n */\nexport function wrap(nodes, loose) {\n  /** @type {Array<HastText | Type>} */\n  const result = []\n  let index = -1\n\n  if (loose) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  while (++index < nodes.length) {\n    if (index) result.push({type: 'text', value: '\\n'})\n    result.push(nodes[index])\n  }\n\n  if (loose && nodes.length > 0) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  return result\n}\n\n/**\n * Trim spaces and tabs at the start of `value`.\n *\n * @param {string} value\n *   Value to trim.\n * @returns {string}\n *   Result.\n */\nfunction trimMarkdownSpaceStart(value) {\n  let index = 0\n  let code = value.charCodeAt(index)\n\n  while (code === 9 || code === 32) {\n    index++\n    code = value.charCodeAt(index)\n  }\n\n  return value.slice(index)\n}\n","/**\n * @typedef {import('hast').Nodes} HastNodes\n * @typedef {import('mdast').Nodes} MdastNodes\n * @typedef {import('./state.js').Options} Options\n */\n\nimport {ok as assert} from 'devlop'\nimport {footer} from './footer.js'\nimport {createState} from './state.js'\n\n/**\n * Transform mdast to hast.\n *\n * ##### Notes\n *\n * ###### HTML\n *\n * Raw HTML is available in mdast as `html` nodes and can be embedded in hast\n * as semistandard `raw` nodes.\n * Most utilities ignore `raw` nodes but two notable ones don’t:\n *\n * *   `hast-util-to-html` also has an option `allowDangerousHtml` which will\n *     output the raw HTML.\n *     This is typically discouraged as noted by the option name but is useful\n *     if you completely trust authors\n * *   `hast-util-raw` can handle the raw embedded HTML strings by parsing them\n *     into standard hast nodes (`element`, `text`, etc).\n *     This is a heavy task as it needs a full HTML parser, but it is the only\n *     way to support untrusted content\n *\n * ###### Footnotes\n *\n * Many options supported here relate to footnotes.\n * Footnotes are not specified by CommonMark, which we follow by default.\n * They are supported by GitHub, so footnotes can be enabled in markdown with\n * `mdast-util-gfm`.\n *\n * The options `footnoteBackLabel` and `footnoteLabel` define natural language\n * that explains footnotes, which is hidden for sighted users but shown to\n * assistive technology.\n * When your page is not in English, you must define translated values.\n *\n * Back references use ARIA attributes, but the section label itself uses a\n * heading that is hidden with an `sr-only` class.\n * To show it to sighted users, define different attributes in\n * `footnoteLabelProperties`.\n *\n * ###### Clobbering\n *\n * Footnotes introduces a problem, as it links footnote calls to footnote\n * definitions on the page through `id` attributes generated from user content,\n * which results in DOM clobbering.\n *\n * DOM clobbering is this:\n *\n * ```html\n * <p id=x></p>\n * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>\n * ```\n *\n * Elements by their ID are made available by browsers on the `window` object,\n * which is a security risk.\n * Using a prefix solves this problem.\n *\n * More information on how to handle clobbering and the prefix is explained in\n * Example: headings (DOM clobbering) in `rehype-sanitize`.\n *\n * ###### Unknown nodes\n *\n * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.\n * The default behavior for unknown nodes is:\n *\n * *   when the node has a `value` (and doesn’t have `data.hName`,\n *     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`\n *     node\n * *   otherwise, create a `<div>` element (which could be changed with\n *     `data.hName`), with its children mapped from mdast to hast as well\n *\n * This behavior can be changed by passing an `unknownHandler`.\n *\n * @param {MdastNodes} tree\n *   mdast tree.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {HastNodes}\n *   hast tree.\n */\nexport function toHast(tree, options) {\n  const state = createState(tree, options)\n  const node = state.one(tree, undefined)\n  const foot = footer(state)\n  /** @type {HastNodes} */\n  const result = Array.isArray(node)\n    ? {type: 'root', children: node}\n    : node || {type: 'root', children: []}\n\n  if (foot) {\n    // If there’s a footer, there were definitions, meaning block\n    // content.\n    // So `result` is a parent node.\n    assert('children' in result)\n    result.children.push({type: 'text', value: '\\n'}, foot)\n  }\n\n  return result\n}\n","// Include `data` fields in mdast and `raw` nodes in hast.\n/// <reference types=\"mdast-util-to-hast\" />\n\n/**\n * @import {Root as HastRoot} from 'hast'\n * @import {Root as MdastRoot} from 'mdast'\n * @import {Options as ToHastOptions} from 'mdast-util-to-hast'\n * @import {Processor} from 'unified'\n * @import {VFile} from 'vfile'\n */\n\n/**\n * @typedef {Omit<ToHastOptions, 'file'>} Options\n *\n * @callback TransformBridge\n *   Bridge-mode.\n *\n *   Runs the destination with the new hast tree.\n *   Discards result.\n * @param {MdastRoot} tree\n *   Tree.\n * @param {VFile} file\n *   File.\n * @returns {Promise<undefined>}\n *   Nothing.\n *\n * @callback TransformMutate\n *  Mutate-mode.\n *\n *  Further transformers run on the hast tree.\n * @param {MdastRoot} tree\n *   Tree.\n * @param {VFile} file\n *   File.\n * @returns {HastRoot}\n *   Tree (hast).\n */\n\nimport {toHast} from 'mdast-util-to-hast'\n\n/**\n * Turn markdown into HTML.\n *\n * ##### Notes\n *\n * ###### Signature\n *\n * *   if a processor is given, runs the (rehype) plugins used on it with a\n *     hast tree, then discards the result (*bridge mode*)\n * *   otherwise, returns a hast tree, the plugins used after `remarkRehype`\n *     are rehype plugins (*mutate mode*)\n *\n * > 👉 **Note**: It’s highly unlikely that you want to pass a `processor`.\n *\n * ###### HTML\n *\n * Raw HTML is available in mdast as `html` nodes and can be embedded in hast\n * as semistandard `raw` nodes.\n * Most plugins ignore `raw` nodes but two notable ones don’t:\n *\n * *   `rehype-stringify` also has an option `allowDangerousHtml` which will\n *     output the raw HTML.\n *     This is typically discouraged as noted by the option name but is useful if\n *     you completely trust authors\n * *   `rehype-raw` can handle the raw embedded HTML strings by parsing them\n *     into standard hast nodes (`element`, `text`, etc).\n *     This is a heavy task as it needs a full HTML parser, but it is the only way\n *     to support untrusted content\n *\n * ###### Footnotes\n *\n * Many options supported here relate to footnotes.\n * Footnotes are not specified by CommonMark, which we follow by default.\n * They are supported by GitHub, so footnotes can be enabled in markdown with\n * `remark-gfm`.\n *\n * The options `footnoteBackLabel` and `footnoteLabel` define natural language\n * that explains footnotes, which is hidden for sighted users but shown to\n * assistive technology.\n * When your page is not in English, you must define translated values.\n *\n * Back references use ARIA attributes, but the section label itself uses a\n * heading that is hidden with an `sr-only` class.\n * To show it to sighted users, define different attributes in\n * `footnoteLabelProperties`.\n *\n * ###### Clobbering\n *\n * Footnotes introduces a problem, as it links footnote calls to footnote\n * definitions on the page through `id` attributes generated from user content,\n * which results in DOM clobbering.\n *\n * DOM clobbering is this:\n *\n * ```html\n * <p id=x></p>\n * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>\n * ```\n *\n * Elements by their ID are made available by browsers on the `window` object,\n * which is a security risk.\n * Using a prefix solves this problem.\n *\n * More information on how to handle clobbering and the prefix is explained in\n * *Example: headings (DOM clobbering)* in `rehype-sanitize`.\n *\n * ###### Unknown nodes\n *\n * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.\n * The default behavior for unknown nodes is:\n *\n * *   when the node has a `value` (and doesn’t have `data.hName`,\n *     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`\n *     node\n * *   otherwise, create a `<div>` element (which could be changed with\n *     `data.hName`), with its children mapped from mdast to hast as well\n *\n * This behavior can be changed by passing an `unknownHandler`.\n *\n * @overload\n * @param {Processor} processor\n * @param {Readonly<Options> | null | undefined} [options]\n * @returns {TransformBridge}\n *\n * @overload\n * @param {Readonly<Options> | null | undefined} [options]\n * @returns {TransformMutate}\n *\n * @param {Readonly<Options> | Processor | null | undefined} [destination]\n *   Processor or configuration (optional).\n * @param {Readonly<Options> | null | undefined} [options]\n *   When a processor was given, configuration (optional).\n * @returns {TransformBridge | TransformMutate}\n *   Transform.\n */\nexport default function remarkRehype(destination, options) {\n  if (destination && 'run' in destination) {\n    /**\n     * @type {TransformBridge}\n     */\n    return async function (tree, file) {\n      // Cast because root in -> root out.\n      const hastTree = /** @type {HastRoot} */ (\n        toHast(tree, {file, ...options})\n      )\n      await destination.run(hastTree, file)\n    }\n  }\n\n  /**\n   * @type {TransformMutate}\n   */\n  return function (tree, file) {\n    // Cast because root in -> root out.\n    // To do: in the future, disallow ` || options` fallback.\n    // With `unified-engine`, `destination` can be `undefined` but\n    // `options` will be the file set.\n    // We should not pass that as `options`.\n    return /** @type {HastRoot} */ (\n      toHast(tree, {file, ...(destination || options)})\n    )\n  }\n}\n","/**\n * Throw a given error.\n *\n * @param {Error|null|undefined} [error]\n *   Maybe error.\n * @returns {asserts error is null|undefined}\n */\nexport function bail(error) {\n  if (error) {\n    throw error\n  }\n}\n","export default function isPlainObject(value) {\n\tif (typeof value !== 'object' || value === null) {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\treturn (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);\n}\n","// To do: remove `void`s\n// To do: remove `null` from output of our APIs, allow it as user APIs.\n\n/**\n * @typedef {(error?: Error | null | undefined, ...output: Array<any>) => void} Callback\n *   Callback.\n *\n * @typedef {(...input: Array<any>) => any} Middleware\n *   Ware.\n *\n * @typedef Pipeline\n *   Pipeline.\n * @property {Run} run\n *   Run the pipeline.\n * @property {Use} use\n *   Add middleware.\n *\n * @typedef {(...input: Array<any>) => void} Run\n *   Call all middleware.\n *\n *   Calls `done` on completion with either an error or the output of the\n *   last middleware.\n *\n *   > 👉 **Note**: as the length of input defines whether async functions get a\n *   > `next` function,\n *   > it’s recommended to keep `input` at one value normally.\n\n *\n * @typedef {(fn: Middleware) => Pipeline} Use\n *   Add middleware.\n */\n\n/**\n * Create new middleware.\n *\n * @returns {Pipeline}\n *   Pipeline.\n */\nexport function trough() {\n  /** @type {Array<Middleware>} */\n  const fns = []\n  /** @type {Pipeline} */\n  const pipeline = {run, use}\n\n  return pipeline\n\n  /** @type {Run} */\n  function run(...values) {\n    let middlewareIndex = -1\n    /** @type {Callback} */\n    const callback = values.pop()\n\n    if (typeof callback !== 'function') {\n      throw new TypeError('Expected function as last argument, not ' + callback)\n    }\n\n    next(null, ...values)\n\n    /**\n     * Run the next `fn`, or we’re done.\n     *\n     * @param {Error | null | undefined} error\n     * @param {Array<any>} output\n     */\n    function next(error, ...output) {\n      const fn = fns[++middlewareIndex]\n      let index = -1\n\n      if (error) {\n        callback(error)\n        return\n      }\n\n      // Copy non-nullish input into values.\n      while (++index < values.length) {\n        if (output[index] === null || output[index] === undefined) {\n          output[index] = values[index]\n        }\n      }\n\n      // Save the newly created `output` for the next call.\n      values = output\n\n      // Next or done.\n      if (fn) {\n        wrap(fn, next)(...output)\n      } else {\n        callback(null, ...output)\n      }\n    }\n  }\n\n  /** @type {Use} */\n  function use(middelware) {\n    if (typeof middelware !== 'function') {\n      throw new TypeError(\n        'Expected `middelware` to be a function, not ' + middelware\n      )\n    }\n\n    fns.push(middelware)\n    return pipeline\n  }\n}\n\n/**\n * Wrap `middleware` into a uniform interface.\n *\n * You can pass all input to the resulting function.\n * `callback` is then called with the output of `middleware`.\n *\n * If `middleware` accepts more arguments than the later given in input,\n * an extra `done` function is passed to it after that input,\n * which must be called by `middleware`.\n *\n * The first value in `input` is the main input value.\n * All other input values are the rest input values.\n * The values given to `callback` are the input values,\n * merged with every non-nullish output value.\n *\n * * if `middleware` throws an error,\n *   returns a promise that is rejected,\n *   or calls the given `done` function with an error,\n *   `callback` is called with that error\n * * if `middleware` returns a value or returns a promise that is resolved,\n *   that value is the main output value\n * * if `middleware` calls `done`,\n *   all non-nullish values except for the first one (the error) overwrite the\n *   output values\n *\n * @param {Middleware} middleware\n *   Function to wrap.\n * @param {Callback} callback\n *   Callback called with the output of `middleware`.\n * @returns {Run}\n *   Wrapped middleware.\n */\nexport function wrap(middleware, callback) {\n  /** @type {boolean} */\n  let called\n\n  return wrapped\n\n  /**\n   * Call `middleware`.\n   * @this {any}\n   * @param {Array<any>} parameters\n   * @returns {void}\n   */\n  function wrapped(...parameters) {\n    const fnExpectsCallback = middleware.length > parameters.length\n    /** @type {any} */\n    let result\n\n    if (fnExpectsCallback) {\n      parameters.push(done)\n    }\n\n    try {\n      result = middleware.apply(this, parameters)\n    } catch (error) {\n      const exception = /** @type {Error} */ (error)\n\n      // Well, this is quite the pickle.\n      // `middleware` received a callback and called it synchronously, but that\n      // threw an error.\n      // The only thing left to do is to throw the thing instead.\n      if (fnExpectsCallback && called) {\n        throw exception\n      }\n\n      return done(exception)\n    }\n\n    if (!fnExpectsCallback) {\n      if (result && result.then && typeof result.then === 'function') {\n        result.then(then, done)\n      } else if (result instanceof Error) {\n        done(result)\n      } else {\n        then(result)\n      }\n    }\n  }\n\n  /**\n   * Call `callback`, only once.\n   *\n   * @type {Callback}\n   */\n  function done(error, ...output) {\n    if (!called) {\n      called = true\n      callback(error, ...output)\n    }\n  }\n\n  /**\n   * Call `done` with one value.\n   *\n   * @param {any} [value]\n   */\n  function then(value) {\n    done(null, value)\n  }\n}\n","// A derivative work based on:\n// <https://github.com/browserify/path-browserify>.\n// Which is licensed:\n//\n// MIT License\n//\n// Copyright (c) 2013 James Halliday\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n// subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A derivative work based on:\n//\n// Parts of that are extracted from Node’s internal `path` module:\n// <https://github.com/nodejs/node/blob/master/lib/path.js>.\n// Which is licensed:\n//\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nexport const minpath = {basename, dirname, extname, join, sep: '/'}\n\n/* eslint-disable max-depth, complexity */\n\n/**\n * Get the basename from a path.\n *\n * @param {string} path\n *   File path.\n * @param {string | null | undefined} [extname]\n *   Extension to strip.\n * @returns {string}\n *   Stem or basename.\n */\nfunction basename(path, extname) {\n  if (extname !== undefined && typeof extname !== 'string') {\n    throw new TypeError('\"ext\" argument must be a string')\n  }\n\n  assertPath(path)\n  let start = 0\n  let end = -1\n  let index = path.length\n  /** @type {boolean | undefined} */\n  let seenNonSlash\n\n  if (\n    extname === undefined ||\n    extname.length === 0 ||\n    extname.length > path.length\n  ) {\n    while (index--) {\n      if (path.codePointAt(index) === 47 /* `/` */) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now.\n        if (seenNonSlash) {\n          start = index + 1\n          break\n        }\n      } else if (end < 0) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component.\n        seenNonSlash = true\n        end = index + 1\n      }\n    }\n\n    return end < 0 ? '' : path.slice(start, end)\n  }\n\n  if (extname === path) {\n    return ''\n  }\n\n  let firstNonSlashEnd = -1\n  let extnameIndex = extname.length - 1\n\n  while (index--) {\n    if (path.codePointAt(index) === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (seenNonSlash) {\n        start = index + 1\n        break\n      }\n    } else {\n      if (firstNonSlashEnd < 0) {\n        // We saw the first non-path separator, remember this index in case\n        // we need it if the extension ends up not matching.\n        seenNonSlash = true\n        firstNonSlashEnd = index + 1\n      }\n\n      if (extnameIndex > -1) {\n        // Try to match the explicit extension.\n        if (path.codePointAt(index) === extname.codePointAt(extnameIndex--)) {\n          if (extnameIndex < 0) {\n            // We matched the extension, so mark this as the end of our path\n            // component\n            end = index\n          }\n        } else {\n          // Extension does not match, so our result is the entire path\n          // component\n          extnameIndex = -1\n          end = firstNonSlashEnd\n        }\n      }\n    }\n  }\n\n  if (start === end) {\n    end = firstNonSlashEnd\n  } else if (end < 0) {\n    end = path.length\n  }\n\n  return path.slice(start, end)\n}\n\n/**\n * Get the dirname from a path.\n *\n * @param {string} path\n *   File path.\n * @returns {string}\n *   File path.\n */\nfunction dirname(path) {\n  assertPath(path)\n\n  if (path.length === 0) {\n    return '.'\n  }\n\n  let end = -1\n  let index = path.length\n  /** @type {boolean | undefined} */\n  let unmatchedSlash\n\n  // Prefix `--` is important to not run on `0`.\n  while (--index) {\n    if (path.codePointAt(index) === 47 /* `/` */) {\n      if (unmatchedSlash) {\n        end = index\n        break\n      }\n    } else if (!unmatchedSlash) {\n      // We saw the first non-path separator\n      unmatchedSlash = true\n    }\n  }\n\n  return end < 0\n    ? path.codePointAt(0) === 47 /* `/` */\n      ? '/'\n      : '.'\n    : end === 1 && path.codePointAt(0) === 47 /* `/` */\n      ? '//'\n      : path.slice(0, end)\n}\n\n/**\n * Get an extname from a path.\n *\n * @param {string} path\n *   File path.\n * @returns {string}\n *   Extname.\n */\nfunction extname(path) {\n  assertPath(path)\n\n  let index = path.length\n\n  let end = -1\n  let startPart = 0\n  let startDot = -1\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find.\n  let preDotState = 0\n  /** @type {boolean | undefined} */\n  let unmatchedSlash\n\n  while (index--) {\n    const code = path.codePointAt(index)\n\n    if (code === 47 /* `/` */) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (unmatchedSlash) {\n        startPart = index + 1\n        break\n      }\n\n      continue\n    }\n\n    if (end < 0) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension.\n      unmatchedSlash = true\n      end = index + 1\n    }\n\n    if (code === 46 /* `.` */) {\n      // If this is our first dot, mark it as the start of our extension.\n      if (startDot < 0) {\n        startDot = index\n      } else if (preDotState !== 1) {\n        preDotState = 1\n      }\n    } else if (startDot > -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension.\n      preDotState = -1\n    }\n  }\n\n  if (\n    startDot < 0 ||\n    end < 0 ||\n    // We saw a non-dot character immediately before the dot.\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly `..`.\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    return ''\n  }\n\n  return path.slice(startDot, end)\n}\n\n/**\n * Join segments from a path.\n *\n * @param {Array<string>} segments\n *   Path segments.\n * @returns {string}\n *   File path.\n */\nfunction join(...segments) {\n  let index = -1\n  /** @type {string | undefined} */\n  let joined\n\n  while (++index < segments.length) {\n    assertPath(segments[index])\n\n    if (segments[index]) {\n      joined =\n        joined === undefined ? segments[index] : joined + '/' + segments[index]\n    }\n  }\n\n  return joined === undefined ? '.' : normalize(joined)\n}\n\n/**\n * Normalize a basic file path.\n *\n * @param {string} path\n *   File path.\n * @returns {string}\n *   File path.\n */\n// Note: `normalize` is not exposed as `path.normalize`, so some code is\n// manually removed from it.\nfunction normalize(path) {\n  assertPath(path)\n\n  const absolute = path.codePointAt(0) === 47 /* `/` */\n\n  // Normalize the path according to POSIX rules.\n  let value = normalizeString(path, !absolute)\n\n  if (value.length === 0 && !absolute) {\n    value = '.'\n  }\n\n  if (value.length > 0 && path.codePointAt(path.length - 1) === 47 /* / */) {\n    value += '/'\n  }\n\n  return absolute ? '/' + value : value\n}\n\n/**\n * Resolve `.` and `..` elements in a path with directory names.\n *\n * @param {string} path\n *   File path.\n * @param {boolean} allowAboveRoot\n *   Whether `..` can move above root.\n * @returns {string}\n *   File path.\n */\nfunction normalizeString(path, allowAboveRoot) {\n  let result = ''\n  let lastSegmentLength = 0\n  let lastSlash = -1\n  let dots = 0\n  let index = -1\n  /** @type {number | undefined} */\n  let code\n  /** @type {number} */\n  let lastSlashIndex\n\n  while (++index <= path.length) {\n    if (index < path.length) {\n      code = path.codePointAt(index)\n    } else if (code === 47 /* `/` */) {\n      break\n    } else {\n      code = 47 /* `/` */\n    }\n\n    if (code === 47 /* `/` */) {\n      if (lastSlash === index - 1 || dots === 1) {\n        // Empty.\n      } else if (lastSlash !== index - 1 && dots === 2) {\n        if (\n          result.length < 2 ||\n          lastSegmentLength !== 2 ||\n          result.codePointAt(result.length - 1) !== 46 /* `.` */ ||\n          result.codePointAt(result.length - 2) !== 46 /* `.` */\n        ) {\n          if (result.length > 2) {\n            lastSlashIndex = result.lastIndexOf('/')\n\n            if (lastSlashIndex !== result.length - 1) {\n              if (lastSlashIndex < 0) {\n                result = ''\n                lastSegmentLength = 0\n              } else {\n                result = result.slice(0, lastSlashIndex)\n                lastSegmentLength = result.length - 1 - result.lastIndexOf('/')\n              }\n\n              lastSlash = index\n              dots = 0\n              continue\n            }\n          } else if (result.length > 0) {\n            result = ''\n            lastSegmentLength = 0\n            lastSlash = index\n            dots = 0\n            continue\n          }\n        }\n\n        if (allowAboveRoot) {\n          result = result.length > 0 ? result + '/..' : '..'\n          lastSegmentLength = 2\n        }\n      } else {\n        if (result.length > 0) {\n          result += '/' + path.slice(lastSlash + 1, index)\n        } else {\n          result = path.slice(lastSlash + 1, index)\n        }\n\n        lastSegmentLength = index - lastSlash - 1\n      }\n\n      lastSlash = index\n      dots = 0\n    } else if (code === 46 /* `.` */ && dots > -1) {\n      dots++\n    } else {\n      dots = -1\n    }\n  }\n\n  return result\n}\n\n/**\n * Make sure `path` is a string.\n *\n * @param {string} path\n *   File path.\n * @returns {asserts path is string}\n *   Nothing.\n */\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError(\n      'Path must be a string. Received ' + JSON.stringify(path)\n    )\n  }\n}\n\n/* eslint-enable max-depth, complexity */\n","// Somewhat based on:\n// <https://github.com/defunctzombie/node-process/blob/master/browser.js>.\n// But I don’t think one tiny line of code can be copyrighted. 😅\nexport const minproc = {cwd}\n\nfunction cwd() {\n  return '/'\n}\n","/**\n * Checks if a value has the shape of a WHATWG URL object.\n *\n * Using a symbol or instanceof would not be able to recognize URL objects\n * coming from other implementations (e.g. in Electron), so instead we are\n * checking some well known properties for a lack of a better test.\n *\n * We use `href` and `protocol` as they are the only properties that are\n * easy to retrieve and calculate due to the lazy nature of the getters.\n *\n * We check for auth attribute to distinguish legacy url instance with\n * WHATWG URL instance.\n *\n * @param {unknown} fileUrlOrPath\n *   File path or URL.\n * @returns {fileUrlOrPath is URL}\n *   Whether it’s a URL.\n */\n// From: <https://github.com/nodejs/node/blob/6a3403c/lib/internal/url.js#L720>\nexport function isUrl(fileUrlOrPath) {\n  return Boolean(\n    fileUrlOrPath !== null &&\n      typeof fileUrlOrPath === 'object' &&\n      'href' in fileUrlOrPath &&\n      fileUrlOrPath.href &&\n      'protocol' in fileUrlOrPath &&\n      fileUrlOrPath.protocol &&\n      // @ts-expect-error: indexing is fine.\n      fileUrlOrPath.auth === undefined\n  )\n}\n","import {isUrl} from './minurl.shared.js'\n\nexport {isUrl} from './minurl.shared.js'\n\n// See: <https://github.com/nodejs/node/blob/6a3403c/lib/internal/url.js>\n\n/**\n * @param {URL | string} path\n *   File URL.\n * @returns {string}\n *   File URL.\n */\nexport function urlToPath(path) {\n  if (typeof path === 'string') {\n    path = new URL(path)\n  } else if (!isUrl(path)) {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError(\n      'The \"path\" argument must be of type string or an instance of URL. Received `' +\n        path +\n        '`'\n    )\n    error.code = 'ERR_INVALID_ARG_TYPE'\n    throw error\n  }\n\n  if (path.protocol !== 'file:') {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError('The URL must be of scheme file')\n    error.code = 'ERR_INVALID_URL_SCHEME'\n    throw error\n  }\n\n  return getPathFromURLPosix(path)\n}\n\n/**\n * Get a path from a POSIX URL.\n *\n * @param {URL} url\n *   URL.\n * @returns {string}\n *   File path.\n */\nfunction getPathFromURLPosix(url) {\n  if (url.hostname !== '') {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError(\n      'File URL host must be \"localhost\" or empty on darwin'\n    )\n    error.code = 'ERR_INVALID_FILE_URL_HOST'\n    throw error\n  }\n\n  const pathname = url.pathname\n  let index = -1\n\n  while (++index < pathname.length) {\n    if (\n      pathname.codePointAt(index) === 37 /* `%` */ &&\n      pathname.codePointAt(index + 1) === 50 /* `2` */\n    ) {\n      const third = pathname.codePointAt(index + 2)\n      if (third === 70 /* `F` */ || third === 102 /* `f` */) {\n        /** @type {NodeJS.ErrnoException} */\n        const error = new TypeError(\n          'File URL path must not include encoded / characters'\n        )\n        error.code = 'ERR_INVALID_FILE_URL_PATH'\n        throw error\n      }\n    }\n  }\n\n  return decodeURIComponent(pathname)\n}\n","/**\n * @import {Node, Point, Position} from 'unist'\n * @import {Options as MessageOptions} from 'vfile-message'\n * @import {Compatible, Data, Map, Options, Value} from 'vfile'\n */\n\n/**\n * @typedef {object & {type: string, position?: Position | undefined}} NodeLike\n */\n\nimport {VFileMessage} from 'vfile-message'\nimport {minpath} from '#minpath'\nimport {minproc} from '#minproc'\nimport {urlToPath, isUrl} from '#minurl'\n\n/**\n * Order of setting (least specific to most), we need this because otherwise\n * `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a\n * stem can be set.\n */\nconst order = /** @type {const} */ ([\n  'history',\n  'path',\n  'basename',\n  'stem',\n  'extname',\n  'dirname'\n])\n\nexport class VFile {\n  /**\n   * Create a new virtual file.\n   *\n   * `options` is treated as:\n   *\n   * *   `string` or `Uint8Array` — `{value: options}`\n   * *   `URL` — `{path: options}`\n   * *   `VFile` — shallow copies its data over to the new file\n   * *   `object` — all fields are shallow copied over to the new file\n   *\n   * Path related fields are set in the following order (least specific to\n   * most specific): `history`, `path`, `basename`, `stem`, `extname`,\n   * `dirname`.\n   *\n   * You cannot set `dirname` or `extname` without setting either `history`,\n   * `path`, `basename`, or `stem` too.\n   *\n   * @param {Compatible | null | undefined} [value]\n   *   File value.\n   * @returns\n   *   New instance.\n   */\n  constructor(value) {\n    /** @type {Options | VFile} */\n    let options\n\n    if (!value) {\n      options = {}\n    } else if (isUrl(value)) {\n      options = {path: value}\n    } else if (typeof value === 'string' || isUint8Array(value)) {\n      options = {value}\n    } else {\n      options = value\n    }\n\n    /* eslint-disable no-unused-expressions */\n\n    /**\n     * Base of `path` (default: `process.cwd()` or `'/'` in browsers).\n     *\n     * @type {string}\n     */\n    // Prevent calling `cwd` (which could be expensive) if it’s not needed;\n    // the empty string will be overridden in the next block.\n    this.cwd = 'cwd' in options ? '' : minproc.cwd()\n\n    /**\n     * Place to store custom info (default: `{}`).\n     *\n     * It’s OK to store custom data directly on the file but moving it to\n     * `data` is recommended.\n     *\n     * @type {Data}\n     */\n    this.data = {}\n\n    /**\n     * List of file paths the file moved between.\n     *\n     * The first is the original path and the last is the current path.\n     *\n     * @type {Array<string>}\n     */\n    this.history = []\n\n    /**\n     * List of messages associated with the file.\n     *\n     * @type {Array<VFileMessage>}\n     */\n    this.messages = []\n\n    /**\n     * Raw value.\n     *\n     * @type {Value}\n     */\n    this.value\n\n    // The below are non-standard, they are “well-known”.\n    // As in, used in several tools.\n    /**\n     * Source map.\n     *\n     * This type is equivalent to the `RawSourceMap` type from the `source-map`\n     * module.\n     *\n     * @type {Map | null | undefined}\n     */\n    this.map\n\n    /**\n     * Custom, non-string, compiled, representation.\n     *\n     * This is used by unified to store non-string results.\n     * One example is when turning markdown into React nodes.\n     *\n     * @type {unknown}\n     */\n    this.result\n\n    /**\n     * Whether a file was saved to disk.\n     *\n     * This is used by vfile reporters.\n     *\n     * @type {boolean}\n     */\n    this.stored\n    /* eslint-enable no-unused-expressions */\n\n    // Set path related properties in the correct order.\n    let index = -1\n\n    while (++index < order.length) {\n      const field = order[index]\n\n      // Note: we specifically use `in` instead of `hasOwnProperty` to accept\n      // `vfile`s too.\n      if (\n        field in options &&\n        options[field] !== undefined &&\n        options[field] !== null\n      ) {\n        // @ts-expect-error: TS doesn’t understand basic reality.\n        this[field] = field === 'history' ? [...options[field]] : options[field]\n      }\n    }\n\n    /** @type {string} */\n    let field\n\n    // Set non-path related properties.\n    for (field in options) {\n      // @ts-expect-error: fine to set other things.\n      if (!order.includes(field)) {\n        // @ts-expect-error: fine to set other things.\n        this[field] = options[field]\n      }\n    }\n  }\n\n  /**\n   * Get the basename (including extname) (example: `'index.min.js'`).\n   *\n   * @returns {string | undefined}\n   *   Basename.\n   */\n  get basename() {\n    return typeof this.path === 'string'\n      ? minpath.basename(this.path)\n      : undefined\n  }\n\n  /**\n   * Set basename (including extname) (`'index.min.js'`).\n   *\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be nullified (use `file.path = file.dirname` instead).\n   *\n   * @param {string} basename\n   *   Basename.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set basename(basename) {\n    assertNonEmpty(basename, 'basename')\n    assertPart(basename, 'basename')\n    this.path = minpath.join(this.dirname || '', basename)\n  }\n\n  /**\n   * Get the parent path (example: `'~'`).\n   *\n   * @returns {string | undefined}\n   *   Dirname.\n   */\n  get dirname() {\n    return typeof this.path === 'string'\n      ? minpath.dirname(this.path)\n      : undefined\n  }\n\n  /**\n   * Set the parent path (example: `'~'`).\n   *\n   * Cannot be set if there’s no `path` yet.\n   *\n   * @param {string | undefined} dirname\n   *   Dirname.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set dirname(dirname) {\n    assertPath(this.basename, 'dirname')\n    this.path = minpath.join(dirname || '', this.basename)\n  }\n\n  /**\n   * Get the extname (including dot) (example: `'.js'`).\n   *\n   * @returns {string | undefined}\n   *   Extname.\n   */\n  get extname() {\n    return typeof this.path === 'string'\n      ? minpath.extname(this.path)\n      : undefined\n  }\n\n  /**\n   * Set the extname (including dot) (example: `'.js'`).\n   *\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be set if there’s no `path` yet.\n   *\n   * @param {string | undefined} extname\n   *   Extname.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set extname(extname) {\n    assertPart(extname, 'extname')\n    assertPath(this.dirname, 'extname')\n\n    if (extname) {\n      if (extname.codePointAt(0) !== 46 /* `.` */) {\n        throw new Error('`extname` must start with `.`')\n      }\n\n      if (extname.includes('.', 1)) {\n        throw new Error('`extname` cannot contain multiple dots')\n      }\n    }\n\n    this.path = minpath.join(this.dirname, this.stem + (extname || ''))\n  }\n\n  /**\n   * Get the full path (example: `'~/index.min.js'`).\n   *\n   * @returns {string}\n   *   Path.\n   */\n  get path() {\n    return this.history[this.history.length - 1]\n  }\n\n  /**\n   * Set the full path (example: `'~/index.min.js'`).\n   *\n   * Cannot be nullified.\n   * You can set a file URL (a `URL` object with a `file:` protocol) which will\n   * be turned into a path with `url.fileURLToPath`.\n   *\n   * @param {URL | string} path\n   *   Path.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set path(path) {\n    if (isUrl(path)) {\n      path = urlToPath(path)\n    }\n\n    assertNonEmpty(path, 'path')\n\n    if (this.path !== path) {\n      this.history.push(path)\n    }\n  }\n\n  /**\n   * Get the stem (basename w/o extname) (example: `'index.min'`).\n   *\n   * @returns {string | undefined}\n   *   Stem.\n   */\n  get stem() {\n    return typeof this.path === 'string'\n      ? minpath.basename(this.path, this.extname)\n      : undefined\n  }\n\n  /**\n   * Set the stem (basename w/o extname) (example: `'index.min'`).\n   *\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be nullified (use `file.path = file.dirname` instead).\n   *\n   * @param {string} stem\n   *   Stem.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set stem(stem) {\n    assertNonEmpty(stem, 'stem')\n    assertPart(stem, 'stem')\n    this.path = minpath.join(this.dirname || '', stem + (this.extname || ''))\n  }\n\n  // Normal prototypal methods.\n  /**\n   * Create a fatal message for `reason` associated with the file.\n   *\n   * The `fatal` field of the message is set to `true` (error; file not usable)\n   * and the `file` field is set to the current file path.\n   * The message is added to the `messages` field on `file`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {MessageOptions | null | undefined} [options]\n   * @returns {never}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {never}\n   *   Never.\n   * @throws {VFileMessage}\n   *   Message.\n   */\n  fail(causeOrReason, optionsOrParentOrPlace, origin) {\n    // @ts-expect-error: the overloads are fine.\n    const message = this.message(causeOrReason, optionsOrParentOrPlace, origin)\n\n    message.fatal = true\n\n    throw message\n  }\n\n  /**\n   * Create an info message for `reason` associated with the file.\n   *\n   * The `fatal` field of the message is set to `undefined` (info; change\n   * likely not needed) and the `file` field is set to the current file path.\n   * The message is added to the `messages` field on `file`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {MessageOptions | null | undefined} [options]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  info(causeOrReason, optionsOrParentOrPlace, origin) {\n    // @ts-expect-error: the overloads are fine.\n    const message = this.message(causeOrReason, optionsOrParentOrPlace, origin)\n\n    message.fatal = undefined\n\n    return message\n  }\n\n  /**\n   * Create a message for `reason` associated with the file.\n   *\n   * The `fatal` field of the message is set to `false` (warning; change may be\n   * needed) and the `file` field is set to the current file path.\n   * The message is added to the `messages` field on `file`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {MessageOptions | null | undefined} [options]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  message(causeOrReason, optionsOrParentOrPlace, origin) {\n    const message = new VFileMessage(\n      // @ts-expect-error: the overloads are fine.\n      causeOrReason,\n      optionsOrParentOrPlace,\n      origin\n    )\n\n    if (this.path) {\n      message.name = this.path + ':' + message.name\n      message.file = this.path\n    }\n\n    message.fatal = false\n\n    this.messages.push(message)\n\n    return message\n  }\n\n  /**\n   * Serialize the file.\n   *\n   * > **Note**: which encodings are supported depends on the engine.\n   * > For info on Node.js, see:\n   * > <https://nodejs.org/api/util.html#whatwg-supported-encodings>.\n   *\n   * @param {string | null | undefined} [encoding='utf8']\n   *   Character encoding to understand `value` as when it’s a `Uint8Array`\n   *   (default: `'utf-8'`).\n   * @returns {string}\n   *   Serialized file.\n   */\n  toString(encoding) {\n    if (this.value === undefined) {\n      return ''\n    }\n\n    if (typeof this.value === 'string') {\n      return this.value\n    }\n\n    const decoder = new TextDecoder(encoding || undefined)\n    return decoder.decode(this.value)\n  }\n}\n\n/**\n * Assert that `part` is not a path (as in, does not contain `path.sep`).\n *\n * @param {string | null | undefined} part\n *   File path part.\n * @param {string} name\n *   Part name.\n * @returns {undefined}\n *   Nothing.\n */\nfunction assertPart(part, name) {\n  if (part && part.includes(minpath.sep)) {\n    throw new Error(\n      '`' + name + '` cannot be a path: did not expect `' + minpath.sep + '`'\n    )\n  }\n}\n\n/**\n * Assert that `part` is not empty.\n *\n * @param {string | undefined} part\n *   Thing.\n * @param {string} name\n *   Part name.\n * @returns {asserts part is string}\n *   Nothing.\n */\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty')\n  }\n}\n\n/**\n * Assert `path` exists.\n *\n * @param {string | undefined} path\n *   Path.\n * @param {string} name\n *   Dependency name.\n * @returns {asserts path is string}\n *   Nothing.\n */\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too')\n  }\n}\n\n/**\n * Assert `value` is an `Uint8Array`.\n *\n * @param {unknown} value\n *   thing.\n * @returns {value is Uint8Array}\n *   Whether `value` is an `Uint8Array`.\n */\nfunction isUint8Array(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'byteLength' in value &&\n      'byteOffset' in value\n  )\n}\n","export const CallableInstance =\n  /**\n   * @type {new <Parameters extends Array<unknown>, Result>(property: string | symbol) => (...parameters: Parameters) => Result}\n   */\n  (\n    /** @type {unknown} */\n    (\n      /**\n       * @this {Function}\n       * @param {string | symbol} property\n       * @returns {(...parameters: Array<unknown>) => unknown}\n       */\n      function (property) {\n        const self = this\n        const constr = self.constructor\n        const proto = /** @type {Record<string | symbol, Function>} */ (\n          // Prototypes do exist.\n          // type-coverage:ignore-next-line\n          constr.prototype\n        )\n        const value = proto[property]\n        /** @type {(...parameters: Array<unknown>) => unknown} */\n        const apply = function () {\n          return value.apply(apply, arguments)\n        }\n\n        Object.setPrototypeOf(apply, proto)\n\n        // Not needed for us in `unified`: we only call this on the `copy`\n        // function,\n        // and we don't need to add its fields (`length`, `name`)\n        // over.\n        // See also: GH-246.\n        // const names = Object.getOwnPropertyNames(value)\n        //\n        // for (const p of names) {\n        //   const descriptor = Object.getOwnPropertyDescriptor(value, p)\n        //   if (descriptor) Object.defineProperty(apply, p, descriptor)\n        // }\n\n        return apply\n      }\n    )\n  )\n","/**\n * @typedef {import('trough').Pipeline} Pipeline\n *\n * @typedef {import('unist').Node} Node\n *\n * @typedef {import('vfile').Compatible} Compatible\n * @typedef {import('vfile').Value} Value\n *\n * @typedef {import('../index.js').CompileResultMap} CompileResultMap\n * @typedef {import('../index.js').Data} Data\n * @typedef {import('../index.js').Settings} Settings\n */\n\n/**\n * @typedef {CompileResultMap[keyof CompileResultMap]} CompileResults\n *   Acceptable results from compilers.\n *\n *   To register custom results, add them to\n *   {@linkcode CompileResultMap}.\n */\n\n/**\n * @template {Node} [Tree=Node]\n *   The node that the compiler receives (default: `Node`).\n * @template {CompileResults} [Result=CompileResults]\n *   The thing that the compiler yields (default: `CompileResults`).\n * @callback Compiler\n *   A **compiler** handles the compiling of a syntax tree to something else\n *   (in most cases, text) (TypeScript type).\n *\n *   It is used in the stringify phase and called with a {@linkcode Node}\n *   and {@linkcode VFile} representation of the document to compile.\n *   It should return the textual representation of the given tree (typically\n *   `string`).\n *\n *   > **Note**: unified typically compiles by serializing: most compilers\n *   > return `string` (or `Uint8Array`).\n *   > Some compilers, such as the one configured with\n *   > [`rehype-react`][rehype-react], return other values (in this case, a\n *   > React tree).\n *   > If you’re using a compiler that doesn’t serialize, expect different\n *   > result values.\n *   >\n *   > To register custom results in TypeScript, add them to\n *   > {@linkcode CompileResultMap}.\n *\n *   [rehype-react]: https://github.com/rehypejs/rehype-react\n * @param {Tree} tree\n *   Tree to compile.\n * @param {VFile} file\n *   File associated with `tree`.\n * @returns {Result}\n *   New content: compiled text (`string` or `Uint8Array`, for `file.value`) or\n *   something else (for `file.result`).\n */\n\n/**\n * @template {Node} [Tree=Node]\n *   The node that the parser yields (default: `Node`)\n * @callback Parser\n *   A **parser** handles the parsing of text to a syntax tree.\n *\n *   It is used in the parse phase and is called with a `string` and\n *   {@linkcode VFile} of the document to parse.\n *   It must return the syntax tree representation of the given file\n *   ({@linkcode Node}).\n * @param {string} document\n *   Document to parse.\n * @param {VFile} file\n *   File associated with `document`.\n * @returns {Tree}\n *   Node representing the given file.\n */\n\n/**\n * @typedef {(\n *   Plugin<Array<any>, any, any> |\n *   PluginTuple<Array<any>, any, any> |\n *   Preset\n * )} Pluggable\n *   Union of the different ways to add plugins and settings.\n */\n\n/**\n * @typedef {Array<Pluggable>} PluggableList\n *   List of plugins and presets.\n */\n\n// Note: we can’t use `callback` yet as it messes up `this`:\n//  <https://github.com/microsoft/TypeScript/issues/55197>.\n/**\n * @template {Array<unknown>} [PluginParameters=[]]\n *   Arguments passed to the plugin (default: `[]`, the empty tuple).\n * @template {Node | string | undefined} [Input=Node]\n *   Value that is expected as input (default: `Node`).\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node it expects.\n *   *   If the plugin sets a {@linkcode Parser}, this should be\n *       `string`.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be the\n *       node it expects.\n * @template [Output=Input]\n *   Value that is yielded as output (default: `Input`).\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node that that yields.\n *   *   If the plugin sets a {@linkcode Parser}, this should be the\n *       node that it yields.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be\n *       result it yields.\n * @typedef {(\n *   (this: Processor, ...parameters: PluginParameters) =>\n *     Input extends string ? // Parser.\n *        Output extends Node | undefined ? undefined | void : never :\n *     Output extends CompileResults ? // Compiler.\n *        Input extends Node | undefined ? undefined | void : never :\n *     Transformer<\n *       Input extends Node ? Input : Node,\n *       Output extends Node ? Output : Node\n *     > | undefined | void\n * )} Plugin\n *   Single plugin.\n *\n *   Plugins configure the processors they are applied on in the following\n *   ways:\n *\n *   *   they change the processor, such as the parser, the compiler, or by\n *       configuring data\n *   *   they specify how to handle trees and files\n *\n *   In practice, they are functions that can receive options and configure the\n *   processor (`this`).\n *\n *   > **Note**: plugins are called when the processor is *frozen*, not when\n *   > they are applied.\n */\n\n/**\n * Tuple of a plugin and its configuration.\n *\n * The first item is a plugin, the rest are its parameters.\n *\n * @template {Array<unknown>} [TupleParameters=[]]\n *   Arguments passed to the plugin (default: `[]`, the empty tuple).\n * @template {Node | string | undefined} [Input=undefined]\n *   Value that is expected as input (optional).\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node it expects.\n *   *   If the plugin sets a {@linkcode Parser}, this should be\n *       `string`.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be the\n *       node it expects.\n * @template [Output=undefined] (optional).\n *   Value that is yielded as output.\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node that that yields.\n *   *   If the plugin sets a {@linkcode Parser}, this should be the\n *       node that it yields.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be\n *       result it yields.\n * @typedef {(\n *   [\n *     plugin: Plugin<TupleParameters, Input, Output>,\n *     ...parameters: TupleParameters\n *   ]\n * )} PluginTuple\n */\n\n/**\n * @typedef Preset\n *   Sharable configuration.\n *\n *   They can contain plugins and settings.\n * @property {PluggableList | undefined} [plugins]\n *   List of plugins and presets (optional).\n * @property {Settings | undefined} [settings]\n *   Shared settings for parsers and compilers (optional).\n */\n\n/**\n * @template {VFile} [File=VFile]\n *   The file that the callback receives (default: `VFile`).\n * @callback ProcessCallback\n *   Callback called when the process is done.\n *\n *   Called with either an error or a result.\n * @param {Error | undefined} [error]\n *   Fatal error (optional).\n * @param {File | undefined} [file]\n *   Processed file (optional).\n * @returns {undefined}\n *   Nothing.\n */\n\n/**\n * @template {Node} [Tree=Node]\n *   The tree that the callback receives (default: `Node`).\n * @callback RunCallback\n *   Callback called when transformers are done.\n *\n *   Called with either an error or results.\n * @param {Error | undefined} [error]\n *   Fatal error (optional).\n * @param {Tree | undefined} [tree]\n *   Transformed tree (optional).\n * @param {VFile | undefined} [file]\n *   File (optional).\n * @returns {undefined}\n *   Nothing.\n */\n\n/**\n * @template {Node} [Output=Node]\n *   Node type that the transformer yields (default: `Node`).\n * @callback TransformCallback\n *   Callback passed to transforms.\n *\n *   If the signature of a `transformer` accepts a third argument, the\n *   transformer may perform asynchronous operations, and must call it.\n * @param {Error | undefined} [error]\n *   Fatal error to stop the process (optional).\n * @param {Output | undefined} [tree]\n *   New, changed, tree (optional).\n * @param {VFile | undefined} [file]\n *   New, changed, file (optional).\n * @returns {undefined}\n *   Nothing.\n */\n\n/**\n * @template {Node} [Input=Node]\n *   Node type that the transformer expects (default: `Node`).\n * @template {Node} [Output=Input]\n *   Node type that the transformer yields (default: `Input`).\n * @callback Transformer\n *   Transformers handle syntax trees and files.\n *\n *   They are functions that are called each time a syntax tree and file are\n *   passed through the run phase.\n *   When an error occurs in them (either because it’s thrown, returned,\n *   rejected, or passed to `next`), the process stops.\n *\n *   The run phase is handled by [`trough`][trough], see its documentation for\n *   the exact semantics of these functions.\n *\n *   > **Note**: you should likely ignore `next`: don’t accept it.\n *   > it supports callback-style async work.\n *   > But promises are likely easier to reason about.\n *\n *   [trough]: https://github.com/wooorm/trough#function-fninput-next\n * @param {Input} tree\n *   Tree to handle.\n * @param {VFile} file\n *   File to handle.\n * @param {TransformCallback<Output>} next\n *   Callback.\n * @returns {(\n *   Promise<Output | undefined | void> |\n *   Promise<never> | // For some reason this is needed separately.\n *   Output |\n *   Error |\n *   undefined |\n *   void\n * )}\n *   If you accept `next`, nothing.\n *   Otherwise:\n *\n *   *   `Error` — fatal error to stop the process\n *   *   `Promise<undefined>` or `undefined` — the next transformer keeps using\n *       same tree\n *   *   `Promise<Node>` or `Node` — new, changed, tree\n */\n\n/**\n * @template {Node | undefined} ParseTree\n *   Output of `parse`.\n * @template {Node | undefined} HeadTree\n *   Input for `run`.\n * @template {Node | undefined} TailTree\n *   Output for `run`.\n * @template {Node | undefined} CompileTree\n *   Input of `stringify`.\n * @template {CompileResults | undefined} CompileResult\n *   Output of `stringify`.\n * @template {Node | string | undefined} Input\n *   Input of plugin.\n * @template Output\n *   Output of plugin (optional).\n * @typedef {(\n *   Input extends string\n *     ? Output extends Node | undefined\n *       ? // Parser.\n *         Processor<\n *           Output extends undefined ? ParseTree : Output,\n *           HeadTree,\n *           TailTree,\n *           CompileTree,\n *           CompileResult\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : Output extends CompileResults\n *     ? Input extends Node | undefined\n *       ? // Compiler.\n *         Processor<\n *           ParseTree,\n *           HeadTree,\n *           TailTree,\n *           Input extends undefined ? CompileTree : Input,\n *           Output extends undefined ? CompileResult : Output\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : Input extends Node | undefined\n *     ? Output extends Node | undefined\n *       ? // Transform.\n *         Processor<\n *           ParseTree,\n *           HeadTree extends undefined ? Input : HeadTree,\n *           Output extends undefined ? TailTree : Output,\n *           CompileTree,\n *           CompileResult\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : // Unknown.\n *       Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n * )} UsePlugin\n *   Create a processor based on the input/output of a {@link Plugin plugin}.\n */\n\n/**\n * @template {CompileResults | undefined} Result\n *   Node type that the transformer yields.\n * @typedef {(\n *   Result extends Value | undefined ?\n *     VFile :\n *     VFile & {result: Result}\n *   )} VFileWithOutput\n *   Type to generate a {@linkcode VFile} corresponding to a compiler result.\n *\n *   If a result that is not acceptable on a `VFile` is used, that will\n *   be stored on the `result` field of {@linkcode VFile}.\n */\n\nimport {bail} from 'bail'\nimport extend from 'extend'\nimport {ok as assert} from 'devlop'\nimport isPlainObj from 'is-plain-obj'\nimport {trough} from 'trough'\nimport {VFile} from 'vfile'\nimport {CallableInstance} from './callable-instance.js'\n\n// To do: next major: drop `Compiler`, `Parser`: prefer lowercase.\n\n// To do: we could start yielding `never` in TS when a parser is missing and\n// `parse` is called.\n// Currently, we allow directly setting `processor.parser`, which is untyped.\n\nconst own = {}.hasOwnProperty\n\n/**\n * @template {Node | undefined} [ParseTree=undefined]\n *   Output of `parse` (optional).\n * @template {Node | undefined} [HeadTree=undefined]\n *   Input for `run` (optional).\n * @template {Node | undefined} [TailTree=undefined]\n *   Output for `run` (optional).\n * @template {Node | undefined} [CompileTree=undefined]\n *   Input of `stringify` (optional).\n * @template {CompileResults | undefined} [CompileResult=undefined]\n *   Output of `stringify` (optional).\n * @extends {CallableInstance<[], Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>>}\n */\nexport class Processor extends CallableInstance {\n  /**\n   * Create a processor.\n   */\n  constructor() {\n    // If `Processor()` is called (w/o new), `copy` is called instead.\n    super('copy')\n\n    /**\n     * Compiler to use (deprecated).\n     *\n     * @deprecated\n     *   Use `compiler` instead.\n     * @type {(\n     *   Compiler<\n     *     CompileTree extends undefined ? Node : CompileTree,\n     *     CompileResult extends undefined ? CompileResults : CompileResult\n     *   > |\n     *   undefined\n     * )}\n     */\n    this.Compiler = undefined\n\n    /**\n     * Parser to use (deprecated).\n     *\n     * @deprecated\n     *   Use `parser` instead.\n     * @type {(\n     *   Parser<ParseTree extends undefined ? Node : ParseTree> |\n     *   undefined\n     * )}\n     */\n    this.Parser = undefined\n\n    // Note: the following fields are considered private.\n    // However, they are needed for tests, and TSC generates an untyped\n    // `private freezeIndex` field for, which trips `type-coverage` up.\n    // Instead, we use `@deprecated` to visualize that they shouldn’t be used.\n    /**\n     * Internal list of configured plugins.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Array<PluginTuple<Array<unknown>>>}\n     */\n    this.attachers = []\n\n    /**\n     * Compiler to use.\n     *\n     * @type {(\n     *   Compiler<\n     *     CompileTree extends undefined ? Node : CompileTree,\n     *     CompileResult extends undefined ? CompileResults : CompileResult\n     *   > |\n     *   undefined\n     * )}\n     */\n    this.compiler = undefined\n\n    /**\n     * Internal state to track where we are while freezing.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {number}\n     */\n    this.freezeIndex = -1\n\n    /**\n     * Internal state to track whether we’re frozen.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {boolean | undefined}\n     */\n    this.frozen = undefined\n\n    /**\n     * Internal state.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Data}\n     */\n    this.namespace = {}\n\n    /**\n     * Parser to use.\n     *\n     * @type {(\n     *   Parser<ParseTree extends undefined ? Node : ParseTree> |\n     *   undefined\n     * )}\n     */\n    this.parser = undefined\n\n    /**\n     * Internal list of configured transformers.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Pipeline}\n     */\n    this.transformers = trough()\n  }\n\n  /**\n   * Copy a processor.\n   *\n   * @deprecated\n   *   This is a private internal method and should not be used.\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   New *unfrozen* processor ({@linkcode Processor}) that is\n   *   configured to work the same as its ancestor.\n   *   When the descendant processor is configured in the future it does not\n   *   affect the ancestral processor.\n   */\n  copy() {\n    // Cast as the type parameters will be the same after attaching.\n    const destination =\n      /** @type {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>} */ (\n        new Processor()\n      )\n    let index = -1\n\n    while (++index < this.attachers.length) {\n      const attacher = this.attachers[index]\n      destination.use(...attacher)\n    }\n\n    destination.data(extend(true, {}, this.namespace))\n\n    return destination\n  }\n\n  /**\n   * Configure the processor with info available to all plugins.\n   * Information is stored in an object.\n   *\n   * Typically, options can be given to a specific plugin, but sometimes it\n   * makes sense to have information shared with several plugins.\n   * For example, a list of HTML elements that are self-closing, which is\n   * needed during all phases.\n   *\n   * > **Note**: setting information cannot occur on *frozen* processors.\n   * > Call the processor first to create a new unfrozen processor.\n   *\n   * > **Note**: to register custom data in TypeScript, augment the\n   * > {@linkcode Data} interface.\n   *\n   * @example\n   *   This example show how to get and set info:\n   *\n   *   ```js\n   *   import {unified} from 'unified'\n   *\n   *   const processor = unified().data('alpha', 'bravo')\n   *\n   *   processor.data('alpha') // => 'bravo'\n   *\n   *   processor.data() // => {alpha: 'bravo'}\n   *\n   *   processor.data({charlie: 'delta'})\n   *\n   *   processor.data() // => {charlie: 'delta'}\n   *   ```\n   *\n   * @template {keyof Data} Key\n   *\n   * @overload\n   * @returns {Data}\n   *\n   * @overload\n   * @param {Data} dataset\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {Key} key\n   * @returns {Data[Key]}\n   *\n   * @overload\n   * @param {Key} key\n   * @param {Data[Key]} value\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @param {Data | Key} [key]\n   *   Key to get or set, or entire dataset to set, or nothing to get the\n   *   entire dataset (optional).\n   * @param {Data[Key]} [value]\n   *   Value to set (optional).\n   * @returns {unknown}\n   *   The current processor when setting, the value at `key` when getting, or\n   *   the entire dataset when getting without key.\n   */\n  data(key, value) {\n    if (typeof key === 'string') {\n      // Set `key`.\n      if (arguments.length === 2) {\n        assertUnfrozen('data', this.frozen)\n        this.namespace[key] = value\n        return this\n      }\n\n      // Get `key`.\n      return (own.call(this.namespace, key) && this.namespace[key]) || undefined\n    }\n\n    // Set space.\n    if (key) {\n      assertUnfrozen('data', this.frozen)\n      this.namespace = key\n      return this\n    }\n\n    // Get space.\n    return this.namespace\n  }\n\n  /**\n   * Freeze a processor.\n   *\n   * Frozen processors are meant to be extended and not to be configured\n   * directly.\n   *\n   * When a processor is frozen it cannot be unfrozen.\n   * New processors working the same way can be created by calling the\n   * processor.\n   *\n   * It’s possible to freeze processors explicitly by calling `.freeze()`.\n   * Processors freeze automatically when `.parse()`, `.run()`, `.runSync()`,\n   * `.stringify()`, `.process()`, or `.processSync()` are called.\n   *\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   The current processor.\n   */\n  freeze() {\n    if (this.frozen) {\n      return this\n    }\n\n    // Cast so that we can type plugins easier.\n    // Plugins are supposed to be usable on different processors, not just on\n    // this exact processor.\n    const self = /** @type {Processor} */ (/** @type {unknown} */ (this))\n\n    while (++this.freezeIndex < this.attachers.length) {\n      const [attacher, ...options] = this.attachers[this.freezeIndex]\n\n      if (options[0] === false) {\n        continue\n      }\n\n      if (options[0] === true) {\n        options[0] = undefined\n      }\n\n      const transformer = attacher.call(self, ...options)\n\n      if (typeof transformer === 'function') {\n        this.transformers.use(transformer)\n      }\n    }\n\n    this.frozen = true\n    this.freezeIndex = Number.POSITIVE_INFINITY\n\n    return this\n  }\n\n  /**\n   * Parse text to a syntax tree.\n   *\n   * > **Note**: `parse` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `parse` performs the parse phase, not the run phase or other\n   * > phases.\n   *\n   * @param {Compatible | undefined} [file]\n   *   file to parse (optional); typically `string` or `VFile`; any value\n   *   accepted as `x` in `new VFile(x)`.\n   * @returns {ParseTree extends undefined ? Node : ParseTree}\n   *   Syntax tree representing `file`.\n   */\n  parse(file) {\n    this.freeze()\n    const realFile = vfile(file)\n    const parser = this.parser || this.Parser\n    assertParser('parse', parser)\n    return parser(String(realFile), realFile)\n  }\n\n  /**\n   * Process the given file as configured on the processor.\n   *\n   * > **Note**: `process` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `process` performs the parse, run, and stringify phases.\n   *\n   * @overload\n   * @param {Compatible | undefined} file\n   * @param {ProcessCallback<VFileWithOutput<CompileResult>>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {Compatible | undefined} [file]\n   * @returns {Promise<VFileWithOutput<CompileResult>>}\n   *\n   * @param {Compatible | undefined} [file]\n   *   File (optional); typically `string` or `VFile`]; any value accepted as\n   *   `x` in `new VFile(x)`.\n   * @param {ProcessCallback<VFileWithOutput<CompileResult>> | undefined} [done]\n   *   Callback (optional).\n   * @returns {Promise<VFile> | undefined}\n   *   Nothing if `done` is given.\n   *   Otherwise a promise, rejected with a fatal error or resolved with the\n   *   processed file.\n   *\n   *   The parsed, transformed, and compiled value is available at\n   *   `file.value` (see note).\n   *\n   *   > **Note**: unified typically compiles by serializing: most\n   *   > compilers return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@linkcode CompileResultMap}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */\n  process(file, done) {\n    const self = this\n\n    this.freeze()\n    assertParser('process', this.parser || this.Parser)\n    assertCompiler('process', this.compiler || this.Compiler)\n\n    return done ? executor(undefined, done) : new Promise(executor)\n\n    // Note: `void`s needed for TS.\n    /**\n     * @param {((file: VFileWithOutput<CompileResult>) => undefined | void) | undefined} resolve\n     * @param {(error: Error | undefined) => undefined | void} reject\n     * @returns {undefined}\n     */\n    function executor(resolve, reject) {\n      const realFile = vfile(file)\n      // Assume `ParseTree` (the result of the parser) matches `HeadTree` (the\n      // input of the first transform).\n      const parseTree =\n        /** @type {HeadTree extends undefined ? Node : HeadTree} */ (\n          /** @type {unknown} */ (self.parse(realFile))\n        )\n\n      self.run(parseTree, realFile, function (error, tree, file) {\n        if (error || !tree || !file) {\n          return realDone(error)\n        }\n\n        // Assume `TailTree` (the output of the last transform) matches\n        // `CompileTree` (the input of the compiler).\n        const compileTree =\n          /** @type {CompileTree extends undefined ? Node : CompileTree} */ (\n            /** @type {unknown} */ (tree)\n          )\n\n        const compileResult = self.stringify(compileTree, file)\n\n        if (looksLikeAValue(compileResult)) {\n          file.value = compileResult\n        } else {\n          file.result = compileResult\n        }\n\n        realDone(error, /** @type {VFileWithOutput<CompileResult>} */ (file))\n      })\n\n      /**\n       * @param {Error | undefined} error\n       * @param {VFileWithOutput<CompileResult> | undefined} [file]\n       * @returns {undefined}\n       */\n      function realDone(error, file) {\n        if (error || !file) {\n          reject(error)\n        } else if (resolve) {\n          resolve(file)\n        } else {\n          assert(done, '`done` is defined if `resolve` is not')\n          done(undefined, file)\n        }\n      }\n    }\n  }\n\n  /**\n   * Process the given file as configured on the processor.\n   *\n   * An error is thrown if asynchronous transforms are configured.\n   *\n   * > **Note**: `processSync` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `processSync` performs the parse, run, and stringify phases.\n   *\n   * @param {Compatible | undefined} [file]\n   *   File (optional); typically `string` or `VFile`; any value accepted as\n   *   `x` in `new VFile(x)`.\n   * @returns {VFileWithOutput<CompileResult>}\n   *   The processed file.\n   *\n   *   The parsed, transformed, and compiled value is available at\n   *   `file.value` (see note).\n   *\n   *   > **Note**: unified typically compiles by serializing: most\n   *   > compilers return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@linkcode CompileResultMap}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */\n  processSync(file) {\n    /** @type {boolean} */\n    let complete = false\n    /** @type {VFileWithOutput<CompileResult> | undefined} */\n    let result\n\n    this.freeze()\n    assertParser('processSync', this.parser || this.Parser)\n    assertCompiler('processSync', this.compiler || this.Compiler)\n\n    this.process(file, realDone)\n    assertDone('processSync', 'process', complete)\n    assert(result, 'we either bailed on an error or have a tree')\n\n    return result\n\n    /**\n     * @type {ProcessCallback<VFileWithOutput<CompileResult>>}\n     */\n    function realDone(error, file) {\n      complete = true\n      bail(error)\n      result = file\n    }\n  }\n\n  /**\n   * Run *transformers* on a syntax tree.\n   *\n   * > **Note**: `run` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `run` performs the run phase, not other phases.\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {Compatible | undefined} file\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {Compatible | undefined} [file]\n   * @returns {Promise<TailTree extends undefined ? Node : TailTree>}\n   *\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   *   Tree to transform and inspect.\n   * @param {(\n   *   RunCallback<TailTree extends undefined ? Node : TailTree> |\n   *   Compatible\n   * )} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} [done]\n   *   Callback (optional).\n   * @returns {Promise<TailTree extends undefined ? Node : TailTree> | undefined}\n   *   Nothing if `done` is given.\n   *   Otherwise, a promise rejected with a fatal error or resolved with the\n   *   transformed tree.\n   */\n  run(tree, file, done) {\n    assertNode(tree)\n    this.freeze()\n\n    const transformers = this.transformers\n\n    if (!done && typeof file === 'function') {\n      done = file\n      file = undefined\n    }\n\n    return done ? executor(undefined, done) : new Promise(executor)\n\n    // Note: `void`s needed for TS.\n    /**\n     * @param {(\n     *   ((tree: TailTree extends undefined ? Node : TailTree) => undefined | void) |\n     *   undefined\n     * )} resolve\n     * @param {(error: Error) => undefined | void} reject\n     * @returns {undefined}\n     */\n    function executor(resolve, reject) {\n      assert(\n        typeof file !== 'function',\n        '`file` can’t be a `done` anymore, we checked'\n      )\n      const realFile = vfile(file)\n      transformers.run(tree, realFile, realDone)\n\n      /**\n       * @param {Error | undefined} error\n       * @param {Node} outputTree\n       * @param {VFile} file\n       * @returns {undefined}\n       */\n      function realDone(error, outputTree, file) {\n        const resultingTree =\n          /** @type {TailTree extends undefined ? Node : TailTree} */ (\n            outputTree || tree\n          )\n\n        if (error) {\n          reject(error)\n        } else if (resolve) {\n          resolve(resultingTree)\n        } else {\n          assert(done, '`done` is defined if `resolve` is not')\n          done(undefined, resultingTree, file)\n        }\n      }\n    }\n  }\n\n  /**\n   * Run *transformers* on a syntax tree.\n   *\n   * An error is thrown if asynchronous transforms are configured.\n   *\n   * > **Note**: `runSync` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `runSync` performs the run phase, not other phases.\n   *\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   *   Tree to transform and inspect.\n   * @param {Compatible | undefined} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @returns {TailTree extends undefined ? Node : TailTree}\n   *   Transformed tree.\n   */\n  runSync(tree, file) {\n    /** @type {boolean} */\n    let complete = false\n    /** @type {(TailTree extends undefined ? Node : TailTree) | undefined} */\n    let result\n\n    this.run(tree, file, realDone)\n\n    assertDone('runSync', 'run', complete)\n    assert(result, 'we either bailed on an error or have a tree')\n    return result\n\n    /**\n     * @type {RunCallback<TailTree extends undefined ? Node : TailTree>}\n     */\n    function realDone(error, tree) {\n      bail(error)\n      result = tree\n      complete = true\n    }\n  }\n\n  /**\n   * Compile a syntax tree.\n   *\n   * > **Note**: `stringify` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `stringify` performs the stringify phase, not the run phase\n   * > or other phases.\n   *\n   * @param {CompileTree extends undefined ? Node : CompileTree} tree\n   *   Tree to compile.\n   * @param {Compatible | undefined} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @returns {CompileResult extends undefined ? Value : CompileResult}\n   *   Textual representation of the tree (see note).\n   *\n   *   > **Note**: unified typically compiles by serializing: most compilers\n   *   > return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@linkcode CompileResultMap}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */\n  stringify(tree, file) {\n    this.freeze()\n    const realFile = vfile(file)\n    const compiler = this.compiler || this.Compiler\n    assertCompiler('stringify', compiler)\n    assertNode(tree)\n\n    return compiler(tree, realFile)\n  }\n\n  /**\n   * Configure the processor to use a plugin, a list of usable values, or a\n   * preset.\n   *\n   * If the processor is already using a plugin, the previous plugin\n   * configuration is changed based on the options that are passed in.\n   * In other words, the plugin is not added a second time.\n   *\n   * > **Note**: `use` cannot be called on *frozen* processors.\n   * > Call the processor first to create a new unfrozen processor.\n   *\n   * @example\n   *   There are many ways to pass plugins to `.use()`.\n   *   This example gives an overview:\n   *\n   *   ```js\n   *   import {unified} from 'unified'\n   *\n   *   unified()\n   *     // Plugin with options:\n   *     .use(pluginA, {x: true, y: true})\n   *     // Passing the same plugin again merges configuration (to `{x: true, y: false, z: true}`):\n   *     .use(pluginA, {y: false, z: true})\n   *     // Plugins:\n   *     .use([pluginB, pluginC])\n   *     // Two plugins, the second with options:\n   *     .use([pluginD, [pluginE, {}]])\n   *     // Preset with plugins and settings:\n   *     .use({plugins: [pluginF, [pluginG, {}]], settings: {position: false}})\n   *     // Settings only:\n   *     .use({settings: {position: false}})\n   *   ```\n   *\n   * @template {Array<unknown>} [Parameters=[]]\n   * @template {Node | string | undefined} [Input=undefined]\n   * @template [Output=Input]\n   *\n   * @overload\n   * @param {Preset | null | undefined} [preset]\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {PluggableList} list\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {Plugin<Parameters, Input, Output>} plugin\n   * @param {...(Parameters | [boolean])} parameters\n   * @returns {UsePlugin<ParseTree, HeadTree, TailTree, CompileTree, CompileResult, Input, Output>}\n   *\n   * @param {PluggableList | Plugin | Preset | null | undefined} value\n   *   Usable value.\n   * @param {...unknown} parameters\n   *   Parameters, when a plugin is given as a usable value.\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   Current processor.\n   */\n  use(value, ...parameters) {\n    const attachers = this.attachers\n    const namespace = this.namespace\n\n    assertUnfrozen('use', this.frozen)\n\n    if (value === null || value === undefined) {\n      // Empty.\n    } else if (typeof value === 'function') {\n      addPlugin(value, parameters)\n    } else if (typeof value === 'object') {\n      if (Array.isArray(value)) {\n        addList(value)\n      } else {\n        addPreset(value)\n      }\n    } else {\n      throw new TypeError('Expected usable value, not `' + value + '`')\n    }\n\n    return this\n\n    /**\n     * @param {Pluggable} value\n     * @returns {undefined}\n     */\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value, [])\n      } else if (typeof value === 'object') {\n        if (Array.isArray(value)) {\n          const [plugin, ...parameters] =\n            /** @type {PluginTuple<Array<unknown>>} */ (value)\n          addPlugin(plugin, parameters)\n        } else {\n          addPreset(value)\n        }\n      } else {\n        throw new TypeError('Expected usable value, not `' + value + '`')\n      }\n    }\n\n    /**\n     * @param {Preset} result\n     * @returns {undefined}\n     */\n    function addPreset(result) {\n      if (!('plugins' in result) && !('settings' in result)) {\n        throw new Error(\n          'Expected usable value but received an empty preset, which is probably a mistake: presets typically come with `plugins` and sometimes with `settings`, but this has neither'\n        )\n      }\n\n      addList(result.plugins)\n\n      if (result.settings) {\n        namespace.settings = extend(true, namespace.settings, result.settings)\n      }\n    }\n\n    /**\n     * @param {PluggableList | null | undefined} plugins\n     * @returns {undefined}\n     */\n    function addList(plugins) {\n      let index = -1\n\n      if (plugins === null || plugins === undefined) {\n        // Empty.\n      } else if (Array.isArray(plugins)) {\n        while (++index < plugins.length) {\n          const thing = plugins[index]\n          add(thing)\n        }\n      } else {\n        throw new TypeError('Expected a list of plugins, not `' + plugins + '`')\n      }\n    }\n\n    /**\n     * @param {Plugin} plugin\n     * @param {Array<unknown>} parameters\n     * @returns {undefined}\n     */\n    function addPlugin(plugin, parameters) {\n      let index = -1\n      let entryIndex = -1\n\n      while (++index < attachers.length) {\n        if (attachers[index][0] === plugin) {\n          entryIndex = index\n          break\n        }\n      }\n\n      if (entryIndex === -1) {\n        attachers.push([plugin, ...parameters])\n      }\n      // Only set if there was at least a `primary` value, otherwise we’d change\n      // `arguments.length`.\n      else if (parameters.length > 0) {\n        let [primary, ...rest] = parameters\n        const currentPrimary = attachers[entryIndex][1]\n        if (isPlainObj(currentPrimary) && isPlainObj(primary)) {\n          primary = extend(true, currentPrimary, primary)\n        }\n\n        attachers[entryIndex] = [plugin, primary, ...rest]\n      }\n    }\n  }\n}\n\n// Note: this returns a *callable* instance.\n// That’s why it’s documented as a function.\n/**\n * Create a new processor.\n *\n * @example\n *   This example shows how a new processor can be created (from `remark`) and linked\n *   to **stdin**(4) and **stdout**(4).\n *\n *   ```js\n *   import process from 'node:process'\n *   import concatStream from 'concat-stream'\n *   import {remark} from 'remark'\n *\n *   process.stdin.pipe(\n *     concatStream(function (buf) {\n *       process.stdout.write(String(remark().processSync(buf)))\n *     })\n *   )\n *   ```\n *\n * @returns\n *   New *unfrozen* processor (`processor`).\n *\n *   This processor is configured to work the same as its ancestor.\n *   When the descendant processor is configured in the future it does not\n *   affect the ancestral processor.\n */\nexport const unified = new Processor().freeze()\n\n/**\n * Assert a parser is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Parser}\n */\nfunction assertParser(name, value) {\n  if (typeof value !== 'function') {\n    throw new TypeError('Cannot `' + name + '` without `parser`')\n  }\n}\n\n/**\n * Assert a compiler is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Compiler}\n */\nfunction assertCompiler(name, value) {\n  if (typeof value !== 'function') {\n    throw new TypeError('Cannot `' + name + '` without `compiler`')\n  }\n}\n\n/**\n * Assert the processor is not frozen.\n *\n * @param {string} name\n * @param {unknown} frozen\n * @returns {asserts frozen is false}\n */\nfunction assertUnfrozen(name, frozen) {\n  if (frozen) {\n    throw new Error(\n      'Cannot call `' +\n        name +\n        '` on a frozen processor.\\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.'\n    )\n  }\n}\n\n/**\n * Assert `node` is a unist node.\n *\n * @param {unknown} node\n * @returns {asserts node is Node}\n */\nfunction assertNode(node) {\n  // `isPlainObj` unfortunately uses `any` instead of `unknown`.\n  // type-coverage:ignore-next-line\n  if (!isPlainObj(node) || typeof node.type !== 'string') {\n    throw new TypeError('Expected node, got `' + node + '`')\n    // Fine.\n  }\n}\n\n/**\n * Assert that `complete` is `true`.\n *\n * @param {string} name\n * @param {string} asyncName\n * @param {unknown} complete\n * @returns {asserts complete is true}\n */\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error(\n      '`' + name + '` finished async. Use `' + asyncName + '` instead'\n    )\n  }\n}\n\n/**\n * @param {Compatible | undefined} [value]\n * @returns {VFile}\n */\nfunction vfile(value) {\n  return looksLikeAVFile(value) ? value : new VFile(value)\n}\n\n/**\n * @param {Compatible | undefined} [value]\n * @returns {value is VFile}\n */\nfunction looksLikeAVFile(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'message' in value &&\n      'messages' in value\n  )\n}\n\n/**\n * @param {unknown} [value]\n * @returns {value is Value}\n */\nfunction looksLikeAValue(value) {\n  return typeof value === 'string' || isUint8Array(value)\n}\n\n/**\n * Assert `value` is an `Uint8Array`.\n *\n * @param {unknown} value\n *   thing.\n * @returns {value is Uint8Array}\n *   Whether `value` is an `Uint8Array`.\n */\nfunction isUint8Array(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'byteLength' in value &&\n      'byteOffset' in value\n  )\n}\n","// Register `Raw` in tree:\n/// <reference types=\"mdast-util-to-hast\" />\n\n/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Nodes} Nodes\n * @typedef {import('hast').Parents} Parents\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast-util-to-jsx-runtime').Components} JsxRuntimeComponents\n * @typedef {import('remark-rehype').Options} RemarkRehypeOptions\n * @typedef {import('unist-util-visit').BuildVisitor<Root>} Visitor\n * @typedef {import('unified').PluggableList} PluggableList\n */\n\n/**\n * @callback AllowElement\n *   Filter elements.\n * @param {Readonly<Element>} element\n *   Element to check.\n * @param {number} index\n *   Index of `element` in `parent`.\n * @param {Readonly<Parents> | undefined} parent\n *   Parent of `element`.\n * @returns {boolean | null | undefined}\n *   Whether to allow `element` (default: `false`).\n *\n * @typedef {Partial<JsxRuntimeComponents>} Components\n *   Map tag names to components.\n *\n * @typedef Deprecation\n *   Deprecation.\n * @property {string} from\n *   Old field.\n * @property {string} id\n *   ID in readme.\n * @property {keyof Options} [to]\n *   New field.\n *\n * @typedef Options\n *   Configuration.\n * @property {AllowElement | null | undefined} [allowElement]\n *   Filter elements (optional);\n *   `allowedElements` / `disallowedElements` is used first.\n * @property {ReadonlyArray<string> | null | undefined} [allowedElements]\n *   Tag names to allow (default: all tag names);\n *   cannot combine w/ `disallowedElements`.\n * @property {string | null | undefined} [children]\n *   Markdown.\n * @property {string | null | undefined} [className]\n *   Wrap in a `div` with this class name.\n * @property {Components | null | undefined} [components]\n *   Map tag names to components.\n * @property {ReadonlyArray<string> | null | undefined} [disallowedElements]\n *   Tag names to disallow (default: `[]`);\n *   cannot combine w/ `allowedElements`.\n * @property {PluggableList | null | undefined} [rehypePlugins]\n *   List of rehype plugins to use.\n * @property {PluggableList | null | undefined} [remarkPlugins]\n *   List of remark plugins to use.\n * @property {Readonly<RemarkRehypeOptions> | null | undefined} [remarkRehypeOptions]\n *   Options to pass through to `remark-rehype`.\n * @property {boolean | null | undefined} [skipHtml=false]\n *   Ignore HTML in markdown completely (default: `false`).\n * @property {boolean | null | undefined} [unwrapDisallowed=false]\n *   Extract (unwrap) what’s in disallowed elements (default: `false`);\n *   normally when say `strong` is not allowed, it and it’s children are dropped,\n *   with `unwrapDisallowed` the element itself is replaced by its children.\n * @property {UrlTransform | null | undefined} [urlTransform]\n *   Change URLs (default: `defaultUrlTransform`)\n *\n * @callback UrlTransform\n *   Transform all URLs.\n * @param {string} url\n *   URL.\n * @param {string} key\n *   Property name (example: `'href'`).\n * @param {Readonly<Element>} node\n *   Node.\n * @returns {string | null | undefined}\n *   Transformed URL (optional).\n */\n\nimport {unreachable} from 'devlop'\nimport {toJsxRuntime} from 'hast-util-to-jsx-runtime'\nimport {urlAttributes} from 'html-url-attributes'\n// @ts-expect-error: untyped.\nimport {Fragment, jsx, jsxs} from 'react/jsx-runtime'\nimport remarkParse from 'remark-parse'\nimport remarkRehype from 'remark-rehype'\nimport {unified} from 'unified'\nimport {visit} from 'unist-util-visit'\nimport {VFile} from 'vfile'\n\nconst changelog =\n  'https://github.com/remarkjs/react-markdown/blob/main/changelog.md'\n\n/** @type {PluggableList} */\nconst emptyPlugins = []\n/** @type {Readonly<RemarkRehypeOptions>} */\nconst emptyRemarkRehypeOptions = {allowDangerousHtml: true}\nconst safeProtocol = /^(https?|ircs?|mailto|xmpp)$/i\n\n// Mutable because we `delete` any time it’s used and a message is sent.\n/** @type {ReadonlyArray<Readonly<Deprecation>>} */\nconst deprecations = [\n  {from: 'astPlugins', id: 'remove-buggy-html-in-markdown-parser'},\n  {from: 'allowDangerousHtml', id: 'remove-buggy-html-in-markdown-parser'},\n  {\n    from: 'allowNode',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes',\n    to: 'allowElement'\n  },\n  {\n    from: 'allowedTypes',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes',\n    to: 'allowedElements'\n  },\n  {\n    from: 'disallowedTypes',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes',\n    to: 'disallowedElements'\n  },\n  {from: 'escapeHtml', id: 'remove-buggy-html-in-markdown-parser'},\n  {from: 'includeElementIndex', id: '#remove-includeelementindex'},\n  {\n    from: 'includeNodeIndex',\n    id: 'change-includenodeindex-to-includeelementindex'\n  },\n  {from: 'linkTarget', id: 'remove-linktarget'},\n  {from: 'plugins', id: 'change-plugins-to-remarkplugins', to: 'remarkPlugins'},\n  {from: 'rawSourcePos', id: '#remove-rawsourcepos'},\n  {from: 'renderers', id: 'change-renderers-to-components', to: 'components'},\n  {from: 'source', id: 'change-source-to-children', to: 'children'},\n  {from: 'sourcePos', id: '#remove-sourcepos'},\n  {from: 'transformImageUri', id: '#add-urltransform', to: 'urlTransform'},\n  {from: 'transformLinkUri', id: '#add-urltransform', to: 'urlTransform'}\n]\n\n/**\n * Component to render markdown.\n *\n * @param {Readonly<Options>} options\n *   Props.\n * @returns {JSX.Element}\n *   React element.\n */\nexport function Markdown(options) {\n  const allowedElements = options.allowedElements\n  const allowElement = options.allowElement\n  const children = options.children || ''\n  const className = options.className\n  const components = options.components\n  const disallowedElements = options.disallowedElements\n  const rehypePlugins = options.rehypePlugins || emptyPlugins\n  const remarkPlugins = options.remarkPlugins || emptyPlugins\n  const remarkRehypeOptions = options.remarkRehypeOptions\n    ? {...options.remarkRehypeOptions, ...emptyRemarkRehypeOptions}\n    : emptyRemarkRehypeOptions\n  const skipHtml = options.skipHtml\n  const unwrapDisallowed = options.unwrapDisallowed\n  const urlTransform = options.urlTransform || defaultUrlTransform\n\n  const processor = unified()\n    .use(remarkParse)\n    .use(remarkPlugins)\n    .use(remarkRehype, remarkRehypeOptions)\n    .use(rehypePlugins)\n\n  const file = new VFile()\n\n  if (typeof children === 'string') {\n    file.value = children\n  } else {\n    unreachable(\n      'Unexpected value `' +\n        children +\n        '` for `children` prop, expected `string`'\n    )\n  }\n\n  if (allowedElements && disallowedElements) {\n    unreachable(\n      'Unexpected combined `allowedElements` and `disallowedElements`, expected one or the other'\n    )\n  }\n\n  for (const deprecation of deprecations) {\n    if (Object.hasOwn(options, deprecation.from)) {\n      unreachable(\n        'Unexpected `' +\n          deprecation.from +\n          '` prop, ' +\n          (deprecation.to\n            ? 'use `' + deprecation.to + '` instead'\n            : 'remove it') +\n          ' (see <' +\n          changelog +\n          '#' +\n          deprecation.id +\n          '> for more info)'\n      )\n    }\n  }\n\n  const mdastTree = processor.parse(file)\n  /** @type {Nodes} */\n  let hastTree = processor.runSync(mdastTree, file)\n\n  // Wrap in `div` if there’s a class name.\n  if (className) {\n    hastTree = {\n      type: 'element',\n      tagName: 'div',\n      properties: {className},\n      // Assume no doctypes.\n      children: /** @type {Array<ElementContent>} */ (\n        hastTree.type === 'root' ? hastTree.children : [hastTree]\n      )\n    }\n  }\n\n  visit(hastTree, transform)\n\n  return toJsxRuntime(hastTree, {\n    Fragment,\n    components,\n    ignoreInvalidStyle: true,\n    jsx,\n    jsxs,\n    passKeys: true,\n    passNode: true\n  })\n\n  /** @type {Visitor} */\n  function transform(node, index, parent) {\n    if (node.type === 'raw' && parent && typeof index === 'number') {\n      if (skipHtml) {\n        parent.children.splice(index, 1)\n      } else {\n        parent.children[index] = {type: 'text', value: node.value}\n      }\n\n      return index\n    }\n\n    if (node.type === 'element') {\n      /** @type {string} */\n      let key\n\n      for (key in urlAttributes) {\n        if (\n          Object.hasOwn(urlAttributes, key) &&\n          Object.hasOwn(node.properties, key)\n        ) {\n          const value = node.properties[key]\n          const test = urlAttributes[key]\n          if (test === null || test.includes(node.tagName)) {\n            node.properties[key] = urlTransform(String(value || ''), key, node)\n          }\n        }\n      }\n    }\n\n    if (node.type === 'element') {\n      let remove = allowedElements\n        ? !allowedElements.includes(node.tagName)\n        : disallowedElements\n        ? disallowedElements.includes(node.tagName)\n        : false\n\n      if (!remove && allowElement && typeof index === 'number') {\n        remove = !allowElement(node, index, parent)\n      }\n\n      if (remove && parent && typeof index === 'number') {\n        if (unwrapDisallowed && node.children) {\n          parent.children.splice(index, 1, ...node.children)\n        } else {\n          parent.children.splice(index, 1)\n        }\n\n        return index\n      }\n    }\n  }\n}\n\n/**\n * Make a URL safe.\n *\n * @satisfies {UrlTransform}\n * @param {string} value\n *   URL.\n * @returns {string}\n *   Safe URL.\n */\nexport function defaultUrlTransform(value) {\n  // Same as:\n  // <https://github.com/micromark/micromark/blob/929275e/packages/micromark-util-sanitize-uri/dev/index.js#L34>\n  // But without the `encode` part.\n  const colon = value.indexOf(':')\n  const questionMark = value.indexOf('?')\n  const numberSign = value.indexOf('#')\n  const slash = value.indexOf('/')\n\n  if (\n    // If there is no protocol, it’s relative.\n    colon < 0 ||\n    // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.\n    (slash > -1 && colon > slash) ||\n    (questionMark > -1 && colon > questionMark) ||\n    (numberSign > -1 && colon > numberSign) ||\n    // It is a protocol, it should be allowed.\n    safeProtocol.test(value.slice(0, colon))\n  ) {\n    return value\n  }\n\n  return ''\n}\n"],"names":["hasOwn","Object","prototype","hasOwnProperty","toStr","toString","defineProperty","gOPD","getOwnPropertyDescriptor","isArray","arr","Array","call","isPlainObject","obj","key","hasOwnConstructor","hasIsPrototypeOf","constructor","setProperty","target","options","name","enumerable","configurable","value","newValue","writable","getProperty","module","exports","extend","src","copy","copyIsArray","clone","arguments","i","length","deep","COMMENT_REGEX","NEWLINE_REGEX","WHITESPACE_REGEX","PROPERTY_REGEX","COLON_REGEX","VALUE_REGEX","SEMICOLON_REGEX","TRIM_REGEX","trim","str","replace","style","lineno","column","updatePosition","lines","match","lastIndexOf","position","start","line","node","Position","end","source","content","errorsList","error","msg","err","reason","filename","silent","push","re","m","exec","slice","comments","rules","c","comment","pos","FORWARD_SLASH","charAt","ASTERISK","EMPTY_STRING","type","declarations","decl","decls","declaration","prop","val","ret","property","__importDefault","mod","__esModule","iterator","styleObject","inline_style_parser_1","default","hasIterator","forEach","__webpack_require__","nameRe","nameReJsx","emptyOptions","lib_name","settings","jsx","test","empty","Schema","normal","space","merge","definitions","index","assign","normalize","toLowerCase","Info","attribute","boolean","booleanish","overloadedBoolean","number","commaSeparated","spaceSeparated","commaOrSpaceSeparated","mustUseProperty","defined","powers","types_boolean","increment","checks","keys","types_namespaceObject","DefinedInfo","mask","values","check","own","create","definition","properties","info","transform","attributes","includes","xlink","_","xLinkActuate","xLinkArcRole","xLinkHref","xLinkRole","xLinkShow","xLinkTitle","xLinkType","xml","xmlLang","xmlBase","xmlSpace","caseSensitiveTransform","caseInsensitiveTransform","xmlns","xmlnsxlink","xmlnsXLink","aria","ariaActiveDescendant","ariaAtomic","ariaAutoComplete","ariaBusy","ariaChecked","ariaColCount","ariaColIndex","ariaColSpan","ariaControls","ariaCurrent","ariaDescribedBy","ariaDetails","ariaDisabled","ariaDropEffect","ariaErrorMessage","ariaExpanded","ariaFlowTo","ariaGrabbed","ariaHasPopup","ariaHidden","ariaInvalid","ariaKeyShortcuts","ariaLabel","ariaLabelledBy","ariaLevel","ariaLive","ariaModal","ariaMultiLine","ariaMultiSelectable","ariaOrientation","ariaOwns","ariaPlaceholder","ariaPosInSet","ariaPressed","ariaReadOnly","ariaRelevant","ariaRequired","ariaRoleDescription","ariaRowCount","ariaRowIndex","ariaRowSpan","ariaSelected","ariaSetSize","ariaSort","ariaValueMax","ariaValueMin","ariaValueNow","ariaValueText","role","html","acceptcharset","classname","htmlfor","httpequiv","abbr","accept","acceptCharset","accessKey","action","allow","allowFullScreen","allowPaymentRequest","allowUserMedia","alt","as","async","autoCapitalize","autoComplete","autoFocus","autoPlay","blocking","capture","charSet","checked","cite","className","cols","colSpan","contentEditable","controls","controlsList","coords","crossOrigin","data","dateTime","decoding","defer","dir","dirName","disabled","download","draggable","encType","enterKeyHint","fetchPriority","form","formAction","formEncType","formMethod","formNoValidate","formTarget","headers","height","hidden","high","href","hrefLang","htmlFor","httpEquiv","id","imageSizes","imageSrcSet","inert","inputMode","integrity","is","isMap","itemId","itemProp","itemRef","itemScope","itemType","kind","label","lang","language","list","loading","loop","low","manifest","max","maxLength","media","method","min","minLength","multiple","muted","nonce","noModule","noValidate","onAbort","onAfterPrint","onAuxClick","onBeforeMatch","onBeforePrint","onBeforeToggle","onBeforeUnload","onBlur","onCancel","onCanPlay","onCanPlayThrough","onChange","onClick","onClose","onContextLost","onContextMenu","onContextRestored","onCopy","onCueChange","onCut","onDblClick","onDrag","onDragEnd","onDragEnter","onDragExit","onDragLeave","onDragOver","onDragStart","onDrop","onDurationChange","onEmptied","onEnded","onError","onFocus","onFormData","onHashChange","onInput","onInvalid","onKeyDown","onKeyPress","onKeyUp","onLanguageChange","onLoad","onLoadedData","onLoadedMetadata","onLoadEnd","onLoadStart","onMessage","onMessageError","onMouseDown","onMouseEnter","onMouseLeave","onMouseMove","onMouseOut","onMouseOver","onMouseUp","onOffline","onOnline","onPageHide","onPageShow","onPaste","onPause","onPlay","onPlaying","onPopState","onProgress","onRateChange","onRejectionHandled","onReset","onResize","onScroll","onScrollEnd","onSecurityPolicyViolation","onSeeked","onSeeking","onSelect","onSlotChange","onStalled","onStorage","onSubmit","onSuspend","onTimeUpdate","onToggle","onUnhandledRejection","onUnload","onVolumeChange","onWaiting","onWheel","open","optimum","pattern","ping","placeholder","playsInline","popover","popoverTarget","popoverTargetAction","poster","preload","readOnly","referrerPolicy","rel","required","reversed","rows","rowSpan","sandbox","scope","scoped","seamless","selected","shadowRootClonable","shadowRootDelegatesFocus","shadowRootMode","shape","size","sizes","slot","span","spellCheck","srcDoc","srcLang","srcSet","step","tabIndex","title","translate","typeMustMatch","useMap","width","wrap","writingSuggestions","align","aLink","archive","axis","background","bgColor","border","borderColor","bottomMargin","cellPadding","cellSpacing","char","charOff","classId","clear","code","codeBase","codeType","color","compact","declare","event","face","frame","frameBorder","hSpace","leftMargin","link","longDesc","lowSrc","marginHeight","marginWidth","noResize","noHref","noShade","noWrap","object","profile","prompt","rev","rightMargin","scheme","scrolling","standby","summary","text","topMargin","valueType","version","vAlign","vLink","vSpace","allowTransparency","autoCorrect","autoSave","disablePictureInPicture","disableRemotePlayback","prefix","results","security","unselectable","svg","accentHeight","alignmentBaseline","arabicForm","baselineShift","capHeight","clipPath","clipRule","colorInterpolation","colorInterpolationFilters","colorProfile","colorRendering","dataType","dominantBaseline","enableBackground","fillOpacity","fillRule","floodColor","floodOpacity","fontFamily","fontSize","fontSizeAdjust","fontStretch","fontStyle","fontVariant","fontWeight","glyphName","glyphOrientationHorizontal","glyphOrientationVertical","horizAdvX","horizOriginX","horizOriginY","imageRendering","letterSpacing","lightingColor","markerEnd","markerMid","markerStart","navDown","navDownLeft","navDownRight","navLeft","navNext","navPrev","navRight","navUp","navUpLeft","navUpRight","onActivate","onBegin","onEnd","onFocusIn","onFocusOut","onMouseWheel","onRepeat","onShow","onZoom","overlinePosition","overlineThickness","paintOrder","panose1","pointerEvents","renderingIntent","shapeRendering","stopColor","stopOpacity","strikethroughPosition","strikethroughThickness","strokeDashArray","strokeDashOffset","strokeLineCap","strokeLineJoin","strokeMiterLimit","strokeOpacity","strokeWidth","textAnchor","textDecoration","textRendering","transformOrigin","typeOf","underlinePosition","underlineThickness","unicodeBidi","unicodeRange","unitsPerEm","vAlphabetic","vHanging","vIdeographic","vMathematical","vectorEffect","vertAdvY","vertOriginX","vertOriginY","wordSpacing","writingMode","xHeight","playbackOrder","timelineBegin","about","accumulate","additive","alphabetic","amplitude","ascent","attributeName","attributeType","azimuth","bandwidth","baseFrequency","baseProfile","bbox","begin","bias","by","calcMode","clip","clipPathUnits","contentScriptType","contentStyleType","cursor","cx","cy","d","defaultAction","descent","diffuseConstant","direction","display","dur","divisor","dx","dy","edgeMode","editable","elevation","exponent","externalResourcesRequired","fill","filter","filterRes","filterUnits","focusable","focusHighlight","format","fr","from","fx","fy","g1","g2","glyphRef","gradientTransform","gradientUnits","handler","hanging","hatchContentUnits","hatchUnits","ideographic","initialVisibility","in","in2","intercept","k","k1","k2","k3","k4","kernelMatrix","kernelUnitLength","keyPoints","keySplines","keyTimes","kerning","lengthAdjust","limitingConeAngle","local","markerHeight","markerUnits","markerWidth","maskContentUnits","maskUnits","mathematical","mediaCharacterEncoding","mediaContentEncodings","mediaSize","mediaTime","mode","numOctaves","observer","offset","opacity","operator","order","orient","orientation","origin","overflow","overlay","path","pathLength","patternContentUnits","patternTransform","patternUnits","phase","pitch","points","pointsAtX","pointsAtY","pointsAtZ","preserveAlpha","preserveAspectRatio","primitiveUnits","propagate","r","radius","refX","refY","repeatCount","repeatDur","requiredExtensions","requiredFeatures","requiredFonts","requiredFormats","resource","restart","result","rotate","rx","ry","scale","seed","side","slope","snapshotTime","specularConstant","specularExponent","spreadMethod","spacing","startOffset","stdDeviation","stemh","stemv","stitchTiles","string","stroke","surfaceScale","syncBehavior","syncBehaviorDefault","syncMaster","syncTolerance","syncToleranceDefault","systemLanguage","tableValues","targetX","targetY","textLength","transformBehavior","to","u1","u2","unicode","viewBox","viewTarget","visibility","widths","x","x1","x2","xChannelSelector","y","y1","y2","yChannelSelector","z","zoomAndPan","property_information_html","property_information_svg","valid","dash","cap","kebab","$0","camelcase","toUpperCase","hastToReact","esm","cjs","pointEnd","point","pointStart","undefined","stringifyPosition","lib_position","lib_point","VFileMessage","Error","causeOrReason","optionsOrParentOrPlace","legacyCause","place","ancestors","cause","message","ruleId","indexOf","parent","fatal","file","stack","actual","expected","note","url","lib_own","emptyMap","Map","lib_cap","dashSomething","tableElements","Set","tableCellElement","docs","one","state","lib_element","parentSchema","schema","tagName","findComponentFromName","props","createElementProps","alignValue","createProperty","find","Type","rest","dashes","Number","isNaN","stringify","input","join","padRight","padLeft","parseStyle","toCamel","ignoreInvalidStyle","filePath","String","stylePropertyNameCase","transformStylesToCssCasing","domCasing","cssCasing","transformStyleToCssCasing","toDash","elementAttributeNameCase","tableCellAlignToStyle","has","children","createChildren","child","thing","addNode","addChildren","pop","mdxExpression","estree","evaluater","expression","program","body","evaluateExpression","crashEstree","mdxJsxElement","Fragment","createJsxElementProps","objectExpression","argument","mdxEsm","evaluateProgram","root","passNode","countsByName","passKeys","count","get","set","allowExpression","identifiers","split","computed","Boolean","optional","components","$1","urlAttributes","icon","lib_emptyOptions","lib_one","includeImageAlt","includeHtml","lib_all","splice","remove","items","parameters","chunkStart","unshift","SpliceBuffer","initial","left","right","shift","setCursor","stop","POSITIVE_INFINITY","reverse","concat","deleteCount","Math","trunc","removed","chunkedPush","item","pushMany","unshiftMany","n","subtokenize","eventsArray","lineIndex","otherIndex","otherEvent","subevents","more","jumps","events","_tokenizer","_isInFirstContentOfListItem","contentType","subcontent","eventIndex","stream","previous","token","context","startPosition","startPositions","tokenizer","parser","childEvents","gaps","current","adjust","breaks","sliceStream","next","defineSkip","_gfmTasklistFirstContentOfListItem","write","_container","micromark_util_combine_extensions_hasOwnProperty","asciiAlpha","regexCheck","asciiAlphanumeric","asciiAtext","asciiControl","asciiDigit","asciiHexDigit","asciiPunctuation","markdownLineEnding","markdownLineEndingOrSpace","markdownSpace","unicodePunctuation","unicodeWhitespace","regex","fromCharCode","factorySpace","effects","ok","limit","enter","consume","exit","tokenize","contentStart","attempt","constructs","contentInitial","lineStart","document_document","childFlow","childToken","lineStartOffset","self","continued","containerState","continuation","documentContinue","checkNewContainers","_closeFlow","closeFlow","indexBeforeExits","indexBeforeFlow","exitContainers","documentContinued","currentConstruct","concrete","flowStart","interrupt","_gfmTableDynamicInterruptHack","containerConstruct","thereIsANewContainer","thereIsNoNewContainer","lazy","now","containerContinue","flow","flowContinue","writeToChild","eof","seen","entry","nok","document","disable","null","blankLine","after","partial","content_content","chunkInside","contentEnd","continuationConstruct","contentContinue","resolve","prefixed","tail","sliceSerialize","flowInitial","afterConstruct","resolver","resolveAll","createResolver","initializeFactory","text_text","field","notText","atBreak","resolveAllLineSuffixes","extraResolver","tabs","chunks","bufferIndex","chunk","charCodeAt","_index","_bufferIndex","called","thematicBreak","marker","sequence","initialSize","atMarker","inside","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","furtherBlankLines","notInCurrentItem","indentConstruct","blockQuote","contBefore","factoryDestination","literalType","literalMarkerType","rawType","stringType","balance","enclosedBefore","raw","enclosed","enclosedEscape","rawEscape","factoryLabel","markerType","labelInside","labelEscape","factoryTitle","escape","factoryWhitespace","normalizeIdentifier","titleBefore","beforeMarker","titleAfter","titleAfterOptionalWhitespace","codeIndented","afterPrefix","furtherStart","setextUnderline","paragraph","resolveTo","heading","htmlBlockNames","htmlRawNames","blankLineBefore","nonLazyContinuationStart","nonLazyContinuation","codeFenced","closeStart","beforeSequenceClose","sequenceClose","sizeOpen","sequenceCloseAfter","initialPrefix","beforeSequenceOpen","sequenceOpen","infoBefore","atNonLazyBreak","metaBefore","meta","contentBefore","beforeContentChunk","contentChunk","index_dom_element","createElement","decodeNamedCharacterReference","characterReference","innerHTML","textContent","numeric","characterEscape","lineEnding","labelEnd","labelStart","_balanced","_inactive","labelEndNok","resourceConstruct","labelEndOk","referenceFullConstruct","referenceNotFull","referenceCollapsedConstruct","close","group","insideSpan","resourceBefore","resourceOpen","resourceEnd","resourceDestinationAfter","resourceDestinationMissing","resourceBetween","resourceTitleAfter","referenceFullAfter","referenceFullMissing","referenceCollapsedOpen","labelStartImage","classifyCharacter","attention","attentionMarkers","before","_open","_close","openingSequence","closingSequence","use","nextEvents","movePoint","labelStartLink","constructs_document","identifier","labelAfter","markerAfter","destinationBefore","destinationAfter","afterWhitespace","constructs_flow","sequenceFurther","closingTag","buffer","markerB","declarationOpen","tagCloseStart","continuationDeclarationInside","commentOpenInside","cdataOpenInside","slash","basicSelfClosing","completeClosingTagAfter","completeEnd","completeAttributeNameBefore","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCdataInside","continuationAfter","continuationStart","continuationStartNonLazy","continuationBefore","continuationRawEndTag","constructs_string","constructs_text","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","returnState","instruction","tagOpen","commentEnd","commentClose","lineEndingBefore","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","lineEndingAfter","lineEndingAfterPrefix","between","tailExitIndex","headEnterIndex","search","decodeNumericCharacterReference","base","parseInt","fromCodePoint","characterEscapeOrReference","decode","$2","head","hex","mdast_util_from_markdown_lib_own","mdast_util_from_markdown_lib_point","defaultOnError","remarkParse","doc","encoding","atCarriageReturn","extensions","mdastExtensions","compiler","config","transforms","canContainEols","autolink","opener","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","codeFlow","codeFencedFenceInfo","codeFencedFenceMeta","codeText","codeTextData","codeFlowValue","definitionDestinationString","definitionLabelString","definitionTitleString","emphasis","hardBreakEscape","hardBreak","hardBreakTrailing","htmlFlow","htmlFlowData","htmlText","htmlTextData","image","listItem","spread","_spread","listItemValue","expectingFirstListItemValue","ancestor","listOrdered","listUnordered","reference","referenceType","referenceString","resourceDestinationString","resourceTitleString","setextHeading","strong","closer","atxHeadingSequence","depth","onexitdata","characterEscapeValue","characterReferenceMarkerHexadecimal","onexitcharacterreferencemarker","characterReferenceMarkerNumeric","characterReferenceValue","characterReferenceType","resume","flowCodeInside","codeFencedFence","onexithardbreak","inReference","fragment","labelText","atHardBreak","setextHeadingSlurpLineEnding","setextHeadingLineSequence","codePointAt","setextHeadingText","configure","combined","extension","tree","tokenStack","listStack","prepareList","firstBlankLineIndex","containerBalance","listSpread","tailIndex","tailEvent","and","errorHandler","siblings","onExitError","ordered","postprocess","parse_parse","combineExtensions","all","syntaxExtension","hook","maybe","existing","add","constructs_namespaceObject","createTokenizer","initialize","columnStart","resolveAllConstructs","accountForPotentialSkip","fields","constructFactory","construct","addResult","onsuccessfulcheck","expandTabs","serializeChunks","atTab","main","chunkIndex","go","sliceChunks","view","startIndex","startBufferIndex","endIndex","endBufferIndex","restore","onreturn","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","def","map","handleConstruct","store","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","preprocess","endPosition","TextDecoder","lastIndex","ceil","env","globalThis","deserializer","$","out","unpair","Date","flags","RegExp","BigInt","deserialize","serialized","serialize_toString","asString","shouldSkip","TYPE","serializer","strict","json","pair","valueOf","toJSON","entries","toISOString","serialize","lossy","structured_clone_esm","structuredClone","any","normalizeUri","skip","encodeURIComponent","defaultFootnoteBackContent","rereferenceIndex","defaultFootnoteBackLabel","referenceIndex","convert","lib_ok","castFactory","anyFactory","tests","apply","nodeAsRecord","checkAsRecord","testFunction","looksLikeANode","lib_empty","visit","testOrVisitor","visitorOrReverse","maybeReverse","visitor","visitParents","factory","parents","subresult","grandparents","nodeAsParent","revert","subtype","suffix","contents","listItemLoose","trimLine","handlers_handlers","blockquote","patch","applyData","break","delete","footnoteReference","counter","clobberPrefix","safeId","footnoteOrder","reuseCounter","footnoteCounts","dataFootnoteRef","sup","allowDangerousHtml","imageReference","definitionById","inlineCode","linkReference","loose","listLoose","table","firstRow","tableContent","tableCell","tableRow","rowIndex","cellIndex","cells","cell","trimLines","last","toml","ignore","yaml","footnoteDefinition","state_own","state_emptyOptions","hName","hChildren","hProperties","nodes","trimMarkdownSpaceStart","toHast","createState","footnoteById","handlers","handle","passThrough","shallow","unknown","unknownHandler","foot","footer","footnoteBackContent","footnoteBackLabel","footnoteLabel","footnoteLabelTagName","footnoteLabelProperties","listItems","backReferences","counts","dataFootnoteBackref","tailTail","dataFootnotes","remarkRehype","destination","hastTree","run","bail","getPrototypeOf","Symbol","toStringTag","minpath","basename","extname","seenNonSlash","assertPath","firstNonSlashEnd","extnameIndex","dirname","unmatchedSlash","startPart","startDot","preDotState","segments","joined","minpath_browser_normalize","absolute","normalizeString","allowAboveRoot","lastSlashIndex","lastSegmentLength","lastSlash","dots","sep","JSON","minproc","cwd","isUrl","fileUrlOrPath","protocol","auth","VFile","history","messages","stored","assertNonEmpty","assertPart","lib_assertPath","stem","urlToPath","URL","getPathFromURLPosix","hostname","pathname","third","decodeURIComponent","fail","decoder","part","CallableInstance","proto","constr","setPrototypeOf","unified_lib_own","Processor","Compiler","Parser","attachers","freezeIndex","frozen","namespace","transformers","trough","fns","pipeline","middlewareIndex","callback","output","fn","lib_wrap","middleware","fnExpectsCallback","done","then","middelware","attacher","assertUnfrozen","freeze","transformer","parse","realFile","vfile","assertParser","process","assertCompiler","executor","Promise","reject","parseTree","realDone","compileResult","processSync","complete","assertDone","assertNode","outputTree","resultingTree","runSync","addPlugin","addList","addPreset","plugins","plugin","entryIndex","primary","currentPrimary","unified","asyncName","looksLikeAVFile","emptyPlugins","emptyRemarkRehypeOptions","safeProtocol","deprecations","Markdown","allowedElements","allowElement","disallowedElements","rehypePlugins","remarkPlugins","remarkRehypeOptions","skipHtml","unwrapDisallowed","urlTransform","defaultUrlTransform","processor","deprecation","mdastTree","toJsxRuntime","jsxDEV","jsxs","development","isStaticChildren","columnNumber","fileName","lineNumber","createEvaluater","jsx_runtime","colon","questionMark","numberSign"],"sourceRoot":""}