{"version":3,"file":"js/849-5447618186a7304ac27e.js","mappings":"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","sources":["webpack://artfully-walls/./node_modules/extend/index.js","webpack://artfully-walls/./node_modules/inline-style-parser/index.js","webpack://artfully-walls/./node_modules/react/cjs/react-jsx-runtime.production.min.js","webpack://artfully-walls/./node_modules/react/jsx-runtime.js","webpack://artfully-walls/./node_modules/style-to-object/cjs/index.js","webpack://artfully-walls/./node_modules/estree-util-is-identifier-name/lib/index.js","webpack://artfully-walls/./node_modules/hast-util-whitespace/lib/index.js","webpack://artfully-walls/./node_modules/property-information/lib/util/schema.js","webpack://artfully-walls/./node_modules/property-information/lib/util/merge.js","webpack://artfully-walls/./node_modules/property-information/lib/normalize.js","webpack://artfully-walls/./node_modules/property-information/lib/util/info.js","webpack://artfully-walls/./node_modules/property-information/lib/util/types.js","webpack://artfully-walls/./node_modules/property-information/lib/util/defined-info.js","webpack://artfully-walls/./node_modules/property-information/lib/util/create.js","webpack://artfully-walls/./node_modules/property-information/lib/xlink.js","webpack://artfully-walls/./node_modules/property-information/lib/xml.js","webpack://artfully-walls/./node_modules/property-information/lib/util/case-sensitive-transform.js","webpack://artfully-walls/./node_modules/property-information/lib/util/case-insensitive-transform.js","webpack://artfully-walls/./node_modules/property-information/lib/xmlns.js","webpack://artfully-walls/./node_modules/property-information/lib/aria.js","webpack://artfully-walls/./node_modules/property-information/lib/html.js","webpack://artfully-walls/./node_modules/property-information/lib/svg.js","webpack://artfully-walls/./node_modules/property-information/index.js","webpack://artfully-walls/./node_modules/property-information/lib/find.js","webpack://artfully-walls/./node_modules/property-information/lib/hast-to-react.js","webpack://artfully-walls/./node_modules/style-to-object/esm/index.mjs","webpack://artfully-walls/./node_modules/unist-util-position/lib/index.js","webpack://artfully-walls/./node_modules/unist-util-stringify-position/lib/index.js","webpack://artfully-walls/./node_modules/vfile-message/lib/index.js","webpack://artfully-walls/./node_modules/hast-util-to-jsx-runtime/lib/index.js","webpack://artfully-walls/./node_modules/comma-separated-tokens/index.js","webpack://artfully-walls/./node_modules/space-separated-tokens/index.js","webpack://artfully-walls/./node_modules/html-url-attributes/lib/index.js","webpack://artfully-walls/./node_modules/mdast-util-to-string/lib/index.js","webpack://artfully-walls/./node_modules/micromark-util-chunked/index.js","webpack://artfully-walls/./node_modules/micromark-util-subtokenize/lib/splice-buffer.js","webpack://artfully-walls/./node_modules/micromark-util-subtokenize/index.js","webpack://artfully-walls/./node_modules/micromark-util-combine-extensions/index.js","webpack://artfully-walls/./node_modules/micromark-util-character/index.js","webpack://artfully-walls/./node_modules/micromark-factory-space/index.js","webpack://artfully-walls/./node_modules/micromark/lib/initialize/content.js","webpack://artfully-walls/./node_modules/micromark/lib/initialize/document.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/blank-line.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/content.js","webpack://artfully-walls/./node_modules/micromark/lib/initialize/flow.js","webpack://artfully-walls/./node_modules/micromark/lib/initialize/text.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/thematic-break.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/list.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/block-quote.js","webpack://artfully-walls/./node_modules/micromark-factory-destination/index.js","webpack://artfully-walls/./node_modules/micromark-factory-label/index.js","webpack://artfully-walls/./node_modules/micromark-factory-title/index.js","webpack://artfully-walls/./node_modules/micromark-factory-whitespace/index.js","webpack://artfully-walls/./node_modules/micromark-util-normalize-identifier/index.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/definition.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/code-indented.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/heading-atx.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/setext-underline.js","webpack://artfully-walls/./node_modules/micromark-util-html-tag-name/index.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/html-flow.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/code-fenced.js","webpack://artfully-walls/./node_modules/decode-named-character-reference/index.dom.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/character-reference.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/character-escape.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/line-ending.js","webpack://artfully-walls/./node_modules/micromark-util-resolve-all/index.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/label-end.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/label-start-image.js","webpack://artfully-walls/./node_modules/micromark-util-classify-character/index.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/attention.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/autolink.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/html-text.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/label-start-link.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/hard-break-escape.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/code-text.js","webpack://artfully-walls/./node_modules/micromark/lib/constructs.js","webpack://artfully-walls/./node_modules/micromark/lib/create-tokenizer.js","webpack://artfully-walls/./node_modules/micromark/lib/parse.js","webpack://artfully-walls/./node_modules/micromark/lib/preprocess.js","webpack://artfully-walls/./node_modules/micromark-util-decode-numeric-character-reference/index.js","webpack://artfully-walls/./node_modules/micromark-util-decode-string/index.js","webpack://artfully-walls/./node_modules/mdast-util-from-markdown/lib/index.js","webpack://artfully-walls/./node_modules/micromark/lib/postprocess.js","webpack://artfully-walls/./node_modules/remark-parse/lib/index.js","webpack://artfully-walls/./node_modules/@ungap/structured-clone/esm/types.js","webpack://artfully-walls/./node_modules/@ungap/structured-clone/esm/deserialize.js","webpack://artfully-walls/./node_modules/@ungap/structured-clone/esm/serialize.js","webpack://artfully-walls/./node_modules/@ungap/structured-clone/esm/index.js","webpack://artfully-walls/./node_modules/micromark-util-sanitize-uri/index.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/footer.js","webpack://artfully-walls/./node_modules/unist-util-is/lib/index.js","webpack://artfully-walls/./node_modules/unist-util-visit-parents/lib/index.js","webpack://artfully-walls/./node_modules/unist-util-visit/lib/index.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/revert.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/list-item.js","webpack://artfully-walls/./node_modules/trim-lines/index.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/index.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/blockquote.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/break.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/code.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/delete.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/emphasis.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/heading.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/html.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/image-reference.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/image.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/inline-code.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/link-reference.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/link.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/list.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/paragraph.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/root.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/strong.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/table.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/table-cell.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/table-row.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/text.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/state.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/index.js","webpack://artfully-walls/./node_modules/remark-rehype/lib/index.js","webpack://artfully-walls/./node_modules/bail/index.js","webpack://artfully-walls/./node_modules/unified/node_modules/is-plain-obj/index.js","webpack://artfully-walls/./node_modules/trough/lib/index.js","webpack://artfully-walls/./node_modules/vfile/lib/minpath.browser.js","webpack://artfully-walls/./node_modules/vfile/lib/minproc.browser.js","webpack://artfully-walls/./node_modules/vfile/lib/minurl.shared.js","webpack://artfully-walls/./node_modules/vfile/lib/minurl.browser.js","webpack://artfully-walls/./node_modules/vfile/lib/index.js","webpack://artfully-walls/./node_modules/unified/lib/callable-instance.js","webpack://artfully-walls/./node_modules/unified/lib/index.js","webpack://artfully-walls/./node_modules/react-markdown/lib/index.js"],"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","/**\n * @license React\n * react-jsx-runtime.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var f=require(\"react\"),k=Symbol.for(\"react.element\"),l=Symbol.for(\"react.fragment\"),m=Object.prototype.hasOwnProperty,n=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0};\nfunction q(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=\"\"+g);void 0!==a.key&&(e=\"\"+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:k,type:c,key:e,ref:h,props:d,_owner:n.current}}exports.Fragment=l;exports.jsx=q;exports.jsxs=q;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-jsx-runtime.production.min.js');\n} else {\n  module.exports = require('./cjs/react-jsx-runtime.development.js');\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","/**\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","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 * @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 * 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","/**\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 * 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 * @import {Chunk, Event, Token} from 'micromark-util-types'\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 = {\n          ...events.get(lineIndex)[1].start\n        };\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 *   Events.\n * @param {number} eventIndex\n *   Index.\n * @returns {Record<string, number>}\n *   Gaps.\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 * @import {\n *   Extension,\n *   Handles,\n *   HtmlExtension,\n *   NormalizedExtension\n * } from 'micromark-util-types'\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine multiple syntax extensions into one.\n *\n * @param {ReadonlyArray<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 *   Nothing.\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 *   List of constructs to merge into.\n * @param {Array<unknown>} list\n *   List of constructs to merge.\n * @returns {undefined}\n *   Nothing.\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 {ReadonlyArray<HtmlExtension>} htmlExtensions\n *   List of HTML extensions.\n * @returns {HtmlExtension}\n *   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 *   Nothing.\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 * @import {Code} from 'micromark-util-types'\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 *   Expression.\n * @returns {(code: Code) => boolean}\n *   Check.\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 * @import {Effects, State, TokenType} from 'micromark-util-types'\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 * @import {\n *   InitialConstruct,\n *   Initializer,\n *   State,\n *   TokenizeContext,\n *   Token\n * } from 'micromark-util-types'\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 *   Context.\n * @type {Initializer}\n *   Content.\n */\nfunction initializeContent(effects) {\n  const contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial);\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 * @import {\n *   Construct,\n *   ContainerState,\n *   InitialConstruct,\n *   Initializer,\n *   Point,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\n/**\n * @typedef {[Construct, ContainerState]} StackItem\n *   Construct and its state.\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 *   Self.\n * @type {Initializer}\n *   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(item[0].continuation, documentContinue, checkNewContainers)(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 (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === \"chunkFlow\") {\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 = {\n          ...point\n        };\n        index++;\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));\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(childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack);\n    }\n\n    // Check if there is a new container.\n    self.containerState = {};\n    return effects.check(containerConstruct, thereIsANewContainer, thereIsNoNewContainer)(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(containerConstruct, containerContinue, flowStart)(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      _tokenizer: childFlow,\n      contentType: \"flow\",\n      previous: childToken\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   *   Token.\n   * @param {boolean | undefined} [endOfFile]\n   *   Whether the token is at the end of the file (default: `false`).\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function writeToChild(token, endOfFile) {\n    const stream = self.sliceStream(token);\n    if (endOfFile) 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          // 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 (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === \"chunkFlow\") {\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 = {\n          ...point\n        };\n        index++;\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));\n\n      // Discard the duplicate exits.\n      self.events.length = index;\n    }\n  }\n\n  /**\n   * @param {number} size\n   *   Size.\n   * @returns {undefined}\n   *   Nothing.\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 *   Context.\n * @type {Tokenizer}\n *   Tokenizer.\n */\nfunction tokenizeContainer(effects, ok, nok) {\n  // Always populated by defaults.\n\n  return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok, nok), \"linePrefix\", this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4);\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blankLine = {\n  partial: true,\n  tokenize: tokenizeBlankLine\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\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 * @import {\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\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  resolve: resolveContent,\n  tokenize: tokenizeContent\n};\n\n/** @type {Construct} */\nconst continuationConstruct = {\n  partial: true,\n  tokenize: tokenizeContinuation\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 *   Context.\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 *   Context.\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 * @import {\n *   InitialConstruct,\n *   Initializer,\n *   State,\n *   TokenizeContext\n * } from 'micromark-util-types'\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 *   Self.\n * @type {Initializer}\n *   Initializer.\n */\nfunction initializeFlow(effects) {\n  const self = this;\n  const initial = effects.attempt(\n  // Try to parse a blank line.\n  blankLine, atBlankEnding,\n  // Try to parse initial flow (essentially, only code).\n  effects.attempt(this.parser.constructs.flowInitial, afterConstruct, factorySpace(effects, effects.attempt(this.parser.constructs.flow, afterConstruct, effects.attempt(content, afterConstruct)), \"linePrefix\")));\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 * @import {\n *   Code,\n *   InitialConstruct,\n *   Initializer,\n *   Resolver,\n *   State,\n *   TokenizeContext\n * } from 'micromark-util-types'\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 *   Field.\n * @returns {InitialConstruct}\n *   Construct.\n */\nfunction initializeFactory(field) {\n  return {\n    resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined),\n    tokenize: initializeText\n  };\n\n  /**\n   * @this {TokenizeContext}\n   *   Context.\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     *   Code.\n     * @returns {boolean}\n     *   Whether the code is a break.\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 *   Resolver.\n * @returns {Resolver}\n *   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 ((eventIndex === events.length || events[eventIndex][1].type === \"lineEnding\") && events[eventIndex - 1][1].type === \"data\") {\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: eventIndex === events.length || tabs || size < 2 ? \"lineSuffix\" : \"hardBreakTrailing\",\n          start: {\n            _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex,\n            _index: data.start._index + index,\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size\n          },\n          end: {\n            ...data.end\n          }\n        };\n        data.end = {\n          ...token.start\n        };\n        if (data.start.offset === data.end.offset) {\n          Object.assign(data, token);\n        } else {\n          events.splice(eventIndex, 0, ['enter', token, context], ['exit', token, context]);\n          eventIndex += 2;\n        }\n      }\n      eventIndex++;\n    }\n  }\n  return events;\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\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 *   Context.\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 * @import {\n *   Code,\n *   Construct,\n *   Exiter,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\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  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd,\n  name: 'list',\n  tokenize: tokenizeListStart\n};\n\n/** @type {Construct} */\nconst listItemPrefixWhitespaceConstruct = {\n  partial: true,\n  tokenize: tokenizeListItemPrefixWhitespace\n};\n\n/** @type {Construct} */\nconst indentConstruct = {\n  partial: true,\n  tokenize: tokenizeIndent\n};\n\n// To do: `markdown-rs` parses list items on their own and later stitches them\n// together.\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\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 * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\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 * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\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 * @this {TokenizeContext}\n *   Context.\n * @type {Exiter}\n */\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type);\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\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 * @import {\n *   Construct,\n *   Exiter,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blockQuote = {\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit,\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\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 *   Context.\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 * @import {Effects, State, TokenType} from 'micromark-util-types'\n */\n\nimport { asciiControl, markdownLineEndingOrSpace, markdownLineEnding } 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 */\nexport function factoryDestination(effects, ok, nok, type, literalType, literalMarkerType, rawType, stringType, max) {\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 (!balance && (code === null || code === 41 || markdownLineEndingOrSpace(code))) {\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 * @import {\n *   Effects,\n *   State,\n *   TokenizeContext,\n *   TokenType\n * } from 'micromark-util-types'\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 */\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 (size > 999 || code === null || code === 91 || 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 && !size && '_hiddenFootnoteSupport' in self.parser.constructs) {\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 (code === null || code === 91 || code === 93 || markdownLineEnding(code) || size++ > 999) {\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 * @import {\n *   Code,\n *   Effects,\n *   State,\n *   TokenType\n * } from 'micromark-util-types'\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 */\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 * @import {Effects, State} from 'micromark-util-types'\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(effects, start, seen ? \"linePrefix\" : \"lineSuffix\")(code);\n    }\n    return ok(code);\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 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().toUpperCase();\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\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 { markdownLineEndingOrSpace, markdownLineEnding, 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  partial: true,\n  tokenize: tokenizeTitleBefore\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\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 *   Context.\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 * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\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  partial: true,\n  tokenize: tokenizeFurtherStart\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\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 *   Context.\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 * @import {\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { splice } from 'micromark-util-chunked';\n/** @type {Construct} */\nexport const headingAtx = {\n  name: 'headingAtx',\n  resolve: resolveHeadingAtx,\n  tokenize: tokenizeHeadingAtx\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 *   Context.\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 * @import {\n *   Code,\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\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  resolveTo: resolveToSetextUnderline,\n  tokenize: tokenizeSetextUnderline\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: {\n      ...events[text][1].start\n    },\n    end: {\n      ...events[events.length - 1][1].end\n    }\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 = {\n      ...events[definition][1].end\n    };\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 *   Context.\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 * @import {\n *   Code,\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiAlphanumeric, asciiAlpha, markdownLineEndingOrSpace, markdownLineEnding, 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  concrete: true,\n  name: 'htmlFlow',\n  resolveTo: resolveToHtmlFlow,\n  tokenize: tokenizeHtmlFlow\n};\n\n/** @type {Construct} */\nconst blankLineBefore = {\n  partial: true,\n  tokenize: tokenizeBlankLineBefore\n};\nconst nonLazyContinuationStart = {\n  partial: true,\n  tokenize: tokenizeNonLazyContinuationStart\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 *   Context.\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      // Always the case.\n      effects.consume(code);\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      // Always the case.\n      effects.consume(code);\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      // Always the case.\n      effects.consume(code);\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 *   Context.\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 *   Context.\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 * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nconst nonLazyContinuation = {\n  partial: true,\n  tokenize: tokenizeNonLazyContinuation\n};\n\n/** @type {Construct} */\nexport const codeFenced = {\n  concrete: true,\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  const self = this;\n  /** @type {Construct} */\n  const closeStart = {\n    partial: true,\n    tokenize: tokenizeCloseStart\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   *   Context.\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 *   Context.\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 * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\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 *   Context.\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 * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\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 *   Context.\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 * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\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 *   Context.\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 * @import {Event, Resolver, TokenizeContext} from 'micromark-util-types'\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {ReadonlyArray<{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 * @import {\n *   Construct,\n *   Event,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\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  resolveAll: resolveAllLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  tokenize: tokenizeLabelEnd\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  /** @type {Array<Event>} */\n  const newEvents = [];\n  while (++index < events.length) {\n    const token = events[index][1];\n    newEvents.push(events[index]);\n    if (token.type === \"labelImage\" || token.type === \"labelLink\" || token.type === \"labelEnd\") {\n      // Remove the marker.\n      const offset = token.type === \"labelImage\" ? 4 : 2;\n      token.type = \"data\";\n      index += offset;\n    }\n  }\n\n  // If the events are equal, we don't have to copy newEvents to events\n  if (events.length !== newEvents.length) {\n    splice(events, 0, events.length, newEvents);\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: {\n      ...events[open][1].start\n    },\n    end: {\n      ...events[events.length - 1][1].end\n    }\n  };\n  const label = {\n    type: \"label\",\n    start: {\n      ...events[open][1].start\n    },\n    end: {\n      ...events[close][1].end\n    }\n  };\n  const text = {\n    type: \"labelText\",\n    start: {\n      ...events[open + offset + 2][1].end\n    },\n    end: {\n      ...events[close - 2][1].start\n    }\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 *   Context.\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 *   Context.\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 *   Context.\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 *   Context.\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 * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { labelEnd } from './label-end.js';\n\n/** @type {Construct} */\nexport const labelStartImage = {\n  name: 'labelStartImage',\n  resolveAll: labelEnd.resolveAll,\n  tokenize: tokenizeLabelStartImage\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\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 * @import {Code} from 'micromark-util-types'\n */\n\nimport { markdownLineEndingOrSpace, unicodePunctuation, unicodeWhitespace } 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 (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n    return 1;\n  }\n  if (unicodePunctuation(code)) {\n    return 2;\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   Event,\n *   Point,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\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  resolveAll: resolveAllAttention,\n  tokenize: tokenizeAttention\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 = {\n            ...events[open][1].end\n          };\n          const end = {\n            ...events[index][1].start\n          };\n          movePoint(start, -use);\n          movePoint(end, use);\n          openingSequence = {\n            type: use > 1 ? \"strongSequence\" : \"emphasisSequence\",\n            start,\n            end: {\n              ...events[open][1].end\n            }\n          };\n          closingSequence = {\n            type: use > 1 ? \"strongSequence\" : \"emphasisSequence\",\n            start: {\n              ...events[index][1].start\n            },\n            end\n          };\n          text = {\n            type: use > 1 ? \"strongText\" : \"emphasisText\",\n            start: {\n              ...events[open][1].end\n            },\n            end: {\n              ...events[index][1].start\n            }\n          };\n          group = {\n            type: use > 1 ? \"strong\" : \"emphasis\",\n            start: {\n              ...openingSequence.start\n            },\n            end: {\n              ...closingSequence.end\n            }\n          };\n          events[open][1].end = {\n            ...openingSequence.start\n          };\n          events[index][1].start = {\n            ...closingSequence.end\n          };\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 *   Context.\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 *   Point.\n * @param {number} offset\n *   Amount to move.\n * @returns {undefined}\n *   Nothing.\n */\nfunction movePoint(point, offset) {\n  point.column += offset;\n  point.offset += offset;\n  point._bufferIndex += offset;\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiAlphanumeric, asciiAlpha, 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 *   Context.\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 * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { asciiAlphanumeric, asciiAlpha, markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\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 * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { labelEnd } from './label-end.js';\n\n/** @type {Construct} */\nexport const labelStartLink = {\n  name: 'labelStartLink',\n  resolveAll: labelEnd.resolveAll,\n  tokenize: tokenizeLabelStartLink\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\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 * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\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 *   Context.\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 * @import {\n *   Construct,\n *   Previous,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const codeText = {\n  name: 'codeText',\n  previous,\n  resolve: resolveCodeText,\n  tokenize: tokenizeCodeText\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 *   Context.\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 *   Context.\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 * @import {Extension} from 'micromark-util-types'\n */\n\nimport { attention, autolink, blockQuote, characterEscape, characterReference, codeFenced, codeIndented, codeText, definition, hardBreakEscape, headingAtx, htmlFlow, htmlText, labelEnd, labelStartImage, labelStartLink, lineEnding, list, setextUnderline, thematicBreak } 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 * @import {\n *   Chunk,\n *   Code,\n *   ConstructRecord,\n *   Construct,\n *   Effects,\n *   InitialConstruct,\n *   ParseContext,\n *   Point,\n *   State,\n *   TokenizeContext,\n *   Token\n * } from 'micromark-util-types'\n */\n\n/**\n * @callback Restore\n *   Restore the state.\n * @returns {undefined}\n *   Nothing.\n *\n * @typedef Info\n *   Info.\n * @property {Restore} restore\n *   Restore.\n * @property {number} from\n *   From.\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n *   Construct.\n * @param {Info} info\n *   Info.\n * @returns {undefined}\n *   Nothing.\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 *   Parser.\n * @param {InitialConstruct} initialize\n *   Construct.\n * @param {Omit<Point, '_bufferIndex' | '_index'> | undefined} [from]\n *   Point (optional).\n * @returns {TokenizeContext}\n *   Context.\n */\nexport function createTokenizer(parser, initialize, from) {\n  /** @type {Point} */\n  let point = {\n    _bufferIndex: -1,\n    _index: 0,\n    line: from && from.line || 1,\n    column: from && from.column || 1,\n    offset: from && from.offset || 0\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    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    consume,\n    enter,\n    exit,\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    code: null,\n    containerState: {},\n    defineSkip,\n    events: [],\n    now,\n    parser,\n    previous: null,\n    sliceSerialize,\n    sliceStream,\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 {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\n    } = point;\n    return {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\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   *   Nothing.\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 (point._index === chunkIndex && point._bufferIndex < chunk.length) {\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   *   Code.\n   * @returns {undefined}\n   *   Nothing.\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      if (point._bufferIndex ===\n      // Points w/ non-negative `_bufferIndex` reference\n      // strings.\n      /** @type {string} */\n      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   *   Callback.\n   * @param {{interrupt?: boolean | undefined} | undefined} [fields]\n   *   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> | ConstructRecord | Construct} constructs\n     *   Constructs.\n     * @param {State} returnState\n     *   State.\n     * @param {State | undefined} [bogusState]\n     *   State.\n     * @returns {State}\n     *   State.\n     */\n    function hook(constructs, returnState, bogusState) {\n      /** @type {ReadonlyArray<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) : 'tokenize' in constructs ?\n      // Looks like a construct.\n      handleListOfConstructs([(/** @type {Construct} */constructs)]) : handleMapOfConstructs(constructs);\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       *   Constructs.\n       * @returns {State}\n       *   State.\n       */\n      function handleMapOfConstructs(map) {\n        return start;\n\n        /** @type {State} */\n        function start(code) {\n          const left = 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(left) ? left : left ? [left] : []), ...(Array.isArray(all) ? all : all ? [all] : [])];\n          return handleListOfConstructs(list)(code);\n        }\n      }\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ReadonlyArray<Construct>} list\n       *   Constructs.\n       * @returns {State}\n       *   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       *   Construct.\n       * @returns {State}\n       *   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 (construct.name && context.parser.constructs.disable.null.includes(construct.name)) {\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, effects, ok, nok)(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   *   Construct.\n   * @param {number} from\n   *   From.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct);\n    }\n    if (construct.resolve) {\n      splice(context.events, from, context.events.length - from, construct.resolve(context.events.slice(from), context));\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   *   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      from: startEventsIndex,\n      restore\n    };\n\n    /**\n     * Restore state.\n     *\n     * @returns {undefined}\n     *   Nothing.\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   *   Nothing.\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 {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {Pick<Token, 'end' | 'start'>} token\n *   Token.\n * @returns {Array<Chunk>}\n *   Chunks.\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 {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {boolean | undefined} [expandTabs=false]\n *   Whether to expand tabs (default: `false`).\n * @returns {string}\n *   Result.\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 switch (chunk) {\n      case -5:\n        {\n          value = \"\\r\";\n          break;\n        }\n      case -4:\n        {\n          value = \"\\n\";\n          break;\n        }\n      case -3:\n        {\n          value = \"\\r\" + \"\\n\";\n          break;\n        }\n      case -2:\n        {\n          value = expandTabs ? \" \" : \"\\t\";\n          break;\n        }\n      case -1:\n        {\n          if (!expandTabs && atTab) continue;\n          value = \" \";\n          break;\n        }\n      default:\n        {\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 * @import {\n *   Create,\n *   FullNormalizedExtension,\n *   InitialConstruct,\n *   ParseContext,\n *   ParseOptions\n * } from 'micromark-util-types'\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 * as defaultConstructs from './constructs.js';\nimport { createTokenizer } from './create-tokenizer.js';\n\n/**\n * @param {ParseOptions | null | undefined} [options]\n *   Configuration (optional).\n * @returns {ParseContext}\n *   Parser.\n */\nexport function parse(options) {\n  const settings = options || {};\n  const constructs = /** @type {FullNormalizedExtension} */\n  combineExtensions([defaultConstructs, ...(settings.extensions || [])]);\n\n  /** @type {ParseContext} */\n  const parser = {\n    constructs,\n    content: create(content),\n    defined: [],\n    document: create(document),\n    flow: create(flow),\n    lazy: {},\n    string: create(string),\n    text: create(text)\n  };\n  return parser;\n\n  /**\n   * @param {InitialConstruct} initial\n   *   Construct to start with.\n   * @returns {Create}\n   *   Create a tokenizer.\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 * @import {Chunk, Code, Encoding, Value} from 'micromark-util-types'\n */\n\n/**\n * @callback Preprocessor\n *   Preprocess a value.\n * @param {Value} value\n *   Value.\n * @param {Encoding | null | undefined} [encoding]\n *   Encoding when `value` is a typed array (optional).\n * @param {boolean | null | undefined} [end=false]\n *   Whether this is the last chunk (default: `false`).\n * @returns {Array<Chunk>}\n *   Chunks.\n */\n\nconst search = /[\\0\\t\\n\\r]/g;\n\n/**\n * @returns {Preprocessor}\n *   Preprocess a value.\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 = buffer + (typeof value === 'string' ? value.toString() : 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 = 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            {\n              chunks.push(65533);\n              column++;\n              break;\n            }\n          case 9:\n            {\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            {\n              chunks.push(-4);\n              column = 1;\n              break;\n            }\n          default:\n            {\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 * 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 = /\\\\([!-/:-@[-`{-~])|&(#(?:\\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 *   Match.\n * @param {string} $1\n *   Character escape.\n * @param {string} $2\n *   Character reference.\n * @returns {string}\n *   Decoded value\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 * @import {\n *   Break,\n *   Blockquote,\n *   Code,\n *   Definition,\n *   Emphasis,\n *   Heading,\n *   Html,\n *   Image,\n *   InlineCode,\n *   Link,\n *   ListItem,\n *   List,\n *   Nodes,\n *   Paragraph,\n *   PhrasingContent,\n *   ReferenceType,\n *   Root,\n *   Strong,\n *   Text,\n *   ThematicBreak\n * } from 'mdast'\n * @import {\n *   Encoding,\n *   Event,\n *   Token,\n *   Value\n * } from 'micromark-util-types'\n * @import {Point} from 'unist'\n * @import {\n *   CompileContext,\n *   CompileData,\n *   Config,\n *   Extension,\n *   Handle,\n *   OnEnterError,\n *   Options\n * } from './types.js'\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   * @type {CompileContext['buffer']}\n   */\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    });\n  }\n\n  /**\n   * @type {CompileContext['enter']}\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 || undefined]);\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   * @type {CompileContext['exit']}\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   * @type {CompileContext['resume']}\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 * @import {Event} from 'micromark-util-types'\n */\n\nimport { subtokenize } from 'micromark-util-subtokenize';\n\n/**\n * @param {Array<Event>} events\n *   Events.\n * @returns {Array<Event>}\n *   Events.\n */\nexport function postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n  return events;\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 || questionMark > -1 && colon > questionMark || numberSign > -1 && colon > numberSign ||\n  // It is a protocol, it should be allowed.\n  protocol.test(value.slice(0, colon))) {\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 (code === 37 && asciiAlphanumeric(value.charCodeAt(index + 1)) && asciiAlphanumeric(value.charCodeAt(index + 2))) {\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 * @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 * @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').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').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","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","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} 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').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').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('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","/**\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} 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","/**\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","EMPTY_STRING","trim","str","replace","style","TypeError","lineno","column","updatePosition","lines","match","lastIndexOf","position","start","line","node","Position","whitespace","this","end","source","content","errorsList","error","msg","err","Error","reason","filename","silent","push","re","m","exec","slice","comments","rules","c","comment","pos","charAt","type","declaration","prop","val","ret","property","decl","decls","declarations","f","k","Symbol","for","l","n","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","ReactCurrentOwner","p","ref","__self","__source","q","a","g","b","d","e","h","defaultProps","$$typeof","props","_owner","current","Fragment","jsx","jsxs","__importDefault","mod","__esModule","iterator","styleObject","inline_style_parser_1","default","hasIterator","forEach","nameRe","nameReJsx","emptyOptions","test","empty","Schema","normal","space","merge","definitions","index","assign","normalize","toLowerCase","Info","attribute","boolean","booleanish","overloadedBoolean","number","commaSeparated","spaceSeparated","commaOrSpaceSeparated","mustUseProperty","defined","powers","increment","checks","keys","DefinedInfo","mask","super","mark","check","values","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","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","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","valid","dash","cap","kebab","$0","camelcase","toUpperCase","hastToReact","pointEnd","point","pointStart","undefined","stringifyPosition","VFileMessage","causeOrReason","optionsOrParentOrPlace","legacyCause","place","ancestors","cause","message","ruleId","indexOf","parent","fatal","file","stack","actual","expected","note","url","emptyMap","Map","dashSomething","tableElements","Set","tableCellElement","docs","toJsxRuntime","tree","filePath","development","jsxDEV","isStaticChildren","children","columnNumber","fileName","lineNumber","developmentCreate","fn","productionCreate","state","components","elementAttributeNameCase","evaluater","createEvaluater","ignoreInvalidStyle","passKeys","passNode","schema","stylePropertyNameCase","tableCellAlignToStyle","one","parentSchema","tagName","findComponentFromName","alignValue","createProperty","has","createElementProps","createChildren","child","thing","addNode","addChildren","pop","estree","expression","body","evaluateExpression","crashEstree","mdxExpression","objectExpression","argument","createJsxElementProps","mdxJsxElement","evaluateProgram","mdxEsm","root","countsByName","count","get","set","Type","rest","dashes","find","Number","isNaN","settings","join","padRight","padLeft","replacer","toCamel","parseStyle","String","domCasing","cssCasing","transformStyleToCssCasing","transformStylesToCssCasing","allowExpression","identifiers","split","computed","Boolean","optional","toDash","$1","urlAttributes","icon","includeImageAlt","includeHtml","splice","remove","items","parameters","chunkStart","unshift","SpliceBuffer","initial","left","right","RangeError","shift","setCursor","stop","POSITIVE_INFINITY","reverse","concat","deleteCount","Math","trunc","removed","chunkedPush","item","pushMany","unshiftMany","subtokenize","eventsArray","jumps","lineIndex","otherIndex","otherEvent","subevents","more","events","_tokenizer","_isInFirstContentOfListItem","contentType","subcontent","_container","eventIndex","token","context","startPosition","startPositions","tokenizer","parser","childEvents","gaps","stream","previous","adjust","breaks","sliceStream","next","defineSkip","_gfmTasklistFirstContentOfListItem","write","syntaxExtension","all","extension","hook","constructs","existing","before","add","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","contentInitial","lineStart","self","childFlow","childToken","lineStartOffset","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","endOfFile","seen","entry","nok","document","disable","null","blankLine","partial","after","resolve","chunkInside","contentEnd","continuationConstruct","contentContinue","prefixed","tail","sliceSerialize","flowInitial","afterConstruct","resolver","resolveAll","createResolver","initializeFactory","field","resolveAllLineSuffixes","notText","atBreak","extraResolver","chunks","tabs","bufferIndex","chunk","charCodeAt","_bufferIndex","_index","thematicBreak","marker","sequence","onBlank","notBlank","furtherBlankLines","initialBlankLine","notInCurrentItem","indentConstruct","initialSize","atMarker","inside","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","blockQuote","contBefore","factoryDestination","literalType","literalMarkerType","rawType","stringType","balance","enclosedBefore","raw","enclosed","enclosedEscape","rawEscape","factoryLabel","markerType","labelInside","labelEscape","factoryTitle","escape","factoryWhitespace","normalizeIdentifier","identifier","labelAfter","markerAfter","destinationBefore","destinationAfter","titleBefore","afterWhitespace","beforeMarker","titleAfter","titleAfterOptionalWhitespace","codeIndented","afterPrefix","furtherStart","headingAtx","sequenceOpen","sequenceFurther","setextUnderline","resolveTo","heading","paragraph","htmlBlockNames","htmlRawNames","htmlFlow","closingTag","buffer","markerB","declarationOpen","tagCloseStart","continuationDeclarationInside","commentOpenInside","cdataOpenInside","slash","basicSelfClosing","completeClosingTagAfter","completeAttributeNameBefore","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCdataInside","continuationStart","blankLineBefore","continuationAfter","nonLazyContinuationStart","continuationStartNonLazy","continuationBefore","continuationRawEndTag","nonLazyContinuation","codeFenced","closeStart","startBefore","beforeSequenceClose","sequenceClose","sizeOpen","sequenceCloseAfter","initialPrefix","beforeSequenceOpen","infoBefore","atNonLazyBreak","metaBefore","meta","contentBefore","beforeContentChunk","contentChunk","createElement","decodeNamedCharacterReference","characterReference","innerHTML","textContent","numeric","characterEscape","lineEnding","called","labelEnd","newEvents","close","_inactive","_balanced","group","insideSpan","labelStart","labelEndNok","resourceConstruct","labelEndOk","referenceFullConstruct","referenceNotFull","referenceCollapsedConstruct","resourceBefore","resourceOpen","resourceEnd","resourceDestinationAfter","resourceDestinationMissing","resourceBetween","resourceTitleAfter","referenceFullAfter","referenceFullMissing","referenceCollapsedOpen","labelStartImage","classifyCharacter","attention","openingSequence","closingSequence","use","nextEvents","_close","_open","movePoint","attentionMarkers","autolink","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","htmlText","returnState","instruction","tagOpen","commentEnd","commentClose","lineEndingBefore","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","lineEndingAfter","lineEndingAfterPrefix","labelStartLink","hardBreakEscape","codeText","tailExitIndex","headEnterIndex","between","createTokenizer","initialize","columnStart","resolveAllConstructs","consumed","constructFactory","construct","addResult","onsuccessfulcheck","accountForPotentialSkip","fields","expandTabs","atTab","serializeChunks","main","expectedCode","startIndex","startBufferIndex","endIndex","endBufferIndex","view","head","sliceChunks","chunkIndex","go","restore","onreturn","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","map","handleMapOfConstructs","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","store","extensions","combineExtensions","search","decodeNumericCharacterReference","base","parseInt","fromCodePoint","characterEscapeOrReference","decode","$2","hex","fromMarkdown","encoding","config","transforms","canContainEols","opener","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","codeFlow","codeFencedFenceInfo","codeFencedFenceMeta","codeTextData","codeFlowValue","definitionDestinationString","definitionLabelString","definitionTitleString","emphasis","hardBreak","hardBreakTrailing","htmlFlowData","htmlTextData","image","listItem","listItemValue","onenterlistitemvalue","listOrdered","onenterlistordered","listUnordered","reference","onenterreference","referenceString","resourceDestinationString","resourceTitleString","setextHeading","strong","closer","atxHeadingSequence","onexitatxheadingsequence","onexitautolinkemail","onexitautolinkprotocol","characterEscapeValue","onexitdata","characterReferenceMarkerHexadecimal","onexitcharacterreferencemarker","characterReferenceMarkerNumeric","characterReferenceValue","onexitcharacterreferencevalue","onexitcharacterreference","onexitcodefenced","codeFencedFence","onexitcodefencedfence","onexitcodefencedfenceinfo","onexitcodefencedfencemeta","onexitcodeindented","onexitcodetext","onexitdefinitiondestinationstring","onexitdefinitionlabelstring","onexitdefinitiontitlestring","onexithardbreak","onexithtmlflow","onexithtmltext","onexitimage","onexitlabel","labelText","onexitlabeltext","onexitlineending","onexitlink","onexitreferencestring","onexitresourcedestinationstring","onexitresourcetitlestring","onexitresource","onexitsetextheading","setextHeadingLineSequence","onexitsetextheadinglinesequence","setextHeadingText","onexitsetextheadingtext","configure","mdastExtensions","compile","tokenStack","resume","listStack","prepareList","defaultOnError","firstBlankLineIndex","containerBalance","listSpread","tailIndex","tailEvent","_spread","and","errorHandler","onExitError","expectingFirstListItemValue","flowCodeInside","depth","setextHeadingSlurpLineEnding","codePointAt","siblings","atHardBreak","inReference","referenceType","ancestor","decodeString","fragment","characterReferenceType","ordered","spread","compiler","postprocess","atCarriageReturn","endPosition","TextDecoder","lastIndex","ceil","preprocess","combined","remarkParse","doc","env","globalThis","deserialize","serialized","$","out","unpair","Date","flags","RegExp","BigInt","deserializer","EMPTY","asString","shouldSkip","TYPE","serialize","json","lossy","strict","pair","valueOf","toJSON","entries","toISOString","serializer","structuredClone","any","normalizeUri","skip","encodeURIComponent","defaultFootnoteBackContent","rereferenceIndex","defaultFootnoteBackLabel","referenceIndex","convert","castFactory","tests","apply","anyFactory","checkAsRecord","nodeAsRecord","propsFactory","typeFactory","testFunction","looksLikeANode","CONTINUE","EXIT","SKIP","visitParents","visitor","factory","parents","visit","subresult","grandparents","toResult","nodeAsParent","testOrVisitor","visitorOrReverse","maybeReverse","revert","subtype","suffix","contents","listItemLoose","trimLines","last","trimLine","blockquote","patch","applyData","break","delete","footnoteReference","clobberPrefix","safeId","footnoteOrder","counter","reuseCounter","footnoteCounts","dataFootnoteRef","sup","allowDangerousHtml","imageReference","definitionById","inlineCode","linkReference","loose","listLoose","table","firstRow","tableContent","tableCell","tableRow","cellIndex","cells","cell","toml","ignore","yaml","footnoteDefinition","hName","hChildren","hProperties","defaultUnknownHandler","nodes","trimMarkdownSpaceStart","toHast","footnoteById","handlers","handle","passThrough","shallow","unknownHandler","createState","foot","footnoteBackContent","footnoteBackLabel","footnoteLabel","footnoteLabelTagName","footnoteLabelProperties","listItems","backReferences","counts","dataFootnoteBackref","tailTail","dataFootnotes","footer","remarkRehype","destination","hastTree","run","bail","getPrototypeOf","toStringTag","trough","fns","pipeline","middlewareIndex","callback","output","middleware","wrapped","fnExpectsCallback","done","then","middelware","minpath","basename","extname","assertPath","seenNonSlash","firstNonSlashEnd","extnameIndex","dirname","unmatchedSlash","startPart","startDot","preDotState","segments","joined","absolute","allowAboveRoot","lastSlashIndex","lastSegmentLength","lastSlash","dots","normalizeString","sep","JSON","stringify","minproc","cwd","isUrl","fileUrlOrPath","protocol","auth","urlToPath","URL","hostname","pathname","third","decodeURIComponent","getPathFromURLPosix","VFile","isUint8Array","history","messages","stored","assertNonEmpty","assertPart","stem","fail","part","CallableInstance","proto","setPrototypeOf","Processor","Compiler","Parser","attachers","freezeIndex","frozen","namespace","transformers","attacher","assertUnfrozen","freeze","transformer","parse","realFile","vfile","assertParser","process","assertCompiler","executor","Promise","reject","parseTree","realDone","compileTree","compileResult","processSync","complete","assertDone","assertNode","outputTree","resultingTree","runSync","addPlugin","addList","addPreset","plugin","plugins","entryIndex","primary","currentPrimary","unified","asyncName","looksLikeAVFile","emptyPlugins","emptyRemarkRehypeOptions","safeProtocol","deprecations","Markdown","allowedElements","allowElement","disallowedElements","rehypePlugins","remarkPlugins","remarkRehypeOptions","skipHtml","unwrapDisallowed","urlTransform","defaultUrlTransform","processor","deprecation","mdastTree","colon","questionMark","numberSign"],"sourceRoot":""}