{"version":3,"file":"static/js/217.94d9678a.chunk.js","mappings":"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","sources":["../../../node_modules/classnames/index.js","../../../node_modules/extend/index.js","../../../node_modules/inline-style-parser/index.js","../../../node_modules/is-buffer/index.js","../../../node_modules/react-is/cjs/react-is.production.min.js","../../../node_modules/react-is/index.js","../../../node_modules/style-to-object/index.js","../../../node_modules/decode-named-character-reference/index.dom.js","../../../node_modules/micromark-core-commonmark/lib/blank-line.js","../../../node_modules/micromark-factory-space/index.js","../../../node_modules/micromark-util-character/lib/unicode-punctuation-regex.js","../../../node_modules/micromark-util-character/index.js","../../../node_modules/micromark-util-chunked/index.js","../../../node_modules/micromark-util-classify-character/index.js","../../../node_modules/micromark-util-combine-extensions/index.js","../../../node_modules/micromark-util-decode-numeric-character-reference/index.js","../../../node_modules/micromark-util-decode-string/index.js","../../../node_modules/micromark-util-normalize-identifier/index.js","../../../node_modules/micromark-util-resolve-all/index.js","../../../node_modules/unist-util-stringify-position/lib/index.js","../../../node_modules/vfile-message/lib/index.js","../../../node_modules/vfile/lib/minpath.browser.js","../../../node_modules/vfile/lib/minproc.browser.js","../../../node_modules/vfile/lib/minurl.shared.js","../../../node_modules/vfile/lib/minurl.browser.js","../../../node_modules/vfile/lib/index.js","../../../node_modules/@babel/runtime/helpers/esm/toArray.js","../../../node_modules/bail/index.js","../../../node_modules/is-plain-obj/index.js","../../../node_modules/trough/lib/index.js","../../../node_modules/unified/lib/index.js","../../../node_modules/mdast-util-to-string/lib/index.js","../../../node_modules/micromark/lib/initialize/content.js","../../../node_modules/micromark/lib/initialize/document.js","../../../node_modules/micromark-util-subtokenize/index.js","../../../node_modules/micromark-core-commonmark/lib/content.js","../../../node_modules/micromark/lib/initialize/flow.js","../../../node_modules/micromark/lib/initialize/text.js","../../../node_modules/micromark/lib/create-tokenizer.js","../../../node_modules/micromark-core-commonmark/lib/thematic-break.js","../../../node_modules/micromark-core-commonmark/lib/list.js","../../../node_modules/micromark-core-commonmark/lib/block-quote.js","../../../node_modules/micromark-factory-destination/index.js","../../../node_modules/micromark-factory-label/index.js","../../../node_modules/micromark-factory-title/index.js","../../../node_modules/micromark-factory-whitespace/index.js","../../../node_modules/micromark-core-commonmark/lib/definition.js","../../../node_modules/micromark-core-commonmark/lib/code-indented.js","../../../node_modules/micromark-core-commonmark/lib/heading-atx.js","../../../node_modules/micromark-core-commonmark/lib/setext-underline.js","../../../node_modules/micromark-util-html-tag-name/index.js","../../../node_modules/micromark-core-commonmark/lib/html-flow.js","../../../node_modules/micromark-core-commonmark/lib/code-fenced.js","../../../node_modules/micromark-core-commonmark/lib/character-reference.js","../../../node_modules/micromark-core-commonmark/lib/character-escape.js","../../../node_modules/micromark-core-commonmark/lib/line-ending.js","../../../node_modules/micromark-core-commonmark/lib/label-end.js","../../../node_modules/micromark-core-commonmark/lib/label-start-image.js","../../../node_modules/micromark-core-commonmark/lib/attention.js","../../../node_modules/micromark-core-commonmark/lib/autolink.js","../../../node_modules/micromark-core-commonmark/lib/html-text.js","../../../node_modules/micromark-core-commonmark/lib/label-start-link.js","../../../node_modules/micromark-core-commonmark/lib/hard-break-escape.js","../../../node_modules/micromark-core-commonmark/lib/code-text.js","../../../node_modules/micromark/lib/constructs.js","../../../node_modules/micromark/lib/preprocess.js","../../../node_modules/mdast-util-from-markdown/lib/index.js","../../../node_modules/micromark/lib/postprocess.js","../../../node_modules/micromark/lib/parse.js","../../../node_modules/remark-parse/lib/index.js","../../../node_modules/micromark-util-sanitize-uri/index.js","../../../node_modules/unist-util-visit/lib/index.js","../../../node_modules/unist-util-position/lib/index.js","../../../node_modules/mdast-util-definitions/lib/index.js","../../../node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js","../../../node_modules/mdast-util-to-hast/lib/revert.js","../../../node_modules/mdast-util-to-hast/lib/handlers/list-item.js","../../../node_modules/trim-lines/index.js","../../../node_modules/mdast-util-to-hast/lib/handlers/index.js","../../../node_modules/mdast-util-to-hast/lib/handlers/blockquote.js","../../../node_modules/mdast-util-to-hast/lib/handlers/break.js","../../../node_modules/mdast-util-to-hast/lib/handlers/code.js","../../../node_modules/mdast-util-to-hast/lib/handlers/delete.js","../../../node_modules/mdast-util-to-hast/lib/handlers/emphasis.js","../../../node_modules/mdast-util-to-hast/lib/handlers/footnote.js","../../../node_modules/mdast-util-to-hast/lib/handlers/heading.js","../../../node_modules/mdast-util-to-hast/lib/handlers/html.js","../../../node_modules/mdast-util-to-hast/lib/handlers/image-reference.js","../../../node_modules/mdast-util-to-hast/lib/handlers/image.js","../../../node_modules/mdast-util-to-hast/lib/handlers/inline-code.js","../../../node_modules/mdast-util-to-hast/lib/handlers/link-reference.js","../../../node_modules/mdast-util-to-hast/lib/handlers/link.js","../../../node_modules/mdast-util-to-hast/lib/handlers/list.js","../../../node_modules/mdast-util-to-hast/lib/handlers/paragraph.js","../../../node_modules/mdast-util-to-hast/lib/handlers/root.js","../../../node_modules/mdast-util-to-hast/lib/handlers/strong.js","../../../node_modules/mdast-util-to-hast/lib/handlers/table.js","../../../node_modules/mdast-util-to-hast/lib/handlers/table-cell.js","../../../node_modules/mdast-util-to-hast/lib/handlers/table-row.js","../../../node_modules/mdast-util-to-hast/lib/handlers/text.js","../../../node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js","../../../node_modules/mdast-util-to-hast/lib/state.js","../../../node_modules/unist-util-generated/lib/index.js","../../../node_modules/mdast-util-to-hast/lib/index.js","../../../node_modules/mdast-util-to-hast/lib/footer.js","../../../node_modules/remark-rehype/lib/index.js","../../../node_modules/property-information/lib/util/schema.js","../../../node_modules/property-information/lib/util/merge.js","../../../node_modules/property-information/lib/normalize.js","../../../node_modules/property-information/lib/util/info.js","../../../node_modules/property-information/lib/util/types.js","../../../node_modules/property-information/lib/util/defined-info.js","../../../node_modules/property-information/lib/util/create.js","../../../node_modules/property-information/lib/xlink.js","../../../node_modules/property-information/lib/xml.js","../../../node_modules/property-information/lib/util/case-sensitive-transform.js","../../../node_modules/property-information/lib/util/case-insensitive-transform.js","../../../node_modules/property-information/lib/xmlns.js","../../../node_modules/property-information/lib/aria.js","../../../node_modules/property-information/lib/html.js","../../../node_modules/property-information/lib/svg.js","../../../node_modules/property-information/index.js","../../../node_modules/react-markdown/lib/rehype-filter.js","../../../node_modules/react-markdown/lib/uri-transformer.js","../../../node_modules/hast-util-whitespace/index.js","../../../node_modules/property-information/lib/find.js","../../../node_modules/property-information/lib/hast-to-react.js","../../../node_modules/react-markdown/lib/ast-to-react.js","../../../node_modules/comma-separated-tokens/index.js","../../../node_modules/space-separated-tokens/index.js","../../../node_modules/react-markdown/lib/react-markdown.js","../../../node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.js","../../../node_modules/micromark-extension-gfm-footnote/lib/syntax.js","../../../node_modules/micromark-extension-gfm-strikethrough/lib/syntax.js","../../../node_modules/micromark-extension-gfm-table/lib/edit-map.js","../../../node_modules/micromark-extension-gfm-table/lib/infer.js","../../../node_modules/micromark-extension-gfm-table/lib/syntax.js","../../../node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js","../../../node_modules/micromark-extension-gfm/index.js","../../../node_modules/ccount/index.js","../../../node_modules/mdast-util-find-and-replace/lib/index.js","../../../node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp/index.js","../../../node_modules/mdast-util-gfm-autolink-literal/lib/index.js","../../../node_modules/mdast-util-to-markdown/lib/util/association.js","../../../node_modules/mdast-util-to-markdown/lib/util/container-flow.js","../../../node_modules/mdast-util-to-markdown/lib/util/indent-lines.js","../../../node_modules/mdast-util-to-markdown/lib/util/pattern-compile.js","../../../node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.js","../../../node_modules/mdast-util-to-markdown/lib/util/safe.js","../../../node_modules/mdast-util-to-markdown/lib/util/track.js","../../../node_modules/mdast-util-gfm-footnote/lib/index.js","../../../node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js","../../../node_modules/mdast-util-gfm-strikethrough/lib/index.js","../../../node_modules/mdast-util-to-markdown/lib/handle/inline-code.js","../../../node_modules/markdown-table/index.js","../../../node_modules/mdast-util-gfm-table/lib/index.js","../../../node_modules/mdast-util-to-markdown/lib/handle/list-item.js","../../../node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js","../../../node_modules/mdast-util-to-markdown/lib/util/check-bullet.js","../../../node_modules/mdast-util-gfm-task-list-item/lib/index.js","../../../node_modules/mdast-util-gfm/lib/index.js","../../../node_modules/remark-gfm/index.js","../../../node_modules/unist-util-is/lib/index.js","../../../node_modules/unist-util-visit-parents/lib/index.js"],"sourcesContent":["/*!\n\tCopyright (c) 2018 Jed Watson.\n\tLicensed under the MIT License (MIT), see\n\thttp://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\tvar nativeCodeString = '[native code]';\n\n\tfunction classNames() {\n\t\tvar classes = [];\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (!arg) continue;\n\n\t\t\tvar argType = typeof arg;\n\n\t\t\tif (argType === 'string' || argType === 'number') {\n\t\t\t\tclasses.push(arg);\n\t\t\t} else if (Array.isArray(arg)) {\n\t\t\t\tif (arg.length) {\n\t\t\t\t\tvar inner = classNames.apply(null, arg);\n\t\t\t\t\tif (inner) {\n\t\t\t\t\t\tclasses.push(inner);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else if (argType === 'object') {\n\t\t\t\tif (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes('[native code]')) {\n\t\t\t\t\tclasses.push(arg.toString());\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tfor (var key in arg) {\n\t\t\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\t\t\tclasses.push(key);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn classes.join(' ');\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n","'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 * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n\nmodule.exports = function isBuffer (obj) {\n  return obj != null && obj.constructor != null &&\n    typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)\n}\n","/**\n * @license React\n * react-is.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 b=Symbol.for(\"react.element\"),c=Symbol.for(\"react.portal\"),d=Symbol.for(\"react.fragment\"),e=Symbol.for(\"react.strict_mode\"),f=Symbol.for(\"react.profiler\"),g=Symbol.for(\"react.provider\"),h=Symbol.for(\"react.context\"),k=Symbol.for(\"react.server_context\"),l=Symbol.for(\"react.forward_ref\"),m=Symbol.for(\"react.suspense\"),n=Symbol.for(\"react.suspense_list\"),p=Symbol.for(\"react.memo\"),q=Symbol.for(\"react.lazy\"),t=Symbol.for(\"react.offscreen\"),u;u=Symbol.for(\"react.module.reference\");\nfunction v(a){if(\"object\"===typeof a&&null!==a){var r=a.$$typeof;switch(r){case b:switch(a=a.type,a){case d:case f:case e:case m:case n:return a;default:switch(a=a&&a.$$typeof,a){case k:case h:case l:case q:case p:case g:return a;default:return r}}case c:return r}}}exports.ContextConsumer=h;exports.ContextProvider=g;exports.Element=b;exports.ForwardRef=l;exports.Fragment=d;exports.Lazy=q;exports.Memo=p;exports.Portal=c;exports.Profiler=f;exports.StrictMode=e;exports.Suspense=m;\nexports.SuspenseList=n;exports.isAsyncMode=function(){return!1};exports.isConcurrentMode=function(){return!1};exports.isContextConsumer=function(a){return v(a)===h};exports.isContextProvider=function(a){return v(a)===g};exports.isElement=function(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===b};exports.isForwardRef=function(a){return v(a)===l};exports.isFragment=function(a){return v(a)===d};exports.isLazy=function(a){return v(a)===q};exports.isMemo=function(a){return v(a)===p};\nexports.isPortal=function(a){return v(a)===c};exports.isProfiler=function(a){return v(a)===f};exports.isStrictMode=function(a){return v(a)===e};exports.isSuspense=function(a){return v(a)===m};exports.isSuspenseList=function(a){return v(a)===n};\nexports.isValidElementType=function(a){return\"string\"===typeof a||\"function\"===typeof a||a===d||a===f||a===e||a===m||a===n||a===t||\"object\"===typeof a&&null!==a&&(a.$$typeof===q||a.$$typeof===p||a.$$typeof===g||a.$$typeof===h||a.$$typeof===l||a.$$typeof===u||void 0!==a.getModuleId)?!0:!1};exports.typeOf=v;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.min.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}\n","var parse = require('inline-style-parser');\n\n/**\n * Parses inline style to object.\n *\n * @example\n * // returns { 'line-height': '42' }\n * StyleToObject('line-height: 42;');\n *\n * @param  {String}      style      - The inline style.\n * @param  {Function}    [iterator] - The iterator function.\n * @return {null|Object}\n */\nfunction StyleToObject(style, iterator) {\n  var output = null;\n  if (!style || typeof style !== 'string') {\n    return output;\n  }\n\n  var declaration;\n  var declarations = parse(style);\n  var hasIterator = typeof iterator === 'function';\n  var property;\n  var value;\n\n  for (var i = 0, len = declarations.length; i < len; i++) {\n    declaration = declarations[i];\n    property = declaration.property;\n    value = declaration.value;\n\n    if (hasIterator) {\n      iterator(property, value, declaration);\n    } else if (value) {\n      output || (output = {});\n      output[property] = value;\n    }\n  }\n\n  return output;\n}\n\nmodule.exports = StyleToObject;\n","/// <reference lib=\"dom\" />\n\n/* eslint-env browser */\n\nconst element = document.createElement('i')\n\n/**\n * @param {string} value\n * @returns {string|false}\n */\nexport function decodeNamedCharacterReference(value) {\n  const characterReference = '&' + value + ';'\n  element.innerHTML = characterReference\n  const char = element.textContent\n\n  // Some named character references do not require the closing semicolon\n  // (`&not`, for instance), which leads to situations where parsing the assumed\n  // named reference of `&notit;` will result in the string `¬it;`.\n  // When we encounter a trailing semicolon after parsing, and the character\n  // reference to decode was not a semicolon (`&semi;`), we can assume that the\n  // matching was not complete.\n  // @ts-expect-error: TypeScript is wrong that `textContent` on elements can\n  // yield `null`.\n  if (char.charCodeAt(char.length - 1) === 59 /* `;` */ && value !== 'semi') {\n    return false\n  }\n\n  // If the decoded string is equal to the input, the character reference was\n  // not valid.\n  // @ts-expect-error: TypeScript is wrong that `textContent` on elements can\n  // yield `null`.\n  return char === characterReference ? false : char\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nexport const blankLine = {\n  tokenize: tokenizeBlankLine,\n  partial: true\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return start\n\n  /**\n   * Start of blank line.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *     ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    return markdownSpace(code)\n      ? factorySpace(effects, after, 'linePrefix')(code)\n      : 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","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {markdownSpace} from 'micromark-util-character'\n\n// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.\n\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   spaces in markdown are often optional, in which case this factory can be\n *     used and `ok` will be switched to whether spaces were found or not\n * *   one line ending or space can be detected with `markdownSpace(code)` right\n *     before using `factorySpace`\n *\n * ###### Examples\n *\n * Where `␉` represents a tab (plus how much it expands) and `␠` represents a\n * single space.\n *\n * ```markdown\n * ␉\n * ␠␠␠␠\n * ␉␠\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {TokenType} type\n *   Type (`' \\t'`).\n * @param {number | undefined} [max=Infinity]\n *   Max (exclusive).\n * @returns\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","// This module is generated by `script/`.\n//\n// CommonMark handles attention (emphasis, strong) markers based on what comes\n// before or after them.\n// One such difference is if those characters are Unicode punctuation.\n// This script is generated from the Unicode data.\n\n/**\n * Regular expression that matches a unicode punctuation character.\n */\nexport const unicodePunctuationRegex =\n  /[!-\\/:-@\\[-`\\{-~\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061D-\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1B7D\\u1B7E\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52-\\u2E5D\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\n\nimport {unicodePunctuationRegex} from './lib/unicode-punctuation-regex.js'\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\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\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\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\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\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\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(unicodePunctuationRegex)\n\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/)\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n * @returns {(code: Code) => boolean}\n */\nfunction regexCheck(regex) {\n  return check\n\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code\n   *   Character code.\n   * @returns {boolean}\n   *   Whether the character code matches the bound regex.\n   */\n  function check(code) {\n    return code !== null && regex.test(String.fromCharCode(code))\n  }\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 {void}\n *   Nothing.\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length\n  let chunkStart = 0\n  /** @type {Array<unknown>} */\n  let parameters\n\n  // Make start between zero and `end` (included).\n  if (start < 0) {\n    start = -start > end ? 0 : end + start\n  } else {\n    start = start > end ? end : start\n  }\n  remove = remove > 0 ? remove : 0\n\n  // No need to chunk the items if there’s only a couple (10k) items.\n  if (items.length < 10000) {\n    parameters = Array.from(items)\n    parameters.unshift(start, remove)\n    // @ts-expect-error Hush, it’s fine.\n    list.splice(...parameters)\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) list.splice(start, remove)\n\n    // Insert the items in chunks to not cause stack overflows.\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000)\n      parameters.unshift(start, 0)\n      // @ts-expect-error Hush, it’s fine.\n      list.splice(...parameters)\n      chunkStart += 10000\n      start += 10000\n    }\n  }\n}\n\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {Array<T>} items\n *   Items to add to `list`.\n * @returns {Array<T>}\n *   Either `list` or `items`.\n */\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items)\n    return list\n  }\n  return items\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\n\nimport {\n  markdownLineEndingOrSpace,\n  unicodePunctuation,\n  unicodeWhitespace\n} from 'micromark-util-character'\n/**\n * Classify whether a code represents whitespace, punctuation, or something\n * else.\n *\n * Used for attention (emphasis, strong), whose sequences can open or close\n * based on the class of surrounding characters.\n *\n * > 👉 **Note**: eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n *   Code.\n * @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined}\n *   Group.\n */\nexport function classifyCharacter(code) {\n  if (\n    code === null ||\n    markdownLineEndingOrSpace(code) ||\n    unicodeWhitespace(code)\n  ) {\n    return 1\n  }\n  if (unicodePunctuation(code)) {\n    return 2\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Handles} Handles\n * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension\n * @typedef {import('micromark-util-types').NormalizedExtension} NormalizedExtension\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine multiple syntax extensions into one.\n *\n * @param {Array<Extension>} extensions\n *   List of syntax extensions.\n * @returns {NormalizedExtension}\n *   A single combined extension.\n */\nexport function combineExtensions(extensions) {\n  /** @type {NormalizedExtension} */\n  const all = {}\n  let index = -1\n\n  while (++index < extensions.length) {\n    syntaxExtension(all, extensions[index])\n  }\n\n  return all\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {NormalizedExtension} all\n *   Extension to merge into.\n * @param {Extension} extension\n *   Extension to merge.\n * @returns {void}\n */\nfunction syntaxExtension(all, extension) {\n  /** @type {keyof Extension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    /** @type {Record<string, unknown>} */\n    const left = maybe || (all[hook] = {})\n    /** @type {Record<string, unknown> | undefined} */\n    const right = extension[hook]\n    /** @type {string} */\n    let code\n\n    if (right) {\n      for (code in right) {\n        if (!hasOwnProperty.call(left, code)) left[code] = []\n        const value = right[code]\n        constructs(\n          // @ts-expect-error Looks like a list.\n          left[code],\n          Array.isArray(value) ? value : value ? [value] : []\n        )\n      }\n    }\n  }\n}\n\n/**\n * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {Array<unknown>} existing\n * @param {Array<unknown>} list\n * @returns {void}\n */\nfunction constructs(existing, list) {\n  let index = -1\n  /** @type {Array<unknown>} */\n  const before = []\n\n  while (++index < list.length) {\n    // @ts-expect-error Looks like an object.\n    ;(list[index].add === 'after' ? existing : before).push(list[index])\n  }\n\n  splice(existing, 0, 0, before)\n}\n\n/**\n * Combine multiple HTML extensions into one.\n *\n * @param {Array<HtmlExtension>} htmlExtensions\n *   List of HTML extensions.\n * @returns {HtmlExtension}\n *   A single combined HTML extension.\n */\nexport function combineHtmlExtensions(htmlExtensions) {\n  /** @type {HtmlExtension} */\n  const handlers = {}\n  let index = -1\n\n  while (++index < htmlExtensions.length) {\n    htmlExtension(handlers, htmlExtensions[index])\n  }\n\n  return handlers\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {HtmlExtension} all\n *   Extension to merge into.\n * @param {HtmlExtension} extension\n *   Extension to merge.\n * @returns {void}\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 * 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.fromCharCode(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 ||\n    code === 11 ||\n    (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 > 55295 && code < 57344) ||\n    // Noncharacters.\n    (code > 64975 && code < 65008) /* eslint-disable no-bitwise */ ||\n    (code & 65535) === 65535 ||\n    (code & 65535) === 65534 /* eslint-enable no-bitwise */ ||\n    // Out of range\n    code > 1114111\n  ) {\n    return '\\uFFFD'\n  }\n  return String.fromCharCode(code)\n}\n","import {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {decodeNumericCharacterReference} from 'micromark-util-decode-numeric-character-reference'\nconst characterEscapeOrReference =\n  /\\\\([!-/:-@[-`{-~])|&(#(?:\\d{1,7}|x[\\da-f]{1,6})|[\\da-z]{1,31});/gi\n\n/**\n * Decode markdown strings (which occur in places such as fenced code info\n * strings, destinations, labels, and titles).\n *\n * The “string” content type allows character escapes and -references.\n * This decodes those.\n *\n * @param {string} value\n *   Value to decode.\n * @returns {string}\n *   Decoded value.\n */\nexport function decodeString(value) {\n  return value.replace(characterEscapeOrReference, decode)\n}\n\n/**\n * @param {string} $0\n * @param {string} $1\n * @param {string} $2\n * @returns {string}\n */\nfunction decode($0, $1, $2) {\n  if ($1) {\n    // Escape.\n    return $1\n  }\n\n  // Reference.\n  const head = $2.charCodeAt(0)\n  if (head === 35) {\n    const head = $2.charCodeAt(1)\n    const hex = head === 120 || head === 88\n    return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10)\n  }\n  return decodeNamedCharacterReference($2) || $0\n}\n","/**\n * Normalize an identifier (as found in references, definitions).\n *\n * Collapses markdown whitespace, trim, and then lower- and uppercase.\n *\n * Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their\n * lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different\n * uppercase character (U+0398 (`Θ`)).\n * So, to get a canonical form, we perform both lower- and uppercase.\n *\n * Using uppercase last makes sure keys will never interact with default\n * prototypal values (such as `constructor`): nothing in the prototype of\n * `Object` is uppercase.\n *\n * @param {string} value\n *   Identifier to normalize.\n * @returns {string}\n *   Normalized identifier.\n */\nexport function normalizeIdentifier(value) {\n  return (\n    value\n      // Collapse markdown whitespace.\n      .replace(/[\\t\\n\\r ]+/g, ' ')\n      // Trim.\n      .replace(/^ | $/g, '')\n      // Some characters are considered “uppercase”, but if their lowercase\n      // counterpart is uppercased will result in a different uppercase\n      // character.\n      // Hence, to get that form, we perform both lower- and uppercase.\n      // Upper case makes sure keys will not interact with default prototypal\n      // methods: no method is uppercase.\n      .toLowerCase()\n      .toUpperCase()\n  )\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {Array<{resolveAll?: Resolver | undefined}>} constructs\n *   List of constructs, optionally with `resolveAll`s.\n * @param {Array<Event>} events\n *   List of events.\n * @param {TokenizeContext} context\n *   Context used by `tokenize`.\n * @returns {Array<Event>}\n *   Changed events.\n */\nexport function resolveAll(constructs, events, context) {\n  /** @type {Array<Resolver>} */\n  const called = []\n  let index = -1\n\n  while (++index < constructs.length) {\n    const resolve = constructs[index].resolveAll\n\n    if (resolve && !called.includes(resolve)) {\n      events = resolve(events, context)\n      called.push(resolve)\n    }\n  }\n\n  return events\n}\n","/**\n * @typedef {import('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 * Serialize the positional info of a point, position (start and end points),\n * or node.\n *\n * @param {Node | NodeLike | Position | PositionLike | Point | PointLike | 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').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {object & {type: string, position?: Position | undefined}} NodeLike\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` at `place` from `origin`.\n   *\n   * When an error is passed in as `reason`, the `stack` is copied.\n   *\n   * @param {string | Error | VFileMessage} reason\n   *   Reason for message, uses the stack and message of the error if given.\n   *\n   *   > 👉 **Note**: you should use markdown.\n   * @param {Node | NodeLike | Position | Point | null | undefined} [place]\n   *   Place in file where the message occurred.\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  // To do: next major: expose `undefined` everywhere instead of `null`.\n  constructor(reason, place, origin) {\n    /** @type {[string | null, string | null]} */\n    const parts = [null, null]\n    /** @type {Position} */\n    let position = {\n      // @ts-expect-error: we always follows the structure of `position`.\n      start: {line: null, column: null},\n      // @ts-expect-error: \"\n      end: {line: null, column: null}\n    }\n\n    super()\n\n    if (typeof place === 'string') {\n      origin = place\n      place = undefined\n    }\n\n    if (typeof origin === 'string') {\n      const index = origin.indexOf(':')\n\n      if (index === -1) {\n        parts[1] = origin\n      } else {\n        parts[0] = origin.slice(0, index)\n        parts[1] = origin.slice(index + 1)\n      }\n    }\n\n    if (place) {\n      // Node.\n      if ('type' in place || 'position' in place) {\n        if (place.position) {\n          // To do: next major: deep clone.\n          // @ts-expect-error: looks like a position.\n          position = place.position\n        }\n      }\n      // Position.\n      else if ('start' in place || 'end' in place) {\n        // @ts-expect-error: looks like a position.\n        // To do: next major: deep clone.\n        position = place\n      }\n      // Point.\n      else if ('line' in place || 'column' in place) {\n        // To do: next major: deep clone.\n        position.start = place\n      }\n    }\n\n    // Fields from `Error`.\n    /**\n     * Serialized positional info of error.\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(place) || '1:1'\n\n    /**\n     * Reason for message.\n     *\n     * @type {string}\n     */\n    this.message = typeof reason === 'object' ? reason.message : reason\n\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\n    if (typeof reason === 'object' && reason.stack) {\n      this.stack = reason.stack\n    }\n\n    /**\n     * Reason for message.\n     *\n     * > 👉 **Note**: you should use markdown.\n     *\n     * @type {string}\n     */\n    this.reason = this.message\n\n    /* eslint-disable no-unused-expressions */\n    /**\n     * State of problem.\n     *\n     * * `true` — marks associated file as no longer processable (error)\n     * * `false` — necessitates a (potential) change (warning)\n     * * `null | undefined` — for things that might not need changing (info)\n     *\n     * @type {boolean | null | undefined}\n     */\n    this.fatal\n\n    /**\n     * Starting line of error.\n     *\n     * @type {number | null}\n     */\n    this.line = position.start.line\n\n    /**\n     * Starting column of error.\n     *\n     * @type {number | null}\n     */\n    this.column = position.start.column\n\n    /**\n     * Full unist position.\n     *\n     * @type {Position | null}\n     */\n    this.position = position\n\n    /**\n     * Namespace of message (example: `'my-package'`).\n     *\n     * @type {string | null}\n     */\n    this.source = parts[0]\n\n    /**\n     * Category of message (example: `'my-rule'`).\n     *\n     * @type {string | null}\n     */\n    this.ruleId = parts[1]\n\n    /**\n     * Path of a file (used throughout the `VFile` ecosystem).\n     *\n     * @type {string | null}\n     */\n    this.file\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 | null}\n     */\n    this.actual\n\n    /**\n     * Suggest acceptable values that can be used instead of `actual`.\n     *\n     * @type {Array<string> | null}\n     */\n    this.expected\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 | null}\n     */\n    this.url\n\n    /**\n     * Long form description of the message (you should use markdown).\n     *\n     * @type {string | null}\n     */\n    this.note\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.fatal = null\nVFileMessage.prototype.column = null\nVFileMessage.prototype.line = null\nVFileMessage.prototype.source = null\nVFileMessage.prototype.ruleId = null\nVFileMessage.prototype.position = null\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 path = {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 | undefined} [ext]\n *   Extension to strip.\n * @returns {string}\n *   Stem or basename.\n */\nfunction basename(path, ext) {\n  if (ext !== undefined && typeof ext !== '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 (ext === undefined || ext.length === 0 || ext.length > path.length) {\n    while (index--) {\n      if (path.charCodeAt(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 (ext === path) {\n    return ''\n  }\n\n  let firstNonSlashEnd = -1\n  let extIndex = ext.length - 1\n\n  while (index--) {\n    if (path.charCodeAt(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 (extIndex > -1) {\n        // Try to match the explicit extension.\n        if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) {\n          if (extIndex < 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          extIndex = -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.charCodeAt(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.charCodeAt(0) === 47 /* `/` */\n      ? '/'\n      : '.'\n    : end === 1 && path.charCodeAt(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.charCodeAt(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.charCodeAt(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.charCodeAt(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.charCodeAt(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.charCodeAt(result.length - 1) !== 46 /* `.` */ ||\n          result.charCodeAt(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 proc = {cwd}\n\nfunction cwd() {\n  return '/'\n}\n","/**\n * @typedef URL\n * @property {string} hash\n * @property {string} host\n * @property {string} hostname\n * @property {string} href\n * @property {string} origin\n * @property {string} password\n * @property {string} pathname\n * @property {string} port\n * @property {string} protocol\n * @property {string} search\n * @property {any} searchParams\n * @property {string} username\n * @property {() => string} toString\n * @property {() => string} toJSON\n */\n\n/**\n * Check if `fileUrlOrPath` looks like a URL.\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/fcf8ba4/lib/internal/url.js#L1501>\nexport function isUrl(fileUrlOrPath) {\n  return (\n    fileUrlOrPath !== null &&\n    typeof fileUrlOrPath === 'object' &&\n    // @ts-expect-error: indexable.\n    fileUrlOrPath.href &&\n    // @ts-expect-error: indexable.\n    fileUrlOrPath.origin\n  )\n}\n","/// <reference lib=\"dom\" />\n\nimport {isUrl} from './minurl.shared.js'\n\n// See: <https://github.com/nodejs/node/blob/fcf8ba4/lib/internal/url.js>\n\n/**\n * @param {string | URL} 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.charCodeAt(index) === 37 /* `%` */ &&\n      pathname.charCodeAt(index + 1) === 50 /* `2` */\n    ) {\n      const third = pathname.charCodeAt(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\nexport {isUrl} from './minurl.shared.js'\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {import('./minurl.shared.js').URL} URL\n * @typedef {import('../index.js').Data} Data\n * @typedef {import('../index.js').Value} Value\n */\n\n/**\n * @typedef {Record<string, unknown> & {type: string, position?: Position | undefined}} NodeLike\n *\n * @typedef {'ascii' | 'utf8' | 'utf-8' | 'utf16le' | 'ucs2' | 'ucs-2' | 'base64' | 'base64url' | 'latin1' | 'binary' | 'hex'} BufferEncoding\n *   Encodings supported by the buffer class.\n *\n *   This is a copy of the types from Node, copied to prevent Node globals from\n *   being needed.\n *   Copied from: <https://github.com/DefinitelyTyped/DefinitelyTyped/blob/90a4ec8/types/node/buffer.d.ts#L170>\n *\n * @typedef {Options | URL | Value | VFile} Compatible\n *   Things that can be passed to the constructor.\n *\n * @typedef VFileCoreOptions\n *   Set multiple values.\n * @property {Value | null | undefined} [value]\n *   Set `value`.\n * @property {string | null | undefined} [cwd]\n *   Set `cwd`.\n * @property {Array<string> | null | undefined} [history]\n *   Set `history`.\n * @property {URL | string | null | undefined} [path]\n *   Set `path`.\n * @property {string | null | undefined} [basename]\n *   Set `basename`.\n * @property {string | null | undefined} [stem]\n *   Set `stem`.\n * @property {string | null | undefined} [extname]\n *   Set `extname`.\n * @property {string | null | undefined} [dirname]\n *   Set `dirname`.\n * @property {Data | null | undefined} [data]\n *   Set `data`.\n *\n * @typedef Map\n *   Raw source map.\n *\n *   See:\n *   <https://github.com/mozilla/source-map/blob/58819f0/source-map.d.ts#L15-L23>.\n * @property {number} version\n *   Which version of the source map spec this map is following.\n * @property {Array<string>} sources\n *   An array of URLs to the original source files.\n * @property {Array<string>} names\n *   An array of identifiers which can be referenced by individual mappings.\n * @property {string | undefined} [sourceRoot]\n *   The URL root from which all sources are relative.\n * @property {Array<string> | undefined} [sourcesContent]\n *   An array of contents of the original source files.\n * @property {string} mappings\n *   A string of base64 VLQs which contain the actual mappings.\n * @property {string} file\n *   The generated file this source map is associated with.\n *\n * @typedef {{[key: string]: unknown} & VFileCoreOptions} Options\n *   Configuration.\n *\n *   A bunch of keys that will be shallow copied over to the new file.\n *\n * @typedef {Record<string, unknown>} ReporterSettings\n *   Configuration for reporters.\n */\n\n/**\n * @template {ReporterSettings} Settings\n *   Options type.\n * @callback Reporter\n *   Type for a reporter.\n * @param {Array<VFile>} files\n *   Files to report.\n * @param {Settings} options\n *   Configuration.\n * @returns {string}\n *   Report.\n */\n\nimport bufferLike from 'is-buffer'\nimport {VFileMessage} from 'vfile-message'\nimport {path} from './minpath.js'\nimport {proc} from './minproc.js'\nimport {urlToPath, isUrl} from './minurl.js'\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 *\n * @type {Array<'basename' | 'dirname' | 'extname' | 'history' | 'path' | 'stem'>}\n */\nconst order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname']\n\nexport class VFile {\n  /**\n   * Create a new virtual file.\n   *\n   * `options` is treated as:\n   *\n   * *   `string` or `Buffer` — `{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 (typeof value === 'string' || buffer(value)) {\n      options = {value}\n    } else if (isUrl(value)) {\n      options = {path: value}\n    } else {\n      options = value\n    }\n\n    /**\n     * Place to store custom information (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 messages associated with the file.\n     *\n     * @type {Array<VFileMessage>}\n     */\n    this.messages = []\n\n    /**\n     * List of filepaths 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     * Base of `path` (default: `process.cwd()` or `'/'` in browsers).\n     *\n     * @type {string}\n     */\n    this.cwd = proc.cwd()\n\n    /* eslint-disable no-unused-expressions */\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    /**\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\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     * 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    /* 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 prop = order[index]\n\n      // Note: we specifically use `in` instead of `hasOwnProperty` to accept\n      // `vfile`s too.\n      if (\n        prop in options &&\n        options[prop] !== undefined &&\n        options[prop] !== null\n      ) {\n        // @ts-expect-error: TS doesn’t understand basic reality.\n        this[prop] = prop === 'history' ? [...options[prop]] : options[prop]\n      }\n    }\n\n    /** @type {string} */\n    let prop\n\n    // Set non-path related properties.\n    for (prop in options) {\n      // @ts-expect-error: fine to set other things.\n      if (!order.includes(prop)) {\n        // @ts-expect-error: fine to set other things.\n        this[prop] = options[prop]\n      }\n    }\n  }\n\n  /**\n   * Get the full path (example: `'~/index.min.js'`).\n   *\n   * @returns {string}\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 {string | URL} path\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 parent path (example: `'~'`).\n   */\n  get dirname() {\n    return typeof this.path === 'string' ? path.dirname(this.path) : undefined\n  }\n\n  /**\n   * Set the parent path (example: `'~'`).\n   *\n   * Cannot be set if there’s no `path` yet.\n   */\n  set dirname(dirname) {\n    assertPath(this.basename, 'dirname')\n    this.path = path.join(dirname || '', this.basename)\n  }\n\n  /**\n   * Get the basename (including extname) (example: `'index.min.js'`).\n   */\n  get basename() {\n    return typeof this.path === 'string' ? path.basename(this.path) : 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  set basename(basename) {\n    assertNonEmpty(basename, 'basename')\n    assertPart(basename, 'basename')\n    this.path = path.join(this.dirname || '', basename)\n  }\n\n  /**\n   * Get the extname (including dot) (example: `'.js'`).\n   */\n  get extname() {\n    return typeof this.path === 'string' ? path.extname(this.path) : 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  set extname(extname) {\n    assertPart(extname, 'extname')\n    assertPath(this.dirname, 'extname')\n\n    if (extname) {\n      if (extname.charCodeAt(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 = path.join(this.dirname, this.stem + (extname || ''))\n  }\n\n  /**\n   * Get the stem (basename w/o extname) (example: `'index.min'`).\n   */\n  get stem() {\n    return typeof this.path === 'string'\n      ? path.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  set stem(stem) {\n    assertNonEmpty(stem, 'stem')\n    assertPart(stem, 'stem')\n    this.path = path.join(this.dirname || '', stem + (this.extname || ''))\n  }\n\n  /**\n   * Serialize the file.\n   *\n   * @param {BufferEncoding | null | undefined} [encoding='utf8']\n   *   Character encoding to understand `value` as when it’s a `Buffer`\n   *   (default: `'utf8'`).\n   * @returns {string}\n   *   Serialized file.\n   */\n  toString(encoding) {\n    return (this.value || '').toString(encoding || undefined)\n  }\n\n  /**\n   * Create a warning message associated with the file.\n   *\n   * Its `fatal` is set to `false` and `file` is set to the current file path.\n   * Its added to `file.messages`.\n   *\n   * @param {string | Error | VFileMessage} reason\n   *   Reason for message, uses the stack and message of the error if given.\n   * @param {Node | NodeLike | Position | Point | null | undefined} [place]\n   *   Place in file where the message occurred.\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(reason, place, origin) {\n    const message = new VFileMessage(reason, place, origin)\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   * Create an info message associated with the file.\n   *\n   * Its `fatal` is set to `null` and `file` is set to the current file path.\n   * Its added to `file.messages`.\n   *\n   * @param {string | Error | VFileMessage} reason\n   *   Reason for message, uses the stack and message of the error if given.\n   * @param {Node | NodeLike | Position | Point | null | undefined} [place]\n   *   Place in file where the message occurred.\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(reason, place, origin) {\n    const message = this.message(reason, place, origin)\n\n    message.fatal = null\n\n    return message\n  }\n\n  /**\n   * Create a fatal error associated with the file.\n   *\n   * Its `fatal` is set to `true` and `file` is set to the current file path.\n   * Its added to `file.messages`.\n   *\n   * > 👉 **Note**: a fatal error means that a file is no longer processable.\n   *\n   * @param {string | Error | VFileMessage} reason\n   *   Reason for message, uses the stack and message of the error if given.\n   * @param {Node | NodeLike | Position | Point | null | undefined} [place]\n   *   Place in file where the message occurred.\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   *   Message.\n   * @throws {VFileMessage}\n   *   Message.\n   */\n  fail(reason, place, origin) {\n    const message = this.message(reason, place, origin)\n\n    message.fatal = true\n\n    throw message\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 {void}\n *   Nothing.\n */\nfunction assertPart(part, name) {\n  if (part && part.includes(path.sep)) {\n    throw new Error(\n      '`' + name + '` cannot be a path: did not expect `' + path.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 a buffer.\n *\n * @param {unknown} value\n *   thing.\n * @returns {value is Buffer}\n *   Whether `value` is a Node.js buffer.\n */\nfunction buffer(value) {\n  return bufferLike(value)\n}\n","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArray from \"./iterableToArray.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nexport default function _toArray(arr) {\n  return arrayWithHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableRest();\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","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('vfile').VFileCompatible} VFileCompatible\n * @typedef {import('vfile').VFileValue} VFileValue\n * @typedef {import('..').Processor} Processor\n * @typedef {import('..').Plugin} Plugin\n * @typedef {import('..').Preset} Preset\n * @typedef {import('..').Pluggable} Pluggable\n * @typedef {import('..').PluggableList} PluggableList\n * @typedef {import('..').Transformer} Transformer\n * @typedef {import('..').Parser} Parser\n * @typedef {import('..').Compiler} Compiler\n * @typedef {import('..').RunCallback} RunCallback\n * @typedef {import('..').ProcessCallback} ProcessCallback\n *\n * @typedef Context\n * @property {Node} tree\n * @property {VFile} file\n */\n\nimport {bail} from 'bail'\nimport isBuffer from 'is-buffer'\nimport extend from 'extend'\nimport isPlainObj from 'is-plain-obj'\nimport {trough} from 'trough'\nimport {VFile} from 'vfile'\n\n// Expose a frozen processor.\nexport const unified = base().freeze()\n\nconst own = {}.hasOwnProperty\n\n// Function to create the first processor.\n/**\n * @returns {Processor}\n */\nfunction base() {\n  const transformers = trough()\n  /** @type {Processor['attachers']} */\n  const attachers = []\n  /** @type {Record<string, unknown>} */\n  let namespace = {}\n  /** @type {boolean|undefined} */\n  let frozen\n  let freezeIndex = -1\n\n  // Data management.\n  // @ts-expect-error: overloads are handled.\n  processor.data = data\n  processor.Parser = undefined\n  processor.Compiler = undefined\n\n  // Lock.\n  processor.freeze = freeze\n\n  // Plugins.\n  processor.attachers = attachers\n  // @ts-expect-error: overloads are handled.\n  processor.use = use\n\n  // API.\n  processor.parse = parse\n  processor.stringify = stringify\n  // @ts-expect-error: overloads are handled.\n  processor.run = run\n  processor.runSync = runSync\n  // @ts-expect-error: overloads are handled.\n  processor.process = process\n  processor.processSync = processSync\n\n  // Expose.\n  return processor\n\n  // Create a new processor based on the processor in the current scope.\n  /** @type {Processor} */\n  function processor() {\n    const destination = base()\n    let index = -1\n\n    while (++index < attachers.length) {\n      destination.use(...attachers[index])\n    }\n\n    destination.data(extend(true, {}, namespace))\n\n    return destination\n  }\n\n  /**\n   * @param {string|Record<string, unknown>} [key]\n   * @param {unknown} [value]\n   * @returns {unknown}\n   */\n  function data(key, value) {\n    if (typeof key === 'string') {\n      // Set `key`.\n      if (arguments.length === 2) {\n        assertUnfrozen('data', frozen)\n        namespace[key] = value\n        return processor\n      }\n\n      // Get `key`.\n      return (own.call(namespace, key) && namespace[key]) || null\n    }\n\n    // Set space.\n    if (key) {\n      assertUnfrozen('data', frozen)\n      namespace = key\n      return processor\n    }\n\n    // Get space.\n    return namespace\n  }\n\n  /** @type {Processor['freeze']} */\n  function freeze() {\n    if (frozen) {\n      return processor\n    }\n\n    while (++freezeIndex < attachers.length) {\n      const [attacher, ...options] = attachers[freezeIndex]\n\n      if (options[0] === false) {\n        continue\n      }\n\n      if (options[0] === true) {\n        options[0] = undefined\n      }\n\n      /** @type {Transformer|void} */\n      const transformer = attacher.call(processor, ...options)\n\n      if (typeof transformer === 'function') {\n        transformers.use(transformer)\n      }\n    }\n\n    frozen = true\n    freezeIndex = Number.POSITIVE_INFINITY\n\n    return processor\n  }\n\n  /**\n   * @param {Pluggable|null|undefined} [value]\n   * @param {...unknown} options\n   * @returns {Processor}\n   */\n  function use(value, ...options) {\n    /** @type {Record<string, unknown>|undefined} */\n    let settings\n\n    assertUnfrozen('use', frozen)\n\n    if (value === null || value === undefined) {\n      // Empty.\n    } else if (typeof value === 'function') {\n      addPlugin(value, ...options)\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    if (settings) {\n      namespace.settings = Object.assign(namespace.settings || {}, settings)\n    }\n\n    return processor\n\n    /**\n     * @param {import('..').Pluggable<unknown[]>} value\n     * @returns {void}\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, ...options] = value\n          addPlugin(plugin, ...options)\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 {void}\n     */\n    function addPreset(result) {\n      addList(result.plugins)\n\n      if (result.settings) {\n        settings = Object.assign(settings || {}, result.settings)\n      }\n    }\n\n    /**\n     * @param {PluggableList|null|undefined} [plugins]\n     * @returns {void}\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 {...unknown} [value]\n     * @returns {void}\n     */\n    function addPlugin(plugin, value) {\n      let index = -1\n      /** @type {Processor['attachers'][number]|undefined} */\n      let entry\n\n      while (++index < attachers.length) {\n        if (attachers[index][0] === plugin) {\n          entry = attachers[index]\n          break\n        }\n      }\n\n      if (entry) {\n        if (isPlainObj(entry[1]) && isPlainObj(value)) {\n          value = extend(true, entry[1], value)\n        }\n\n        entry[1] = value\n      } else {\n        // @ts-expect-error: fine.\n        attachers.push([...arguments])\n      }\n    }\n  }\n\n  /** @type {Processor['parse']} */\n  function parse(doc) {\n    processor.freeze()\n    const file = vfile(doc)\n    const Parser = processor.Parser\n    assertParser('parse', Parser)\n\n    if (newable(Parser, 'parse')) {\n      // @ts-expect-error: `newable` checks this.\n      return new Parser(String(file), file).parse()\n    }\n\n    // @ts-expect-error: `newable` checks this.\n    return Parser(String(file), file) // eslint-disable-line new-cap\n  }\n\n  /** @type {Processor['stringify']} */\n  function stringify(node, doc) {\n    processor.freeze()\n    const file = vfile(doc)\n    const Compiler = processor.Compiler\n    assertCompiler('stringify', Compiler)\n    assertNode(node)\n\n    if (newable(Compiler, 'compile')) {\n      // @ts-expect-error: `newable` checks this.\n      return new Compiler(node, file).compile()\n    }\n\n    // @ts-expect-error: `newable` checks this.\n    return Compiler(node, file) // eslint-disable-line new-cap\n  }\n\n  /**\n   * @param {Node} node\n   * @param {VFileCompatible|RunCallback} [doc]\n   * @param {RunCallback} [callback]\n   * @returns {Promise<Node>|void}\n   */\n  function run(node, doc, callback) {\n    assertNode(node)\n    processor.freeze()\n\n    if (!callback && typeof doc === 'function') {\n      callback = doc\n      doc = undefined\n    }\n\n    if (!callback) {\n      return new Promise(executor)\n    }\n\n    executor(null, callback)\n\n    /**\n     * @param {null|((node: Node) => void)} resolve\n     * @param {(error: Error) => void} reject\n     * @returns {void}\n     */\n    function executor(resolve, reject) {\n      // @ts-expect-error: `doc` can’t be a callback anymore, we checked.\n      transformers.run(node, vfile(doc), done)\n\n      /**\n       * @param {Error|null} error\n       * @param {Node} tree\n       * @param {VFile} file\n       * @returns {void}\n       */\n      function done(error, tree, file) {\n        tree = tree || node\n        if (error) {\n          reject(error)\n        } else if (resolve) {\n          resolve(tree)\n        } else {\n          // @ts-expect-error: `callback` is defined if `resolve` is not.\n          callback(null, tree, file)\n        }\n      }\n    }\n  }\n\n  /** @type {Processor['runSync']} */\n  function runSync(node, file) {\n    /** @type {Node|undefined} */\n    let result\n    /** @type {boolean|undefined} */\n    let complete\n\n    processor.run(node, file, done)\n\n    assertDone('runSync', 'run', complete)\n\n    // @ts-expect-error: we either bailed on an error or have a tree.\n    return result\n\n    /**\n     * @param {Error|null} [error]\n     * @param {Node} [tree]\n     * @returns {void}\n     */\n    function done(error, tree) {\n      bail(error)\n      result = tree\n      complete = true\n    }\n  }\n\n  /**\n   * @param {VFileCompatible} doc\n   * @param {ProcessCallback} [callback]\n   * @returns {Promise<VFile>|undefined}\n   */\n  function process(doc, callback) {\n    processor.freeze()\n    assertParser('process', processor.Parser)\n    assertCompiler('process', processor.Compiler)\n\n    if (!callback) {\n      return new Promise(executor)\n    }\n\n    executor(null, callback)\n\n    /**\n     * @param {null|((file: VFile) => void)} resolve\n     * @param {(error?: Error|null|undefined) => void} reject\n     * @returns {void}\n     */\n    function executor(resolve, reject) {\n      const file = vfile(doc)\n\n      processor.run(processor.parse(file), file, (error, tree, file) => {\n        if (error || !tree || !file) {\n          done(error)\n        } else {\n          /** @type {unknown} */\n          const result = processor.stringify(tree, file)\n\n          if (result === undefined || result === null) {\n            // Empty.\n          } else if (looksLikeAVFileValue(result)) {\n            file.value = result\n          } else {\n            file.result = result\n          }\n\n          done(error, file)\n        }\n      })\n\n      /**\n       * @param {Error|null|undefined} [error]\n       * @param {VFile|undefined} [file]\n       * @returns {void}\n       */\n      function done(error, file) {\n        if (error || !file) {\n          reject(error)\n        } else if (resolve) {\n          resolve(file)\n        } else {\n          // @ts-expect-error: `callback` is defined if `resolve` is not.\n          callback(null, file)\n        }\n      }\n    }\n  }\n\n  /** @type {Processor['processSync']} */\n  function processSync(doc) {\n    /** @type {boolean|undefined} */\n    let complete\n\n    processor.freeze()\n    assertParser('processSync', processor.Parser)\n    assertCompiler('processSync', processor.Compiler)\n\n    const file = vfile(doc)\n\n    processor.process(file, done)\n\n    assertDone('processSync', 'process', complete)\n\n    return file\n\n    /**\n     * @param {Error|null|undefined} [error]\n     * @returns {void}\n     */\n    function done(error) {\n      complete = true\n      bail(error)\n    }\n  }\n}\n\n/**\n * Check if `value` is a constructor.\n *\n * @param {unknown} value\n * @param {string} name\n * @returns {boolean}\n */\nfunction newable(value, name) {\n  return (\n    typeof value === 'function' &&\n    // Prototypes do exist.\n    // type-coverage:ignore-next-line\n    value.prototype &&\n    // A function with keys in its prototype is probably a constructor.\n    // Classes’ prototype methods are not enumerable, so we check if some value\n    // exists in the prototype.\n    // type-coverage:ignore-next-line\n    (keys(value.prototype) || name in value.prototype)\n  )\n}\n\n/**\n * Check if `value` is an object with keys.\n *\n * @param {Record<string, unknown>} value\n * @returns {boolean}\n */\nfunction keys(value) {\n  /** @type {string} */\n  let key\n\n  for (key in value) {\n    if (own.call(value, key)) {\n      return true\n    }\n  }\n\n  return false\n}\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 {VFileCompatible} [value]\n * @returns {VFile}\n */\nfunction vfile(value) {\n  return looksLikeAVFile(value) ? value : new VFile(value)\n}\n\n/**\n * @param {VFileCompatible} [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 VFileValue}\n */\nfunction looksLikeAVFileValue(value) {\n  return typeof value === 'string' || isBuffer(value)\n}\n","/**\n * @typedef {import('mdast').Root|import('mdast').Content} Node\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [includeImageAlt=true]\n *   Whether to use `alt` for `image`s.\n * @property {boolean | null | undefined} [includeHtml=true]\n *   Whether to use `value` of HTML.\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 Node}\n *   Whether `value` is a node.\n */\nfunction node(value) {\n  return Boolean(value && typeof value === 'object')\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n/** @type {InitialConstruct} */\nexport const content = {\n  tokenize: initializeContent\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Initializer}\n */\nfunction initializeContent(effects) {\n  const contentStart = effects.attempt(\n    this.parser.constructs.contentInitial,\n    afterContentStartConstruct,\n    paragraphInitial\n  )\n  /** @type {Token} */\n  let previous\n  return contentStart\n\n  /** @type {State} */\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, contentStart, 'linePrefix')\n  }\n\n  /** @type {State} */\n  function paragraphInitial(code) {\n    effects.enter('paragraph')\n    return lineStart(code)\n  }\n\n  /** @type {State} */\n  function lineStart(code) {\n    const token = effects.enter('chunkText', {\n      contentType: 'text',\n      previous\n    })\n    if (previous) {\n      previous.next = token\n    }\n    previous = token\n    return data(code)\n  }\n\n  /** @type {State} */\n  function data(code) {\n    if (code === null) {\n      effects.exit('chunkText')\n      effects.exit('paragraph')\n      effects.consume(code)\n      return\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      effects.exit('chunkText')\n      return lineStart\n    }\n\n    // Data.\n    effects.consume(code)\n    return data\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').ContainerState} ContainerState\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\n/**\n * @typedef {[Construct, ContainerState]} StackItem\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {splice} from 'micromark-util-chunked'\n/** @type {InitialConstruct} */\nexport const document = {\n  tokenize: initializeDocument\n}\n\n/** @type {Construct} */\nconst containerConstruct = {\n  tokenize: tokenizeContainer\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Initializer}\n */\nfunction initializeDocument(effects) {\n  const self = this\n  /** @type {Array<StackItem>} */\n  const stack = []\n  let continued = 0\n  /** @type {TokenizeContext | undefined} */\n  let childFlow\n  /** @type {Token | undefined} */\n  let childToken\n  /** @type {number} */\n  let lineStartOffset\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    // First we iterate through the open blocks, starting with the root\n    // document, and descending through last children down to the last open\n    // block.\n    // Each block imposes a condition that the line must satisfy if the block is\n    // to remain open.\n    // For example, a block quote requires a `>` character.\n    // A paragraph requires a non-blank line.\n    // In this phase we may match all or just some of the open blocks.\n    // But we cannot close unmatched blocks yet, because we may have a lazy\n    // continuation line.\n    if (continued < stack.length) {\n      const item = stack[continued]\n      self.containerState = item[1]\n      return effects.attempt(\n        item[0].continuation,\n        documentContinue,\n        checkNewContainers\n      )(code)\n    }\n\n    // Done.\n    return checkNewContainers(code)\n  }\n\n  /** @type {State} */\n  function documentContinue(code) {\n    continued++\n\n    // Note: this field is called `_closeFlow` but it also closes containers.\n    // Perhaps a good idea to rename it but it’s already used in the wild by\n    // extensions.\n    if (self.containerState._closeFlow) {\n      self.containerState._closeFlow = undefined\n      if (childFlow) {\n        closeFlow()\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when dealing with lazy lines in `writeToChild`.\n      const indexBeforeExits = self.events.length\n      let indexBeforeFlow = indexBeforeExits\n      /** @type {Point | undefined} */\n      let point\n\n      // Find the flow chunk.\n      while (indexBeforeFlow--) {\n        if (\n          self.events[indexBeforeFlow][0] === 'exit' &&\n          self.events[indexBeforeFlow][1].type === 'chunkFlow'\n        ) {\n          point = self.events[indexBeforeFlow][1].end\n          break\n        }\n      }\n      exitContainers(continued)\n\n      // Fix positions.\n      let index = indexBeforeExits\n      while (index < self.events.length) {\n        self.events[index][1].end = Object.assign({}, point)\n        index++\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(\n        self.events,\n        indexBeforeFlow + 1,\n        0,\n        self.events.slice(indexBeforeExits)\n      )\n\n      // Discard the duplicate exits.\n      self.events.length = index\n      return checkNewContainers(code)\n    }\n    return start(code)\n  }\n\n  /** @type {State} */\n  function checkNewContainers(code) {\n    // Next, after consuming the continuation markers for existing blocks, we\n    // look for new block starts (e.g. `>` for a block quote).\n    // If we encounter a new block start, we close any blocks unmatched in\n    // step 1 before creating the new block as a child of the last matched\n    // block.\n    if (continued === stack.length) {\n      // No need to `check` whether there’s a container, of `exitContainers`\n      // would be moot.\n      // We can instead immediately `attempt` to parse one.\n      if (!childFlow) {\n        return documentContinued(code)\n      }\n\n      // If we have concrete content, such as block HTML or fenced code,\n      // we can’t have containers “pierce” into them, so we can immediately\n      // start.\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        return flowStart(code)\n      }\n\n      // If we do have flow, it could still be a blank line,\n      // but we’d be interrupting it w/ a new container if there’s a current\n      // construct.\n      // To do: next major: remove `_gfmTableDynamicInterruptHack` (no longer\n      // needed in micromark-extension-gfm-table@1.0.6).\n      self.interrupt = Boolean(\n        childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack\n      )\n    }\n\n    // Check if there is a new container.\n    self.containerState = {}\n    return effects.check(\n      containerConstruct,\n      thereIsANewContainer,\n      thereIsNoNewContainer\n    )(code)\n  }\n\n  /** @type {State} */\n  function thereIsANewContainer(code) {\n    if (childFlow) closeFlow()\n    exitContainers(continued)\n    return documentContinued(code)\n  }\n\n  /** @type {State} */\n  function thereIsNoNewContainer(code) {\n    self.parser.lazy[self.now().line] = continued !== stack.length\n    lineStartOffset = self.now().offset\n    return flowStart(code)\n  }\n\n  /** @type {State} */\n  function documentContinued(code) {\n    // Try new containers.\n    self.containerState = {}\n    return effects.attempt(\n      containerConstruct,\n      containerContinue,\n      flowStart\n    )(code)\n  }\n\n  /** @type {State} */\n  function containerContinue(code) {\n    continued++\n    stack.push([self.currentConstruct, self.containerState])\n    // Try another.\n    return documentContinued(code)\n  }\n\n  /** @type {State} */\n  function flowStart(code) {\n    if (code === null) {\n      if (childFlow) closeFlow()\n      exitContainers(0)\n      effects.consume(code)\n      return\n    }\n    childFlow = childFlow || self.parser.flow(self.now())\n    effects.enter('chunkFlow', {\n      contentType: 'flow',\n      previous: childToken,\n      _tokenizer: childFlow\n    })\n    return flowContinue(code)\n  }\n\n  /** @type {State} */\n  function flowContinue(code) {\n    if (code === null) {\n      writeToChild(effects.exit('chunkFlow'), true)\n      exitContainers(0)\n      effects.consume(code)\n      return\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code)\n      writeToChild(effects.exit('chunkFlow'))\n      // Get ready for the next line.\n      continued = 0\n      self.interrupt = undefined\n      return start\n    }\n    effects.consume(code)\n    return flowContinue\n  }\n\n  /**\n   * @param {Token} token\n   * @param {boolean | undefined} [eof]\n   * @returns {void}\n   */\n  function writeToChild(token, eof) {\n    const stream = self.sliceStream(token)\n    if (eof) stream.push(null)\n    token.previous = childToken\n    if (childToken) childToken.next = token\n    childToken = token\n    childFlow.defineSkip(token.start)\n    childFlow.write(stream)\n\n    // Alright, so we just added a lazy line:\n    //\n    // ```markdown\n    // > a\n    // b.\n    //\n    // Or:\n    //\n    // > ~~~c\n    // d\n    //\n    // Or:\n    //\n    // > | e |\n    // f\n    // ```\n    //\n    // The construct in the second example (fenced code) does not accept lazy\n    // lines, so it marked itself as done at the end of its first line, and\n    // then the content construct parses `d`.\n    // Most constructs in markdown match on the first line: if the first line\n    // forms a construct, a non-lazy line can’t “unmake” it.\n    //\n    // The construct in the third example is potentially a GFM table, and\n    // those are *weird*.\n    // It *could* be a table, from the first line, if the following line\n    // matches a condition.\n    // In this case, that second line is lazy, which “unmakes” the first line\n    // and turns the whole into one content block.\n    //\n    // We’ve now parsed the non-lazy and the lazy line, and can figure out\n    // whether the lazy line started a new flow block.\n    // If it did, we exit the current containers between the two flow blocks.\n    if (self.parser.lazy[token.start.line]) {\n      let index = childFlow.events.length\n      while (index--) {\n        if (\n          // The token starts before the line ending…\n          childFlow.events[index][1].start.offset < lineStartOffset &&\n          // …and either is not ended yet…\n          (!childFlow.events[index][1].end ||\n            // …or ends after it.\n            childFlow.events[index][1].end.offset > lineStartOffset)\n        ) {\n          // Exit: there’s still something open, which means it’s a lazy line\n          // part of something.\n          return\n        }\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when closing flow in `documentContinue`.\n      const indexBeforeExits = self.events.length\n      let indexBeforeFlow = indexBeforeExits\n      /** @type {boolean | undefined} */\n      let seen\n      /** @type {Point | undefined} */\n      let point\n\n      // Find the previous chunk (the one before the lazy line).\n      while (indexBeforeFlow--) {\n        if (\n          self.events[indexBeforeFlow][0] === 'exit' &&\n          self.events[indexBeforeFlow][1].type === 'chunkFlow'\n        ) {\n          if (seen) {\n            point = self.events[indexBeforeFlow][1].end\n            break\n          }\n          seen = true\n        }\n      }\n      exitContainers(continued)\n\n      // Fix positions.\n      index = indexBeforeExits\n      while (index < self.events.length) {\n        self.events[index][1].end = Object.assign({}, point)\n        index++\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(\n        self.events,\n        indexBeforeFlow + 1,\n        0,\n        self.events.slice(indexBeforeExits)\n      )\n\n      // Discard the duplicate exits.\n      self.events.length = index\n    }\n  }\n\n  /**\n   * @param {number} size\n   * @returns {void}\n   */\n  function exitContainers(size) {\n    let index = stack.length\n\n    // Exit open containers.\n    while (index-- > size) {\n      const entry = stack[index]\n      self.containerState = entry[1]\n      entry[0].exit.call(self, effects)\n    }\n    stack.length = size\n  }\n  function closeFlow() {\n    childFlow.write([null])\n    childToken = undefined\n    childFlow = undefined\n    self.containerState._closeFlow = undefined\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeContainer(effects, ok, nok) {\n  // Always populated by defaults.\n\n  return factorySpace(\n    effects,\n    effects.attempt(this.parser.constructs.document, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4\n  )\n}\n","/**\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Token} Token\n */\n\nimport {splice} from 'micromark-util-chunked'\n/**\n * Tokenize subcontent.\n *\n * @param {Array<Event>} events\n *   List of events.\n * @returns {boolean}\n *   Whether subtokens were found.\n */\nexport function subtokenize(events) {\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  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index]\n    }\n    event = events[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 (\n      index &&\n      event[1].type === 'chunkFlow' &&\n      events[index - 1][1].type === 'listItemPrefix'\n    ) {\n      subevents = event[1]._tokenizer.events\n      otherIndex = 0\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'lineEndingBlank'\n      ) {\n        otherIndex += 2\n      }\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'content'\n      ) {\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[otherIndex]\n        if (\n          otherEvent[1].type === 'lineEnding' ||\n          otherEvent[1].type === 'lineEndingBlank'\n        ) {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events[lineIndex][1].type = 'lineEndingBlank'\n            }\n            otherEvent[1].type = 'lineEnding'\n            lineIndex = otherIndex\n          }\n        } else {\n          break\n        }\n      }\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = Object.assign({}, events[lineIndex][1].start)\n\n        // Switch container exit w/ line endings.\n        parameters = events.slice(lineIndex, index)\n        parameters.unshift(event)\n        splice(events, lineIndex, index - lineIndex + 1, parameters)\n      }\n    }\n  }\n  return !more\n}\n\n/**\n * Tokenize embedded tokens.\n *\n * @param {Array<Event>} events\n * @param {number} eventIndex\n * @returns {Record<string, number>}\n */\nfunction subcontent(events, eventIndex) {\n  const token = events[eventIndex][1]\n  const context = events[eventIndex][2]\n  let startPosition = eventIndex - 1\n  /** @type {Array<number>} */\n  const startPositions = []\n  const tokenizer =\n    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[++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' &&\n      childEvents[index - 1][0] === 'enter' &&\n      childEvents[index][1].type === childEvents[index - 1][1].type &&\n      childEvents[index][1].start.line !== childEvents[index][1].end.line\n    ) {\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.unshift([start, start + slice.length - 1])\n    splice(events, start, 2, slice)\n  }\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","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {subtokenize} from 'micromark-util-subtokenize'\n/**\n * No name because it must not be turned off.\n * @type {Construct}\n */\nexport const content = {\n  tokenize: tokenizeContent,\n  resolve: resolveContent\n}\n\n/** @type {Construct} */\nconst continuationConstruct = {\n  tokenize: tokenizeContinuation,\n  partial: true\n}\n\n/**\n * Content is transparent: it’s parsed right now. That way, definitions are also\n * parsed right now: before text in paragraphs (specifically, media) are parsed.\n *\n * @type {Resolver}\n */\nfunction resolveContent(events) {\n  subtokenize(events)\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeContent(effects, ok) {\n  /** @type {Token | undefined} */\n  let previous\n  return chunkStart\n\n  /**\n   * Before a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkStart(code) {\n    effects.enter('content')\n    previous = effects.enter('chunkContent', {\n      contentType: 'content'\n    })\n    return chunkInside(code)\n  }\n\n  /**\n   * In a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkInside(code) {\n    if (code === null) {\n      return contentEnd(code)\n    }\n\n    // To do: in `markdown-rs`, each line is parsed on its own, and everything\n    // is stitched together resolving.\n    if (markdownLineEnding(code)) {\n      return effects.check(\n        continuationConstruct,\n        contentContinue,\n        contentEnd\n      )(code)\n    }\n\n    // Data.\n    effects.consume(code)\n    return chunkInside\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentEnd(code) {\n    effects.exit('chunkContent')\n    effects.exit('content')\n    return ok(code)\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentContinue(code) {\n    effects.consume(code)\n    effects.exit('chunkContent')\n    previous.next = effects.enter('chunkContent', {\n      contentType: 'content',\n      previous\n    })\n    previous = previous.next\n    return chunkInside\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeContinuation(effects, ok, nok) {\n  const self = this\n  return startLookahead\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function startLookahead(code) {\n    effects.exit('chunkContent')\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, prefixed, 'linePrefix')\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    // Always populated by defaults.\n\n    const tail = self.events[self.events.length - 1]\n    if (\n      !self.parser.constructs.disable.null.includes('codeIndented') &&\n      tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n    ) {\n      return ok(code)\n    }\n    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\nimport {blankLine, content} from 'micromark-core-commonmark'\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n/** @type {InitialConstruct} */\nexport const flow = {\n  tokenize: initializeFlow\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Initializer}\n */\nfunction initializeFlow(effects) {\n  const self = this\n  const initial = effects.attempt(\n    // Try to parse a blank line.\n    blankLine,\n    atBlankEnding,\n    // Try to parse initial flow (essentially, only code).\n    effects.attempt(\n      this.parser.constructs.flowInitial,\n      afterConstruct,\n      factorySpace(\n        effects,\n        effects.attempt(\n          this.parser.constructs.flow,\n          afterConstruct,\n          effects.attempt(content, afterConstruct)\n        ),\n        'linePrefix'\n      )\n    )\n  )\n  return initial\n\n  /** @type {State} */\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n    effects.enter('lineEndingBlank')\n    effects.consume(code)\n    effects.exit('lineEndingBlank')\n    self.currentConstruct = undefined\n    return initial\n  }\n\n  /** @type {State} */\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code)\n      return\n    }\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    self.currentConstruct = undefined\n    return initial\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\nexport const resolver = {\n  resolveAll: createResolver()\n}\nexport const string = initializeFactory('string')\nexport const text = initializeFactory('text')\n\n/**\n * @param {'string' | 'text'} field\n * @returns {InitialConstruct}\n */\nfunction initializeFactory(field) {\n  return {\n    tokenize: initializeText,\n    resolveAll: createResolver(\n      field === 'text' ? resolveAllLineSuffixes : undefined\n    )\n  }\n\n  /**\n   * @this {TokenizeContext}\n   * @type {Initializer}\n   */\n  function initializeText(effects) {\n    const self = this\n    const constructs = this.parser.constructs[field]\n    const text = effects.attempt(constructs, start, notText)\n    return start\n\n    /** @type {State} */\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code)\n    }\n\n    /** @type {State} */\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code)\n        return\n      }\n      effects.enter('data')\n      effects.consume(code)\n      return data\n    }\n\n    /** @type {State} */\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit('data')\n        return text(code)\n      }\n\n      // Data.\n      effects.consume(code)\n      return data\n    }\n\n    /**\n     * @param {Code} code\n     * @returns {boolean}\n     */\n    function atBreak(code) {\n      if (code === null) {\n        return true\n      }\n      const list = constructs[code]\n      let index = -1\n      if (list) {\n        // Always populated by defaults.\n\n        while (++index < list.length) {\n          const item = list[index]\n          if (!item.previous || item.previous.call(self, self.previous)) {\n            return true\n          }\n        }\n      }\n      return false\n    }\n  }\n}\n\n/**\n * @param {Resolver | undefined} [extraResolver]\n * @returns {Resolver}\n */\nfunction createResolver(extraResolver) {\n  return resolveAllText\n\n  /** @type {Resolver} */\n  function resolveAllText(events, context) {\n    let index = -1\n    /** @type {number | undefined} */\n    let enter\n\n    // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === 'data') {\n          enter = index\n          index++\n        }\n      } else if (!events[index] || events[index][1].type !== 'data') {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end\n          events.splice(enter + 2, index - enter - 2)\n          index = enter + 2\n        }\n        enter = undefined\n      }\n    }\n    return extraResolver ? extraResolver(events, context) : events\n  }\n}\n\n/**\n * A rather ugly set of instructions which again looks at chunks in the input\n * stream.\n * The reason to do this here is that it is *much* faster to parse in reverse.\n * And that we can’t hook into `null` to split the line suffix before an EOF.\n * To do: figure out if we can make this into a clean utility, or even in core.\n * As it will be useful for GFMs literal autolink extension (and maybe even\n * tables?)\n *\n * @type {Resolver}\n */\nfunction resolveAllLineSuffixes(events, context) {\n  let eventIndex = 0 // Skip first.\n\n  while (++eventIndex <= events.length) {\n    if (\n      (eventIndex === events.length ||\n        events[eventIndex][1].type === 'lineEnding') &&\n      events[eventIndex - 1][1].type === 'data'\n    ) {\n      const data = events[eventIndex - 1][1]\n      const chunks = context.sliceStream(data)\n      let index = chunks.length\n      let bufferIndex = -1\n      let size = 0\n      /** @type {boolean | undefined} */\n      let tabs\n      while (index--) {\n        const chunk = chunks[index]\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++\n            bufferIndex--\n          }\n          if (bufferIndex) break\n          bufferIndex = -1\n        }\n        // Number\n        else if (chunk === -2) {\n          tabs = true\n          size++\n        } else if (chunk === -1) {\n          // Empty\n        } else {\n          // Replacement character, exit.\n          index++\n          break\n        }\n      }\n      if (size) {\n        const token = {\n          type:\n            eventIndex === events.length || tabs || size < 2\n              ? 'lineSuffix'\n              : 'hardBreakTrailing',\n          start: {\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size,\n            _index: data.start._index + index,\n            _bufferIndex: index\n              ? bufferIndex\n              : data.start._bufferIndex + bufferIndex\n          },\n          end: Object.assign({}, data.end)\n        }\n        data.end = Object.assign({}, token.start)\n        if (data.start.offset === data.end.offset) {\n          Object.assign(data, token)\n        } else {\n          events.splice(\n            eventIndex,\n            0,\n            ['enter', token, context],\n            ['exit', token, context]\n          )\n          eventIndex += 2\n        }\n      }\n      eventIndex++\n    }\n  }\n  return events\n}\n","/**\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenType} TokenType\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\n/**\n * @callback Restore\n * @returns {void}\n *\n * @typedef Info\n * @property {Restore} restore\n * @property {number} from\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n * @param {Info} info\n * @returns {void}\n */\n\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {push, splice} from 'micromark-util-chunked'\nimport {resolveAll} from 'micromark-util-resolve-all'\n/**\n * Create a tokenizer.\n * Tokenizers deal with one type of data (e.g., containers, flow, text).\n * The parser is the object dealing with it all.\n * `initialize` works like other constructs, except that only its `tokenize`\n * function is used, in which case it doesn’t receive an `ok` or `nok`.\n * `from` can be given to set the point before the first character, although\n * when further lines are indented, they must be set with `defineSkip`.\n *\n * @param {ParseContext} parser\n * @param {InitialConstruct} initialize\n * @param {Omit<Point, '_bufferIndex' | '_index'> | undefined} [from]\n * @returns {TokenizeContext}\n */\nexport function createTokenizer(parser, initialize, from) {\n  /** @type {Point} */\n  let point = Object.assign(\n    from\n      ? Object.assign({}, from)\n      : {\n          line: 1,\n          column: 1,\n          offset: 0\n        },\n    {\n      _index: 0,\n      _bufferIndex: -1\n    }\n  )\n  /** @type {Record<string, number>} */\n  const columnStart = {}\n  /** @type {Array<Construct>} */\n  const resolveAllConstructs = []\n  /** @type {Array<Chunk>} */\n  let chunks = []\n  /** @type {Array<Token>} */\n  let stack = []\n  /** @type {boolean | undefined} */\n  let consumed = true\n\n  /**\n   * Tools used for tokenizing.\n   *\n   * @type {Effects}\n   */\n  const effects = {\n    consume,\n    enter,\n    exit,\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    })\n  }\n\n  /**\n   * State and tools for resolving and serializing.\n   *\n   * @type {TokenizeContext}\n   */\n  const context = {\n    previous: null,\n    code: null,\n    containerState: {},\n    events: [],\n    parser,\n    sliceStream,\n    sliceSerialize,\n    now,\n    defineSkip,\n    write\n  }\n\n  /**\n   * The state function.\n   *\n   * @type {State | void}\n   */\n  let state = initialize.tokenize.call(context, effects)\n\n  /**\n   * Track which character we expect to be consumed, to catch bugs.\n   *\n   * @type {Code}\n   */\n  let expectedCode\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize)\n  }\n  return context\n\n  /** @type {TokenizeContext['write']} */\n  function write(slice) {\n    chunks = push(chunks, slice)\n    main()\n\n    // Exit if we’re not done, resolve might change stuff.\n    if (chunks[chunks.length - 1] !== null) {\n      return []\n    }\n    addResult(initialize, 0)\n\n    // Otherwise, resolve, and exit.\n    context.events = resolveAll(resolveAllConstructs, context.events, context)\n    return context.events\n  }\n\n  //\n  // Tools.\n  //\n\n  /** @type {TokenizeContext['sliceSerialize']} */\n  function sliceSerialize(token, expandTabs) {\n    return serializeChunks(sliceStream(token), expandTabs)\n  }\n\n  /** @type {TokenizeContext['sliceStream']} */\n  function sliceStream(token) {\n    return sliceChunks(chunks, token)\n  }\n\n  /** @type {TokenizeContext['now']} */\n  function now() {\n    // This is a hot path, so we clone manually instead of `Object.assign({}, point)`\n    const {line, column, offset, _index, _bufferIndex} = point\n    return {\n      line,\n      column,\n      offset,\n      _index,\n      _bufferIndex\n    }\n  }\n\n  /** @type {TokenizeContext['defineSkip']} */\n  function defineSkip(value) {\n    columnStart[value.line] = value.column\n    accountForPotentialSkip()\n  }\n\n  //\n  // State management.\n  //\n\n  /**\n   * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n   * `consume`).\n   * Here is where we walk through the chunks, which either include strings of\n   * several characters, or numerical character codes.\n   * The reason to do this in a loop instead of a call is so the stack can\n   * drain.\n   *\n   * @returns {void}\n   */\n  function main() {\n    /** @type {number} */\n    let chunkIndex\n    while (point._index < chunks.length) {\n      const chunk = chunks[point._index]\n\n      // If we’re in a buffer chunk, loop through it.\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0\n        }\n        while (\n          point._index === chunkIndex &&\n          point._bufferIndex < chunk.length\n        ) {\n          go(chunk.charCodeAt(point._bufferIndex))\n        }\n      } else {\n        go(chunk)\n      }\n    }\n  }\n\n  /**\n   * Deal with one code.\n   *\n   * @param {Code} code\n   * @returns {void}\n   */\n  function go(code) {\n    consumed = undefined\n    expectedCode = code\n    state = state(code)\n  }\n\n  /** @type {Effects['consume']} */\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++\n      point.column = 1\n      point.offset += code === -3 ? 2 : 1\n      accountForPotentialSkip()\n    } else if (code !== -1) {\n      point.column++\n      point.offset++\n    }\n\n    // Not in a string chunk.\n    if (point._bufferIndex < 0) {\n      point._index++\n    } else {\n      point._bufferIndex++\n\n      // At end of string chunk.\n      // @ts-expect-error Points w/ non-negative `_bufferIndex` reference\n      // strings.\n      if (point._bufferIndex === chunks[point._index].length) {\n        point._bufferIndex = -1\n        point._index++\n      }\n    }\n\n    // Expose the previous character.\n    context.previous = code\n\n    // Mark as consumed.\n    consumed = true\n  }\n\n  /** @type {Effects['enter']} */\n  function enter(type, fields) {\n    /** @type {Token} */\n    // @ts-expect-error Patch instead of assign required fields to help GC.\n    const token = fields || {}\n    token.type = type\n    token.start = now()\n    context.events.push(['enter', token, context])\n    stack.push(token)\n    return token\n  }\n\n  /** @type {Effects['exit']} */\n  function exit(type) {\n    const token = stack.pop()\n    token.end = now()\n    context.events.push(['exit', token, context])\n    return token\n  }\n\n  /**\n   * Use results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from)\n  }\n\n  /**\n   * Discard results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulcheck(_, info) {\n    info.restore()\n  }\n\n  /**\n   * Factory to attempt/check/interrupt.\n   *\n   * @param {ReturnHandle} onreturn\n   * @param {{interrupt?: boolean | undefined} | undefined} [fields]\n   */\n  function constructFactory(onreturn, fields) {\n    return hook\n\n    /**\n     * Handle either an object mapping codes to constructs, a list of\n     * constructs, or a single construct.\n     *\n     * @param {Array<Construct> | Construct | ConstructRecord} constructs\n     * @param {State} returnState\n     * @param {State | undefined} [bogusState]\n     * @returns {State}\n     */\n    function hook(constructs, returnState, bogusState) {\n      /** @type {Array<Construct>} */\n      let listOfConstructs\n      /** @type {number} */\n      let constructIndex\n      /** @type {Construct} */\n      let currentConstruct\n      /** @type {Info} */\n      let info\n      return Array.isArray(constructs) /* c8 ignore next 1 */\n        ? handleListOfConstructs(constructs)\n        : 'tokenize' in constructs\n        ? // @ts-expect-error Looks like a construct.\n          handleListOfConstructs([constructs])\n        : handleMapOfConstructs(constructs)\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       * @returns {State}\n       */\n      function handleMapOfConstructs(map) {\n        return start\n\n        /** @type {State} */\n        function start(code) {\n          const def = code !== null && map[code]\n          const all = code !== null && map.null\n          const list = [\n            // To do: add more extension tests.\n            /* c8 ignore next 2 */\n            ...(Array.isArray(def) ? def : def ? [def] : []),\n            ...(Array.isArray(all) ? all : all ? [all] : [])\n          ]\n          return handleListOfConstructs(list)(code)\n        }\n      }\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {Array<Construct>} list\n       * @returns {State}\n       */\n      function handleListOfConstructs(list) {\n        listOfConstructs = list\n        constructIndex = 0\n        if (list.length === 0) {\n          return bogusState\n        }\n        return handleConstruct(list[constructIndex])\n      }\n\n      /**\n       * Handle a single construct.\n       *\n       * @param {Construct} construct\n       * @returns {State}\n       */\n      function handleConstruct(construct) {\n        return start\n\n        /** @type {State} */\n        function start(code) {\n          // To do: not needed to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store()\n          currentConstruct = construct\n          if (!construct.partial) {\n            context.currentConstruct = construct\n          }\n\n          // Always populated by defaults.\n\n          if (\n            construct.name &&\n            context.parser.constructs.disable.null.includes(construct.name)\n          ) {\n            return nok(code)\n          }\n          return construct.tokenize.call(\n            // If we do have fields, create an object w/ `context` as its\n            // prototype.\n            // This allows a “live binding”, which is needed for `interrupt`.\n            fields ? Object.assign(Object.create(context), fields) : context,\n            effects,\n            ok,\n            nok\n          )(code)\n        }\n      }\n\n      /** @type {State} */\n      function ok(code) {\n        consumed = true\n        onreturn(currentConstruct, info)\n        return returnState\n      }\n\n      /** @type {State} */\n      function nok(code) {\n        consumed = true\n        info.restore()\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex])\n        }\n        return bogusState\n      }\n    }\n  }\n\n  /**\n   * @param {Construct} construct\n   * @param {number} from\n   * @returns {void}\n   */\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct)\n    }\n    if (construct.resolve) {\n      splice(\n        context.events,\n        from,\n        context.events.length - from,\n        construct.resolve(context.events.slice(from), context)\n      )\n    }\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context)\n    }\n  }\n\n  /**\n   * Store state.\n   *\n   * @returns {Info}\n   */\n  function store() {\n    const startPoint = now()\n    const startPrevious = context.previous\n    const startCurrentConstruct = context.currentConstruct\n    const startEventsIndex = context.events.length\n    const startStack = Array.from(stack)\n    return {\n      restore,\n      from: startEventsIndex\n    }\n\n    /**\n     * Restore state.\n     *\n     * @returns {void}\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 {void}\n   */\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line]\n      point.offset += columnStart[point.line] - 1\n    }\n  }\n}\n\n/**\n * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {Array<Chunk>} chunks\n * @param {Pick<Token, 'end' | 'start'>} token\n * @returns {Array<Chunk>}\n */\nfunction sliceChunks(chunks, token) {\n  const startIndex = token.start._index\n  const startBufferIndex = token.start._bufferIndex\n  const endIndex = token.end._index\n  const endBufferIndex = token.end._bufferIndex\n  /** @type {Array<Chunk>} */\n  let view\n  if (startIndex === endIndex) {\n    // @ts-expect-error `_bufferIndex` is used on string chunks.\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)]\n  } else {\n    view = chunks.slice(startIndex, endIndex)\n    if (startBufferIndex > -1) {\n      const head = view[0]\n      if (typeof head === 'string') {\n        view[0] = head.slice(startBufferIndex)\n      } else {\n        view.shift()\n      }\n    }\n    if (endBufferIndex > 0) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view.push(chunks[endIndex].slice(0, endBufferIndex))\n    }\n  }\n  return view\n}\n\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {Array<Chunk>} chunks\n * @param {boolean | undefined} [expandTabs=false]\n * @returns {string}\n */\nfunction serializeChunks(chunks, expandTabs) {\n  let index = -1\n  /** @type {Array<string>} */\n  const result = []\n  /** @type {boolean | undefined} */\n  let atTab\n  while (++index < chunks.length) {\n    const chunk = chunks[index]\n    /** @type {string} */\n    let value\n    if (typeof chunk === 'string') {\n      value = chunk\n    } else\n      switch (chunk) {\n        case -5: {\n          value = '\\r'\n          break\n        }\n        case -4: {\n          value = '\\n'\n          break\n        }\n        case -3: {\n          value = '\\r' + '\\n'\n          break\n        }\n        case -2: {\n          value = expandTabs ? ' ' : '\\t'\n          break\n        }\n        case -1: {\n          if (!expandTabs && atTab) continue\n          value = ' '\n          break\n        }\n        default: {\n          // Currently only replacement character.\n          value = String.fromCharCode(chunk)\n        }\n      }\n    atTab = chunk === -2\n    result.push(value)\n  }\n  return result.join('')\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nexport const thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  let size = 0\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n\n  /**\n   * Start of thematic break.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('thematicBreak')\n    // To do: parse indent like `markdown-rs`.\n    return before(code)\n  }\n\n  /**\n   * After optional whitespace, at marker.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    marker = code\n    return atBreak(code)\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter('thematicBreakSequence')\n      return sequence(code)\n    }\n    if (size >= 3 && (code === null || markdownLineEnding(code))) {\n      effects.exit('thematicBreak')\n      return ok(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      size++\n      return sequence\n    }\n    effects.exit('thematicBreakSequence')\n    return markdownSpace(code)\n      ? factorySpace(effects, atBreak, 'whitespace')(code)\n      : atBreak(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').ContainerState} ContainerState\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {asciiDigit, markdownSpace} from 'micromark-util-character'\nimport {blankLine} from './blank-line.js'\nimport {thematicBreak} from './thematic-break.js'\n\n/** @type {Construct} */\nexport const list = {\n  name: 'list',\n  tokenize: tokenizeListStart,\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd\n}\n\n/** @type {Construct} */\nconst listItemPrefixWhitespaceConstruct = {\n  tokenize: tokenizeListItemPrefixWhitespace,\n  partial: true\n}\n\n/** @type {Construct} */\nconst indentConstruct = {\n  tokenize: tokenizeIndent,\n  partial: true\n}\n\n// To do: `markdown-rs` parses list items on their own and later stitches them\n// together.\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeListStart(effects, ok, nok) {\n  const self = this\n  const tail = self.events[self.events.length - 1]\n  let initialSize =\n    tail && tail[1].type === 'linePrefix'\n      ? tail[2].sliceSerialize(tail[1], true).length\n      : 0\n  let size = 0\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    const kind =\n      self.containerState.type ||\n      (code === 42 || code === 43 || code === 45\n        ? 'listUnordered'\n        : 'listOrdered')\n    if (\n      kind === 'listUnordered'\n        ? !self.containerState.marker || code === self.containerState.marker\n        : asciiDigit(code)\n    ) {\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\n          ? effects.check(thematicBreak, nok, atMarker)(code)\n          : 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 (\n      (!self.interrupt || size < 2) &&\n      (self.containerState.marker\n        ? code === self.containerState.marker\n        : code === 41 || code === 46)\n    ) {\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(\n      blankLine,\n      // Can’t be empty when interrupting.\n      self.interrupt ? nok : onBlank,\n      effects.attempt(\n        listItemPrefixWhitespaceConstruct,\n        endOfPrefix,\n        otherPrefix\n      )\n    )\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 =\n      initialSize +\n      self.sliceSerialize(effects.exit('listItemPrefix'), true).length\n    return ok(code)\n  }\n}\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeListContinuation(effects, ok, nok) {\n  const self = this\n  self.containerState._closeFlow = undefined\n  return effects.check(blankLine, onBlank, notBlank)\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.furtherBlankLines =\n      self.containerState.furtherBlankLines ||\n      self.containerState.initialBlankLine\n\n    // We have a blank line.\n    // Still, try to consume at most the items size.\n    return factorySpace(\n      effects,\n      ok,\n      'listItemIndent',\n      self.containerState.size + 1\n    )(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(\n      effects,\n      effects.attempt(list, ok, nok),\n      'linePrefix',\n      self.parser.constructs.disable.null.includes('codeIndented')\n        ? undefined\n        : 4\n    )(code)\n  }\n}\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemIndent',\n    self.containerState.size + 1\n  )\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'listItemIndent' &&\n      tail[2].sliceSerialize(tail[1], true).length === self.containerState.size\n      ? ok(code)\n      : nok(code)\n  }\n}\n\n/**\n * @type {Exiter}\n * @this {TokenizeContext}\n */\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type)\n}\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  const self = this\n\n  // Always populated by defaults.\n\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemPrefixWhitespace',\n    self.parser.constructs.disable.null.includes('codeIndented')\n      ? undefined\n      : 4 + 1\n  )\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return !markdownSpace(code) &&\n      tail &&\n      tail[1].type === 'listItemPrefixWhitespace'\n      ? ok(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nexport const blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  const self = this\n  return start\n\n  /**\n   * Start of block quote.\n   *\n   * ```markdown\n   * > | > a\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 62) {\n      const state = self.containerState\n      if (!state.open) {\n        effects.enter('blockQuote', {\n          _container: true\n        })\n        state.open = true\n      }\n      effects.enter('blockQuotePrefix')\n      effects.enter('blockQuoteMarker')\n      effects.consume(code)\n      effects.exit('blockQuoteMarker')\n      return after\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `>`, before optional whitespace.\n   *\n   * ```markdown\n   * > | > a\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter('blockQuotePrefixWhitespace')\n      effects.consume(code)\n      effects.exit('blockQuotePrefixWhitespace')\n      effects.exit('blockQuotePrefix')\n      return ok\n    }\n    effects.exit('blockQuotePrefix')\n    return ok(code)\n  }\n}\n\n/**\n * Start of block quote continuation.\n *\n * ```markdown\n *   | > a\n * > | > b\n *     ^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  const self = this\n  return contStart\n\n  /**\n   * Start of block quote continuation.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contStart(code) {\n    if (markdownSpace(code)) {\n      // Always populated by defaults.\n\n      return factorySpace(\n        effects,\n        contBefore,\n        'linePrefix',\n        self.parser.constructs.disable.null.includes('codeIndented')\n          ? undefined\n          : 4\n      )(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","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {\n  asciiControl,\n  markdownLineEndingOrSpace,\n  markdownLineEnding\n} from 'micromark-util-character'\n/**\n * Parse destinations.\n *\n * ###### Examples\n *\n * ```markdown\n * <a>\n * <a\\>b>\n * <a b>\n * <a)>\n * a\n * a\\)b\n * a(b)c\n * a(b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type for whole (`<a>` or `b`).\n * @param {TokenType} literalType\n *   Type when enclosed (`<a>`).\n * @param {TokenType} literalMarkerType\n *   Type for enclosing (`<` and `>`).\n * @param {TokenType} rawType\n *   Type when not enclosed (`b`).\n * @param {TokenType} stringType\n *   Type for the value (`a` or `b`).\n * @param {number | undefined} [max=Infinity]\n *   Depth of nested parens (inclusive).\n * @returns {State}\n *   Start state.\n */ // eslint-disable-next-line max-params\nexport function factoryDestination(\n  effects,\n  ok,\n  nok,\n  type,\n  literalType,\n  literalMarkerType,\n  rawType,\n  stringType,\n  max\n) {\n  const limit = max || Number.POSITIVE_INFINITY\n  let balance = 0\n  return start\n\n  /**\n   * Start of destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *     ^\n   * > | aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type)\n      effects.enter(literalType)\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      return enclosedBefore\n    }\n\n    // ASCII control, space, closing paren.\n    if (code === null || code === 32 || code === 41 || asciiControl(code)) {\n      return nok(code)\n    }\n    effects.enter(type)\n    effects.enter(rawType)\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return raw(code)\n  }\n\n  /**\n   * After `<`, at an enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      effects.exit(literalType)\n      effects.exit(type)\n      return ok\n    }\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return enclosed(code)\n  }\n\n  /**\n   * In enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      return enclosedBefore(code)\n    }\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return code === 92 ? enclosedEscape : enclosed\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | <a\\*a>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code)\n      return enclosed\n    }\n    return enclosed(code)\n  }\n\n  /**\n   * In raw destination.\n   *\n   * ```markdown\n   * > | aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function raw(code) {\n    if (\n      !balance &&\n      (code === null || code === 41 || markdownLineEndingOrSpace(code))\n    ) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      effects.exit(rawType)\n      effects.exit(type)\n      return ok(code)\n    }\n    if (balance < limit && code === 40) {\n      effects.consume(code)\n      balance++\n      return raw\n    }\n    if (code === 41) {\n      effects.consume(code)\n      balance--\n      return raw\n    }\n\n    // ASCII control (but *not* `\\0`) and space and `(`.\n    // Note: in `markdown-rs`, `\\0` exists in codes, in `micromark-js` it\n    // doesn’t.\n    if (code === null || code === 32 || code === 40 || asciiControl(code)) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return code === 92 ? rawEscape : raw\n  }\n\n  /**\n   * After `\\`, at special character.\n   *\n   * ```markdown\n   * > | a\\*a\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function rawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code)\n      return raw\n    }\n    return raw(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/**\n * Parse labels.\n *\n * > 👉 **Note**: labels in markdown are capped at 999 characters in the string.\n *\n * ###### Examples\n *\n * ```markdown\n * [a]\n * [a\n * b]\n * [a\\]b]\n * ```\n *\n * @this {TokenizeContext}\n *   Tokenize context.\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole label (`[a]`).\n * @param {TokenType} markerType\n *   Type for the markers (`[` and `]`).\n * @param {TokenType} stringType\n *   Type for the identifier (`a`).\n * @returns {State}\n *   Start state.\n */ // eslint-disable-next-line max-params\nexport function factoryLabel(effects, ok, nok, type, markerType, stringType) {\n  const self = this\n  let size = 0\n  /** @type {boolean} */\n  let seen\n  return start\n\n  /**\n   * Start of label.\n   *\n   * ```markdown\n   * > | [a]\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(type)\n    effects.enter(markerType)\n    effects.consume(code)\n    effects.exit(markerType)\n    effects.enter(stringType)\n    return atBreak\n  }\n\n  /**\n   * In label, at something, before something else.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (\n      size > 999 ||\n      code === null ||\n      code === 91 ||\n      (code === 93 && !seen) ||\n      // To do: remove in the future once we’ve switched from\n      // `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n      // which doesn’t need this.\n      // Hidden footnotes hook.\n      /* c8 ignore next 3 */\n      (code === 94 &&\n        !size &&\n        '_hiddenFootnoteSupport' in self.parser.constructs)\n    ) {\n      return nok(code)\n    }\n    if (code === 93) {\n      effects.exit(stringType)\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n\n    // To do: indent? Link chunks and EOLs together?\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return atBreak\n    }\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return labelInside(code)\n  }\n\n  /**\n   * In label, in text.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelInside(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      code === 93 ||\n      markdownLineEnding(code) ||\n      size++ > 999\n    ) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n    effects.consume(code)\n    if (!seen) seen = !markdownSpace(code)\n    return code === 92 ? labelEscape : labelInside\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | [a\\*a]\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code)\n      size++\n      return labelInside\n    }\n    return labelInside(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n/**\n * Parse titles.\n *\n * ###### Examples\n *\n * ```markdown\n * \"a\"\n * 'b'\n * (c)\n * \"a\n * b\"\n * 'a\n *     b'\n * (a\\)b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole title (`\"a\"`, `'b'`, `(c)`).\n * @param {TokenType} markerType\n *   Type for the markers (`\"`, `'`, `(`, and `)`).\n * @param {TokenType} stringType\n *   Type for the value (`a`).\n * @returns {State}\n *   Start state.\n */ // eslint-disable-next-line max-params\nexport function factoryTitle(effects, ok, nok, type, markerType, stringType) {\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n\n  /**\n   * Start of title.\n   *\n   * ```markdown\n   * > | \"a\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      effects.enter(type)\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      marker = code === 40 ? 41 : code\n      return begin\n    }\n    return nok(code)\n  }\n\n  /**\n   * After opening marker.\n   *\n   * This is also used at the closing marker.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function begin(code) {\n    if (code === marker) {\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n    effects.enter(stringType)\n    return atBreak(code)\n  }\n\n  /**\n   * At something, before something else.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType)\n      return begin(marker)\n    }\n    if (code === null) {\n      return nok(code)\n    }\n\n    // Note: blank lines can’t exist in content.\n    if (markdownLineEnding(code)) {\n      // To do: use `space_or_tab_eol_with_options`, connect.\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return factorySpace(effects, atBreak, 'linePrefix')\n    }\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return inside(code)\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n    effects.consume(code)\n    return code === 92 ? escape : inside\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | \"a\\*b\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function escape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code)\n      return inside\n    }\n    return inside(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   line endings or spaces in markdown are often optional, in which case this\n *     factory can be used and `ok` will be switched to whether spaces were found\n *     or not\n * *   one line ending or space can be detected with\n *     `markdownLineEndingOrSpace(code)` right before using `factoryWhitespace`\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @returns\n *   Start state.\n */\nexport function factoryWhitespace(effects, ok) {\n  /** @type {boolean} */\n  let seen\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      seen = true\n      return start\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(\n        effects,\n        start,\n        seen ? 'linePrefix' : 'lineSuffix'\n      )(code)\n    }\n    return ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factoryDestination} from 'micromark-factory-destination'\nimport {factoryLabel} from 'micromark-factory-label'\nimport {factorySpace} from 'micromark-factory-space'\nimport {factoryTitle} from 'micromark-factory-title'\nimport {factoryWhitespace} from 'micromark-factory-whitespace'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\n/** @type {Construct} */\nexport const definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n}\n\n/** @type {Construct} */\nconst titleBefore = {\n  tokenize: tokenizeTitleBefore,\n  partial: true\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinition(effects, ok, nok) {\n  const self = this\n  /** @type {string} */\n  let identifier\n  return start\n\n  /**\n   * At start of a definition.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // Do not interrupt paragraphs (but do follow definitions).\n    // To do: do `interrupt` the way `markdown-rs` does.\n    // To do: parse whitespace the way `markdown-rs` does.\n    effects.enter('definition')\n    return before(code)\n  }\n\n  /**\n   * After optional whitespace, at `[`.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    // To do: parse whitespace the way `markdown-rs` does.\n\n    return factoryLabel.call(\n      self,\n      effects,\n      labelAfter,\n      // Note: we don’t need to reset the way `markdown-rs` does.\n      nok,\n      'definitionLabel',\n      'definitionLabelMarker',\n      'definitionLabelString'\n    )(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(\n      self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n    )\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)\n      ? factoryWhitespace(effects, destinationBefore)(code)\n      : 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(\n      effects,\n      destinationAfter,\n      // Note: we don’t need to reset the way `markdown-rs` does.\n      nok,\n      'definitionDestination',\n      'definitionDestinationLiteral',\n      'definitionDestinationLiteralMarker',\n      'definitionDestinationRaw',\n      'definitionDestinationString'\n    )(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)\n      ? factorySpace(effects, afterWhitespace, 'whitespace')(code)\n      : afterWhitespace(code)\n  }\n\n  /**\n   * After definition, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterWhitespace(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('definition')\n\n      // Note: we don’t care about uniqueness.\n      // It’s likely that that doesn’t happen very frequently.\n      // It is more likely that it wastes precious time.\n      self.parser.defined.push(identifier)\n\n      // To do: `markdown-rs` interrupt.\n      // // You’d be interrupting.\n      // tokenizer.interrupt = true\n      return ok(code)\n    }\n    return nok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTitleBefore(effects, ok, nok) {\n  return titleBefore\n\n  /**\n   * After destination, at whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleBefore(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, beforeMarker)(code)\n      : 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(\n      effects,\n      titleAfter,\n      nok,\n      'definitionTitle',\n      'definitionTitleMarker',\n      'definitionTitleString'\n    )(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)\n      ? factorySpace(effects, titleAfterOptionalWhitespace, 'whitespace')(code)\n      : 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","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nexport const codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented\n}\n\n/** @type {Construct} */\nconst furtherStart = {\n  tokenize: tokenizeFurtherStart,\n  partial: true\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  const self = this\n  return start\n\n  /**\n   * Start of code (indented).\n   *\n   * > **Parsing note**: it is not needed to check if this first line is a\n   * > filled line (that it has a non-whitespace character), because blank lines\n   * > are parsed already, so we never run into that.\n   *\n   * ```markdown\n   * > |     aaa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: manually check if interrupting like `markdown-rs`.\n\n    effects.enter('codeIndented')\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)(code)\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n      ? atBreak(code)\n      : nok(code)\n  }\n\n  /**\n   * At a break.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === null) {\n      return after(code)\n    }\n    if (markdownLineEnding(code)) {\n      return effects.attempt(furtherStart, atBreak, after)(code)\n    }\n    effects.enter('codeFlowValue')\n    return inside(code)\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return atBreak(code)\n    }\n    effects.consume(code)\n    return inside\n  }\n\n  /** @type {State} */\n  function after(code) {\n    effects.exit('codeIndented')\n    // To do: allow interrupting like `markdown-rs`.\n    // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    return ok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeFurtherStart(effects, ok, nok) {\n  const self = this\n  return furtherStart\n\n  /**\n   * At eol, trying to parse another indent.\n   *\n   * ```markdown\n   * > |     aaa\n   *            ^\n   *   |     bbb\n   * ```\n   *\n   * @type {State}\n   */\n  function furtherStart(code) {\n    // To do: improve `lazy` / `pierce` handling.\n    // If this is a lazy line, it can’t be code.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code)\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return furtherStart\n    }\n\n    // To do: the code here in `micromark-js` is a bit different from\n    // `markdown-rs` because there it can attempt spaces.\n    // We can’t yet.\n    //\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)(code)\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n      ? ok(code)\n      : markdownLineEnding(code)\n      ? furtherStart(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {splice} from 'micromark-util-chunked'\n/** @type {Construct} */\nexport const headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\n}\n\n/** @type {Resolver} */\nfunction resolveHeadingAtx(events, context) {\n  let contentEnd = events.length - 2\n  let contentStart = 3\n  /** @type {Token} */\n  let content\n  /** @type {Token} */\n  let text\n\n  // Prefix whitespace, part of the opening.\n  if (events[contentStart][1].type === 'whitespace') {\n    contentStart += 2\n  }\n\n  // Suffix whitespace, part of the closing.\n  if (\n    contentEnd - 2 > contentStart &&\n    events[contentEnd][1].type === 'whitespace'\n  ) {\n    contentEnd -= 2\n  }\n  if (\n    events[contentEnd][1].type === 'atxHeadingSequence' &&\n    (contentStart === contentEnd - 1 ||\n      (contentEnd - 4 > contentStart &&\n        events[contentEnd - 2][1].type === 'whitespace'))\n  ) {\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, [\n      ['enter', content, context],\n      ['enter', text, context],\n      ['exit', text, context],\n      ['exit', content, context]\n    ])\n  }\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  let size = 0\n  return start\n\n  /**\n   * Start of a heading (atx).\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    effects.enter('atxHeading')\n    return before(code)\n  }\n\n  /**\n   * After optional whitespace, at `#`.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter('atxHeadingSequence')\n    return sequenceOpen(code)\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code)\n      return sequenceOpen\n    }\n\n    // Always at least one `#`.\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingSequence')\n      return atBreak(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ## aa\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === 35) {\n      effects.enter('atxHeadingSequence')\n      return sequenceFurther(code)\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('atxHeading')\n      // To do: interrupt like `markdown-rs`.\n      // // Feel free to interrupt.\n      // tokenizer.interrupt = false\n      return ok(code)\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, 'whitespace')(code)\n    }\n\n    // To do: generate `data` tokens, add the `text` token later.\n    // Needs edit map, see: `markdown.rs`.\n    effects.enter('atxHeadingText')\n    return data(code)\n  }\n\n  /**\n   * In further sequence (after whitespace).\n   *\n   * Could be normal “visible” hashes in the heading or a final sequence.\n   *\n   * ```markdown\n   * > | ## aa ##\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceFurther(code) {\n    if (code === 35) {\n      effects.consume(code)\n      return sequenceFurther\n    }\n    effects.exit('atxHeadingSequence')\n    return atBreak(code)\n  }\n\n  /**\n   * In text.\n   *\n   * ```markdown\n   * > | ## aa\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingText')\n      return atBreak(code)\n    }\n    effects.consume(code)\n    return data\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nexport const setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\n}\n\n/** @type {Resolver} */\nfunction resolveToSetextUnderline(events, context) {\n  // To do: resolve like `markdown-rs`.\n  let index = events.length\n  /** @type {number | undefined} */\n  let content\n  /** @type {number | undefined} */\n  let text\n  /** @type {number | undefined} */\n  let definition\n\n  // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === 'content') {\n        content = index\n        break\n      }\n      if (events[index][1].type === 'paragraph') {\n        text = index\n      }\n    }\n    // Exit\n    else {\n      if (events[index][1].type === 'content') {\n        // Remove the content end (if needed we’ll add it later)\n        events.splice(index, 1)\n      }\n      if (!definition && events[index][1].type === 'definition') {\n        definition = index\n      }\n    }\n  }\n  const heading = {\n    type: 'setextHeading',\n    start: Object.assign({}, events[text][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  }\n\n  // Change the paragraph to setext heading text.\n  events[text][1].type = 'setextHeadingText'\n\n  // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context])\n    events.splice(definition + 1, 0, ['exit', events[content][1], context])\n    events[content][1].end = Object.assign({}, events[definition][1].end)\n  } else {\n    events[content][1] = heading\n  }\n\n  // Add the heading exit at the end.\n  events.push(['exit', heading, context])\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  const self = this\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n\n  /**\n   * At start of heading (setext) underline.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    let index = self.events.length\n    /** @type {boolean | undefined} */\n    let paragraph\n    // Find an opening.\n    while (index--) {\n      // Skip enter/exit of line ending, line prefix, and content.\n      // We can now either have a definition or a paragraph.\n      if (\n        self.events[index][1].type !== 'lineEnding' &&\n        self.events[index][1].type !== 'linePrefix' &&\n        self.events[index][1].type !== 'content'\n      ) {\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)\n      ? factorySpace(effects, after, 'lineSuffix')(code)\n      : 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","/**\n * List of lowercase HTML “block” tag names.\n *\n * The list, when parsing HTML (flow), results in more relaxed rules (condition\n * 6).\n * Because they are known blocks, the HTML-like syntax doesn’t have to be\n * strictly parsed.\n * For tag names not in this list, a more strict algorithm (condition 7) is used\n * to detect whether the HTML-like syntax is seen as HTML (flow) or not.\n *\n * This is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `search` was added in `CommonMark@0.31`.\n */\nexport const htmlBlockNames = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'search',\n  'section',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n]\n\n/**\n * List of lowercase HTML “raw” tag names.\n *\n * The list, when parsing HTML (flow), results in HTML that can include lines\n * without exiting, until a closing tag also in this list is found (condition\n * 1).\n *\n * This module is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `textarea` was added in `CommonMark@0.30`.\n */\nexport const htmlRawNames = ['pre', 'script', 'style', 'textarea']\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {htmlBlockNames, htmlRawNames} from 'micromark-util-html-tag-name'\nimport {blankLine} from './blank-line.js'\n\n/** @type {Construct} */\nexport const htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n}\n\n/** @type {Construct} */\nconst blankLineBefore = {\n  tokenize: tokenizeBlankLineBefore,\n  partial: true\n}\nconst nonLazyContinuationStart = {\n  tokenize: tokenizeNonLazyContinuationStart,\n  partial: true\n}\n\n/** @type {Resolver} */\nfunction resolveToHtmlFlow(events) {\n  let index = events.length\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {\n      break\n    }\n  }\n  if (index > 1 && events[index - 2][1].type === 'linePrefix') {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start\n    // Add the prefix start to the HTML line token.\n    events[index + 1][1].start = events[index - 2][1].start\n    // Remove the line prefix.\n    events.splice(index - 2, 2)\n  }\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  const self = this\n  /** @type {number} */\n  let marker\n  /** @type {boolean} */\n  let closingTag\n  /** @type {string} */\n  let buffer\n  /** @type {number} */\n  let index\n  /** @type {Code} */\n  let markerB\n  return start\n\n  /**\n   * Start of HTML (flow).\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    return before(code)\n  }\n\n  /**\n   * At `<`, after optional whitespace.\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter('htmlFlow')\n    effects.enter('htmlFlowData')\n    effects.consume(code)\n    return open\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | <x />\n   *      ^\n   * > | <!doctype>\n   *      ^\n   * > | <!--xxx-->\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationOpen\n    }\n    if (code === 47) {\n      effects.consume(code)\n      closingTag = true\n      return tagCloseStart\n    }\n    if (code === 63) {\n      effects.consume(code)\n      marker = 3\n      // To do:\n      // tokenizer.concrete = true\n      // To do: use `markdown-rs` style interrupt.\n      // While we’re in an instruction instead of a declaration, we’re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      // @ts-expect-error: not null.\n      buffer = String.fromCharCode(code)\n      return tagName\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *       ^\n   * > | <!--xxx-->\n   *       ^\n   * > | <![CDATA[>&<]]>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      marker = 2\n      return commentOpenInside\n    }\n    if (code === 91) {\n      effects.consume(code)\n      marker = 5\n      index = 0\n      return cdataOpenInside\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      marker = 4\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `<!-`, inside a comment, at another `-`.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `<![`, inside CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *        ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = 'CDATA['\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code)\n      if (index === value.length) {\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok : continuation\n      }\n      return cdataOpenInside\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | </x>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      // @ts-expect-error: not null.\n      buffer = String.fromCharCode(code)\n      return tagName\n    }\n    return nok(code)\n  }\n\n  /**\n   * In tag name.\n   *\n   * ```markdown\n   * > | <ab>\n   *      ^^\n   * > | </ab>\n   *       ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagName(code) {\n    if (\n      code === null ||\n      code === 47 ||\n      code === 62 ||\n      markdownLineEndingOrSpace(code)\n    ) {\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]\n        ? nok(code)\n        : closingTag\n        ? completeClosingTagAfter(code)\n        : 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 (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\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 (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\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 (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 47 ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96 ||\n      markdownLineEndingOrSpace(code)\n    ) {\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(\n        blankLineBefore,\n        continuationAfter,\n        continuationStart\n      )(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(\n      nonLazyContinuationStart,\n      continuationStartNonLazy,\n      continuationAfter\n    )(code)\n  }\n\n  /**\n   * In continuation, at eol, before non-lazy content.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStartNonLazy(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return continuationBefore\n  }\n\n  /**\n   * In continuation, before non-lazy content.\n   *\n   * ```markdown\n   *   | <x>\n   * > | asd\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return continuationStart(code)\n    }\n    effects.enter('htmlFlowData')\n    return continuation(code)\n  }\n\n  /**\n   * In comment continuation, after one `-`, expecting another.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n    return continuation(code)\n  }\n\n  /**\n   * In raw continuation, after `<`, at `/`.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code)\n      buffer = ''\n      return continuationRawEndTag\n    }\n    return continuation(code)\n  }\n\n  /**\n   * In raw continuation, after `</`, in a raw tag name.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                             ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawEndTag(code) {\n    if (code === 62) {\n      const name = buffer.toLowerCase()\n      if (htmlRawNames.includes(name)) {\n        effects.consume(code)\n        return continuationClose\n      }\n      return continuation(code)\n    }\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code)\n      // @ts-expect-error: not null.\n      buffer += String.fromCharCode(code)\n      return continuationRawEndTag\n    }\n    return continuation(code)\n  }\n\n  /**\n   * In cdata continuation, after `]`, expecting `]>`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *                  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCdataInside(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n    return continuation(code)\n  }\n\n  /**\n   * In declaration or instruction continuation, at `>`.\n   *\n   * ```markdown\n   * > | <!-->\n   *         ^\n   * > | <?>\n   *       ^\n   * > | <!q>\n   *        ^\n   * > | <!--ab-->\n   *             ^\n   * > | <![CDATA[>&<]]>\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    // More dashes.\n    if (code === 45 && marker === 2) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n    return continuation(code)\n  }\n\n  /**\n   * In closed continuation: everything we get until the eol/eof is part of it.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData')\n      return continuationAfter(code)\n    }\n    effects.consume(code)\n    return continuationClose\n  }\n\n  /**\n   * Done.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationAfter(code) {\n    effects.exit('htmlFlow')\n    // // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    // // No longer concrete.\n    // tokenizer.concrete = false\n    return ok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuationStart(effects, ok, nok) {\n  const self = this\n  return start\n\n  /**\n   * At eol, before continuation.\n   *\n   * ```markdown\n   * > | * ```js\n   *            ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return after\n    }\n    return nok(code)\n  }\n\n  /**\n   * A continuation.\n   *\n   * ```markdown\n   *   | * ```js\n   * > | b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLineBefore(effects, ok, nok) {\n  return start\n\n  /**\n   * Before eol, expecting blank line.\n   *\n   * ```markdown\n   * > | <div>\n   *          ^\n   *   |\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return effects.attempt(blankLine, ok, nok)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nconst nonLazyContinuation = {\n  tokenize: tokenizeNonLazyContinuation,\n  partial: true\n}\n\n/** @type {Construct} */\nexport const codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  const self = this\n  /** @type {Construct} */\n  const closeStart = {\n    tokenize: tokenizeCloseStart,\n    partial: true\n  }\n  let initialPrefix = 0\n  let sizeOpen = 0\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n\n  /**\n   * Start of code.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse whitespace like `markdown-rs`.\n    return beforeSequenceOpen(code)\n  }\n\n  /**\n   * In opening fence, after prefix, at sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeSequenceOpen(code) {\n    const tail = self.events[self.events.length - 1]\n    initialPrefix =\n      tail && tail[1].type === 'linePrefix'\n        ? tail[2].sliceSerialize(tail[1], true).length\n        : 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)\n      ? factorySpace(effects, infoBefore, 'whitespace')(code)\n      : 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\n        ? ok(code)\n        : 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)\n      ? factorySpace(\n          effects,\n          beforeContentChunk,\n          'linePrefix',\n          initialPrefix + 1\n        )(code)\n      : beforeContentChunk(code)\n  }\n\n  /**\n   * Before code content, after optional prefix.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeContentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return effects.check(nonLazyContinuation, atNonLazyBreak, after)(code)\n    }\n    effects.enter('codeFlowValue')\n    return contentChunk(code)\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^^^^^^^^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return beforeContentChunk(code)\n    }\n    effects.consume(code)\n    return contentChunk\n  }\n\n  /**\n   * After code.\n   *\n   * ```markdown\n   *   | ~~~js\n   *   | alert(1)\n   * > | ~~~\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    effects.exit('codeFenced')\n    return ok(code)\n  }\n\n  /**\n   * @this {TokenizeContext}\n   * @type {Tokenizer}\n   */\n  function tokenizeCloseStart(effects, ok, nok) {\n    let size = 0\n    return startBefore\n\n    /**\n     *\n     *\n     * @type {State}\n     */\n    function startBefore(code) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return start\n    }\n\n    /**\n     * Before closing fence, at optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function start(code) {\n      // Always populated by defaults.\n\n      // To do: `enter` here or in next state?\n      effects.enter('codeFencedFence')\n      return markdownSpace(code)\n        ? factorySpace(\n            effects,\n            beforeSequenceClose,\n            'linePrefix',\n            self.parser.constructs.disable.null.includes('codeIndented')\n              ? undefined\n              : 4\n          )(code)\n        : 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)\n          ? factorySpace(effects, sequenceCloseAfter, 'whitespace')(code)\n          : sequenceCloseAfter(code)\n      }\n      return nok(code)\n    }\n\n    /**\n     * After closing fence sequence, after optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *        ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceCloseAfter(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit('codeFencedFence')\n        return ok(code)\n      }\n      return nok(code)\n    }\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuation(effects, ok, nok) {\n  const self = this\n  return start\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === null) {\n      return nok(code)\n    }\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return lineStart\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function lineStart(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {\n  asciiAlphanumeric,\n  asciiDigit,\n  asciiHexDigit\n} from 'micromark-util-character'\n/** @type {Construct} */\nexport const characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  const self = this\n  let size = 0\n  /** @type {number} */\n  let max\n  /** @type {(code: Code) => boolean} */\n  let test\n  return start\n\n  /**\n   * Start of character reference.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *      ^\n   * > | a&#123;b\n   *      ^\n   * > | a&#x9;b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('characterReference')\n    effects.enter('characterReferenceMarker')\n    effects.consume(code)\n    effects.exit('characterReferenceMarker')\n    return open\n  }\n\n  /**\n   * After `&`, at `#` for numeric references or alphanumeric for named\n   * references.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^\n   * > | a&#123;b\n   *       ^\n   * > | a&#x9;b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 35) {\n      effects.enter('characterReferenceMarkerNumeric')\n      effects.consume(code)\n      effects.exit('characterReferenceMarkerNumeric')\n      return numeric\n    }\n    effects.enter('characterReferenceValue')\n    max = 31\n    test = asciiAlphanumeric\n    return value(code)\n  }\n\n  /**\n   * After `#`, at `x` for hexadecimals or digit for decimals.\n   *\n   * ```markdown\n   * > | a&#123;b\n   *        ^\n   * > | a&#x9;b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter('characterReferenceMarkerHexadecimal')\n      effects.consume(code)\n      effects.exit('characterReferenceMarkerHexadecimal')\n      effects.enter('characterReferenceValue')\n      max = 6\n      test = asciiHexDigit\n      return value\n    }\n    effects.enter('characterReferenceValue')\n    max = 7\n    test = asciiDigit\n    return value(code)\n  }\n\n  /**\n   * After markers (`&#x`, `&#`, or `&`), in value, before `;`.\n   *\n   * The character reference kind defines what and how many characters are\n   * allowed.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^^^\n   * > | a&#123;b\n   *        ^^^\n   * > | a&#x9;b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function value(code) {\n    if (code === 59 && size) {\n      const token = effects.exit('characterReferenceValue')\n      if (\n        test === asciiAlphanumeric &&\n        !decodeNamedCharacterReference(self.sliceSerialize(token))\n      ) {\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","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {asciiPunctuation} from 'micromark-util-character'\n/** @type {Construct} */\nexport const characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start\n\n  /**\n   * Start of character escape.\n   *\n   * ```markdown\n   * > | a\\*b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('characterEscape')\n    effects.enter('escapeMarker')\n    effects.consume(code)\n    effects.exit('escapeMarker')\n    return inside\n  }\n\n  /**\n   * After `\\`, at punctuation.\n   *\n   * ```markdown\n   * > | a\\*b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    // ASCII punctuation.\n    if (asciiPunctuation(code)) {\n      effects.enter('characterEscapeValue')\n      effects.consume(code)\n      effects.exit('characterEscapeValue')\n      effects.exit('characterEscape')\n      return ok\n    }\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n/** @type {Construct} */\nexport const lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLineEnding(effects, ok) {\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, ok, 'linePrefix')\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factoryDestination} from 'micromark-factory-destination'\nimport {factoryLabel} from 'micromark-factory-label'\nimport {factoryTitle} from 'micromark-factory-title'\nimport {factoryWhitespace} from 'micromark-factory-whitespace'\nimport {markdownLineEndingOrSpace} from 'micromark-util-character'\nimport {push, splice} from 'micromark-util-chunked'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {resolveAll} from 'micromark-util-resolve-all'\n/** @type {Construct} */\nexport const labelEnd = {\n  name: 'labelEnd',\n  tokenize: tokenizeLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  resolveAll: resolveAllLabelEnd\n}\n\n/** @type {Construct} */\nconst resourceConstruct = {\n  tokenize: tokenizeResource\n}\n/** @type {Construct} */\nconst referenceFullConstruct = {\n  tokenize: tokenizeReferenceFull\n}\n/** @type {Construct} */\nconst referenceCollapsedConstruct = {\n  tokenize: tokenizeReferenceCollapsed\n}\n\n/** @type {Resolver} */\nfunction resolveAllLabelEnd(events) {\n  let index = -1\n  while (++index < events.length) {\n    const token = events[index][1]\n    if (\n      token.type === 'labelImage' ||\n      token.type === 'labelLink' ||\n      token.type === 'labelEnd'\n    ) {\n      // Remove the marker.\n      events.splice(index + 1, token.type === 'labelImage' ? 4 : 2)\n      token.type = 'data'\n      index++\n    }\n  }\n  return events\n}\n\n/** @type {Resolver} */\nfunction resolveToLabelEnd(events, context) {\n  let index = events.length\n  let offset = 0\n  /** @type {Token} */\n  let token\n  /** @type {number | undefined} */\n  let open\n  /** @type {number | undefined} */\n  let close\n  /** @type {Array<Event>} */\n  let media\n\n  // Find an opening.\n  while (index--) {\n    token = events[index][1]\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (\n        token.type === 'link' ||\n        (token.type === 'labelLink' && token._inactive)\n      ) {\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 (\n        events[index][0] === 'enter' &&\n        (token.type === 'labelImage' || token.type === 'labelLink') &&\n        !token._balanced\n      ) {\n        open = index\n        if (token.type !== 'labelLink') {\n          offset = 2\n          break\n        }\n      }\n    } else if (token.type === 'labelEnd') {\n      close = index\n    }\n  }\n  const group = {\n    type: events[open][1].type === 'labelLink' ? 'link' : 'image',\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  }\n  const label = {\n    type: 'label',\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[close][1].end)\n  }\n  const text = {\n    type: 'labelText',\n    start: Object.assign({}, events[open + offset + 2][1].end),\n    end: Object.assign({}, events[close - 2][1].start)\n  }\n  media = [\n    ['enter', group, context],\n    ['enter', label, context]\n  ]\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(\n    media,\n    resolveAll(\n      context.parser.constructs.insideSpan.null,\n      events.slice(open + offset + 4, close - 3),\n      context\n    )\n  )\n\n  // Text close, marker close, label close.\n  media = push(media, [\n    ['exit', text, context],\n    events[close - 2],\n    events[close - 1],\n    ['exit', label, context]\n  ])\n\n  // Reference, resource, or so.\n  media = push(media, events.slice(close + 1))\n\n  // Media close.\n  media = push(media, [['exit', group, context]])\n  splice(events, open, events.length, media)\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  const self = this\n  let index = self.events.length\n  /** @type {Token} */\n  let labelStart\n  /** @type {boolean} */\n  let defined\n\n  // Find an opening.\n  while (index--) {\n    if (\n      (self.events[index][1].type === 'labelImage' ||\n        self.events[index][1].type === 'labelLink') &&\n      !self.events[index][1]._balanced\n    ) {\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(\n      normalizeIdentifier(\n        self.sliceSerialize({\n          start: labelStart.end,\n          end: self.now()\n        })\n      )\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(\n        resourceConstruct,\n        labelEndOk,\n        defined ? labelEndOk : labelEndNok\n      )(code)\n    }\n\n    // Full (`[asd][fgh]`) or collapsed (`[asd][]`) reference?\n    if (code === 91) {\n      return effects.attempt(\n        referenceFullConstruct,\n        labelEndOk,\n        defined ? referenceNotFull : labelEndNok\n      )(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(\n      referenceCollapsedConstruct,\n      labelEndOk,\n      labelEndNok\n    )(code)\n  }\n\n  /**\n   * Done, we found something.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *           ^\n   * > | [a][b] c\n   *           ^\n   * > | [a][] b\n   *          ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndOk(code) {\n    // Note: `markdown-rs` does a bunch of stuff here.\n    return ok(code)\n  }\n\n  /**\n   * Done, it’s nothing.\n   *\n   * There was an okay opening, but we didn’t match anything.\n   *\n   * ```markdown\n   * > | [a](b c\n   *        ^\n   * > | [a][b c\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndNok(code) {\n    labelStart._balanced = true\n    return nok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeResource(effects, ok, nok) {\n  return resourceStart\n\n  /**\n   * At a resource.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceStart(code) {\n    effects.enter('resource')\n    effects.enter('resourceMarker')\n    effects.consume(code)\n    effects.exit('resourceMarker')\n    return resourceBefore\n  }\n\n  /**\n   * In resource, after `(`, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBefore(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, resourceOpen)(code)\n      : 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(\n      effects,\n      resourceDestinationAfter,\n      resourceDestinationMissing,\n      'resourceDestination',\n      'resourceDestinationLiteral',\n      'resourceDestinationLiteralMarker',\n      'resourceDestinationRaw',\n      'resourceDestinationString',\n      32\n    )(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)\n      ? factoryWhitespace(effects, resourceBetween)(code)\n      : 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(\n        effects,\n        resourceTitleAfter,\n        nok,\n        'resourceTitle',\n        'resourceTitleMarker',\n        'resourceTitleString'\n      )(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)\n      ? factoryWhitespace(effects, resourceEnd)(code)\n      : resourceEnd(code)\n  }\n\n  /**\n   * In resource, at `)`.\n   *\n   * ```markdown\n   * > | [a](b) d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceEnd(code) {\n    if (code === 41) {\n      effects.enter('resourceMarker')\n      effects.consume(code)\n      effects.exit('resourceMarker')\n      effects.exit('resource')\n      return ok\n    }\n    return nok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceFull(effects, ok, nok) {\n  const self = this\n  return referenceFull\n\n  /**\n   * In a reference (full), at the `[`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFull(code) {\n    return factoryLabel.call(\n      self,\n      effects,\n      referenceFullAfter,\n      referenceFullMissing,\n      'reference',\n      'referenceMarker',\n      'referenceString'\n    )(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(\n      normalizeIdentifier(\n        self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n      )\n    )\n      ? ok(code)\n      : nok(code)\n  }\n\n  /**\n   * In reference (full) that was missing.\n   *\n   * ```markdown\n   * > | [a][b d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullMissing(code) {\n    return nok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceCollapsed(effects, ok, nok) {\n  return referenceCollapsedStart\n\n  /**\n   * In reference (collapsed), at `[`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceCollapsedStart(code) {\n    // We only attempt a collapsed label if there’s a `[`.\n\n    effects.enter('reference')\n    effects.enter('referenceMarker')\n    effects.consume(code)\n    effects.exit('referenceMarker')\n    return referenceCollapsedOpen\n  }\n\n  /**\n   * In reference (collapsed), at `]`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *         ^\n   * ```\n   *\n   *  @type {State}\n   */\n  function referenceCollapsedOpen(code) {\n    if (code === 93) {\n      effects.enter('referenceMarker')\n      effects.consume(code)\n      effects.exit('referenceMarker')\n      effects.exit('reference')\n      return ok\n    }\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {labelEnd} from './label-end.js'\n\n/** @type {Construct} */\nexport const labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  const self = this\n  return start\n\n  /**\n   * Start of label (image) start.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('labelImage')\n    effects.enter('labelImageMarker')\n    effects.consume(code)\n    effects.exit('labelImageMarker')\n    return open\n  }\n\n  /**\n   * After `!`, at `[`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 91) {\n      effects.enter('labelMarker')\n      effects.consume(code)\n      effects.exit('labelMarker')\n      effects.exit('labelImage')\n      return after\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `![`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *         ^\n   * ```\n   *\n   * This is needed in because, when GFM footnotes are enabled, images never\n   * form when started with a `^`.\n   * Instead, links form:\n   *\n   * ```markdown\n   * ![^a](b)\n   *\n   * ![^a][b]\n   *\n   * [b]: c\n   * ```\n   *\n   * ```html\n   * <p>!<a href=\\\"b\\\">^a</a></p>\n   * <p>!<a href=\\\"c\\\">^a</a></p>\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // To do: use a new field to do this, this is still needed for\n    // `micromark-extension-gfm-footnote`, but the `label-start-link`\n    // behavior isn’t.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs\n      ? nok(code)\n      : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {push, splice} from 'micromark-util-chunked'\nimport {classifyCharacter} from 'micromark-util-classify-character'\nimport {resolveAll} from 'micromark-util-resolve-all'\n/** @type {Construct} */\nexport const attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\n}\n\n/**\n * Take all events and resolve attention to emphasis or strong.\n *\n * @type {Resolver}\n */\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 (\n      events[index][0] === 'enter' &&\n      events[index][1].type === 'attentionSequence' &&\n      events[index][1]._close\n    ) {\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 (\n          events[open][0] === 'exit' &&\n          events[open][1].type === 'attentionSequence' &&\n          events[open][1]._open &&\n          // If the markers are the same:\n          context.sliceSerialize(events[open][1]).charCodeAt(0) ===\n            context.sliceSerialize(events[index][1]).charCodeAt(0)\n        ) {\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 (\n            (events[open][1]._close || events[index][1]._open) &&\n            (events[index][1].end.offset - events[index][1].start.offset) % 3 &&\n            !(\n              (events[open][1].end.offset -\n                events[open][1].start.offset +\n                events[index][1].end.offset -\n                events[index][1].start.offset) %\n              3\n            )\n          ) {\n            continue\n          }\n\n          // Number of markers to use from the sequence.\n          use =\n            events[open][1].end.offset - events[open][1].start.offset > 1 &&\n            events[index][1].end.offset - events[index][1].start.offset > 1\n              ? 2\n              : 1\n          const start = Object.assign({}, events[open][1].end)\n          const end = Object.assign({}, events[index][1].start)\n          movePoint(start, -use)\n          movePoint(end, use)\n          openingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start,\n            end: Object.assign({}, events[open][1].end)\n          }\n          closingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: Object.assign({}, events[index][1].start),\n            end\n          }\n          text = {\n            type: use > 1 ? 'strongText' : 'emphasisText',\n            start: Object.assign({}, events[open][1].end),\n            end: Object.assign({}, events[index][1].start)\n          }\n          group = {\n            type: use > 1 ? 'strong' : 'emphasis',\n            start: Object.assign({}, openingSequence.start),\n            end: Object.assign({}, closingSequence.end)\n          }\n          events[open][1].end = Object.assign({}, openingSequence.start)\n          events[index][1].start = Object.assign({}, closingSequence.end)\n          nextEvents = []\n\n          // If there are more markers in the opening, add them before.\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = push(nextEvents, [\n              ['enter', events[open][1], context],\n              ['exit', events[open][1], context]\n            ])\n          }\n\n          // Opening.\n          nextEvents = push(nextEvents, [\n            ['enter', group, context],\n            ['enter', openingSequence, context],\n            ['exit', openingSequence, context],\n            ['enter', text, context]\n          ])\n\n          // Always populated by defaults.\n\n          // Between.\n          nextEvents = push(\n            nextEvents,\n            resolveAll(\n              context.parser.constructs.insideSpan.null,\n              events.slice(open + 1, index),\n              context\n            )\n          )\n\n          // Closing.\n          nextEvents = push(nextEvents, [\n            ['exit', text, context],\n            ['enter', closingSequence, context],\n            ['exit', closingSequence, context],\n            ['exit', group, context]\n          ])\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, [\n              ['enter', events[index][1], context],\n              ['exit', events[index][1], context]\n            ])\n          } else {\n            offset = 0\n          }\n          splice(events, open - 1, index - open + 3, nextEvents)\n          index = open + nextEvents.length - offset - 2\n          break\n        }\n      }\n    }\n  }\n\n  // Remove remaining sequences.\n  index = -1\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data'\n    }\n  }\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeAttention(effects, ok) {\n  const attentionMarkers = this.parser.constructs.attentionMarkers.null\n  const previous = this.previous\n  const before = classifyCharacter(previous)\n\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n\n  /**\n   * Before a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    marker = code\n    effects.enter('attentionSequence')\n    return inside(code)\n  }\n\n  /**\n   * In a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return inside\n    }\n    const token = effects.exit('attentionSequence')\n\n    // To do: next major: move this to resolver, just like `markdown-rs`.\n    const after = classifyCharacter(code)\n\n    // Always populated by defaults.\n\n    const open =\n      !after || (after === 2 && before) || attentionMarkers.includes(code)\n    const close =\n      !before || (before === 2 && after) || attentionMarkers.includes(previous)\n    token._open = Boolean(marker === 42 ? open : open && (before || !close))\n    token._close = Boolean(marker === 42 ? close : close && (after || !open))\n    return ok(code)\n  }\n}\n\n/**\n * Move a point a bit.\n *\n * Note: `move` only works inside lines! It’s not possible to move past other\n * chunks (replacement characters, tabs, or line endings).\n *\n * @param {Point} point\n * @param {number} offset\n * @returns {void}\n */\nfunction movePoint(point, offset) {\n  point.column += offset\n  point.offset += offset\n  point._bufferIndex += offset\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  asciiAtext,\n  asciiControl\n} from 'micromark-util-character'\n/** @type {Construct} */\nexport const autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeAutolink(effects, ok, nok) {\n  let size = 0\n  return start\n\n  /**\n   * Start of an autolink.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *      ^\n   * > | a<user@example.com>b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('autolink')\n    effects.enter('autolinkMarker')\n    effects.consume(code)\n    effects.exit('autolinkMarker')\n    effects.enter('autolinkProtocol')\n    return open\n  }\n\n  /**\n   * After `<`, at protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *       ^\n   * > | a<user@example.com>b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return schemeOrEmailAtext\n    }\n    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 (\n      (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) &&\n      size++ < 32\n    ) {\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","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\n/** @type {Construct} */\nexport const htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlText(effects, ok, nok) {\n  const self = this\n  /** @type {NonNullable<Code> | undefined} */\n  let marker\n  /** @type {number} */\n  let index\n  /** @type {State} */\n  let returnState\n  return start\n\n  /**\n   * Start of HTML (text).\n   *\n   * ```markdown\n   * > | a <b> c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('htmlText')\n    effects.enter('htmlTextData')\n    effects.consume(code)\n    return open\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | a <b> c\n   *        ^\n   * > | a <!doctype> c\n   *        ^\n   * > | a <!--b--> c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationOpen\n    }\n    if (code === 47) {\n      effects.consume(code)\n      return tagCloseStart\n    }\n    if (code === 63) {\n      effects.consume(code)\n      return instruction\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | a <!doctype> c\n   *         ^\n   * > | a <!--b--> c\n   *         ^\n   * > | a <![CDATA[>&<]]> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentOpenInside\n    }\n    if (code === 91) {\n      effects.consume(code)\n      index = 0\n      return cdataOpenInside\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return declaration\n    }\n    return nok(code)\n  }\n\n  /**\n   * In a comment, after `<!-`, at another `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentEnd\n    }\n    return nok(code)\n  }\n\n  /**\n   * In comment.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function comment(code) {\n    if (code === null) {\n      return nok(code)\n    }\n    if (code === 45) {\n      effects.consume(code)\n      return commentClose\n    }\n    if (markdownLineEnding(code)) {\n      returnState = comment\n      return lineEndingBefore(code)\n    }\n    effects.consume(code)\n    return comment\n  }\n\n  /**\n   * In comment, after `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentEnd\n    }\n    return comment(code)\n  }\n\n  /**\n   * In comment, after `--`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentEnd(code) {\n    return code === 62\n      ? end(code)\n      : code === 45\n      ? commentClose(code)\n      : 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 (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\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 (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\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 (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 60 ||\n      code === 61 ||\n      code === 96\n    ) {\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)\n      ? factorySpace(\n          effects,\n          lineEndingAfterPrefix,\n          'linePrefix',\n          self.parser.constructs.disable.null.includes('codeIndented')\n            ? undefined\n            : 4\n        )(code)\n      : 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","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {labelEnd} from './label-end.js'\n\n/** @type {Construct} */\nexport const labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  const self = this\n  return start\n\n  /**\n   * Start of label (link) start.\n   *\n   * ```markdown\n   * > | a [b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('labelLink')\n    effects.enter('labelMarker')\n    effects.consume(code)\n    effects.exit('labelMarker')\n    effects.exit('labelLink')\n    return after\n  }\n\n  /** @type {State} */\n  function after(code) {\n    // To do: this isn’t needed in `micromark-extension-gfm-footnote`,\n    // remove.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs\n      ? nok(code)\n      : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {markdownLineEnding} from 'micromark-util-character'\n/** @type {Construct} */\nexport const hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start\n\n  /**\n   * Start of a hard break (escape).\n   *\n   * ```markdown\n   * > | a\\\n   *      ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('hardBreakEscape')\n    effects.consume(code)\n    return after\n  }\n\n  /**\n   * After `\\`, at eol.\n   *\n   * ```markdown\n   * > | a\\\n   *       ^\n   *   | b\n   * ```\n   *\n   *  @type {State}\n   */\n  function after(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit('hardBreakEscape')\n      return ok(code)\n    }\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Previous} Previous\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {markdownLineEnding} from 'micromark-util-character'\n/** @type {Construct} */\nexport const codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous\n}\n\n// To do: next major: don’t resolve, like `markdown-rs`.\n/** @type {Resolver} */\nfunction resolveCodeText(events) {\n  let tailExitIndex = events.length - 4\n  let headEnterIndex = 3\n  /** @type {number} */\n  let index\n  /** @type {number | undefined} */\n  let enter\n\n  // If we start and end with an EOL or a space.\n  if (\n    (events[headEnterIndex][1].type === 'lineEnding' ||\n      events[headEnterIndex][1].type === 'space') &&\n    (events[tailExitIndex][1].type === 'lineEnding' ||\n      events[tailExitIndex][1].type === 'space')\n  ) {\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 (\n      index === tailExitIndex ||\n      events[index][1].type === 'lineEnding'\n    ) {\n      events[enter][1].type = 'codeTextData'\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end\n        events.splice(enter + 2, index - enter - 2)\n        tailExitIndex -= index - enter - 2\n        index = enter + 2\n      }\n      enter = undefined\n    }\n  }\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Previous}\n */\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return (\n    code !== 96 ||\n    this.events[this.events.length - 1][1].type === 'characterEscape'\n  )\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCodeText(effects, ok, nok) {\n  const self = this\n  let sizeOpen = 0\n  /** @type {number} */\n  let size\n  /** @type {Token} */\n  let token\n  return start\n\n  /**\n   * Start of code (text).\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * > | \\`a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('codeText')\n    effects.enter('codeTextSequence')\n    return sequenceOpen(code)\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 96) {\n      effects.consume(code)\n      sizeOpen++\n      return sequenceOpen\n    }\n    effects.exit('codeTextSequence')\n    return between(code)\n  }\n\n  /**\n   * Between something and something else.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function between(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code)\n    }\n\n    // To do: next major: don’t do spaces in resolve, but when compiling,\n    // like `markdown-rs`.\n    // Tabs don’t work, and virtual spaces don’t make sense.\n    if (code === 32) {\n      effects.enter('space')\n      effects.consume(code)\n      effects.exit('space')\n      return between\n    }\n\n    // Closing fence? Could also be data.\n    if (code === 96) {\n      token = effects.enter('codeTextSequence')\n      size = 0\n      return sequenceClose(code)\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return between\n    }\n\n    // Data.\n    effects.enter('codeTextData')\n    return data(code)\n  }\n\n  /**\n   * In data.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (\n      code === null ||\n      code === 32 ||\n      code === 96 ||\n      markdownLineEnding(code)\n    ) {\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","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n */\n\nimport {\n  attention,\n  autolink,\n  blockQuote,\n  characterEscape,\n  characterReference,\n  codeFenced,\n  codeIndented,\n  codeText,\n  definition,\n  hardBreakEscape,\n  headingAtx,\n  htmlFlow,\n  htmlText,\n  labelEnd,\n  labelStartImage,\n  labelStartLink,\n  lineEnding,\n  list,\n  setextUnderline,\n  thematicBreak\n} from 'micromark-core-commonmark'\nimport {resolver as resolveText} from './initialize/text.js'\n\n/** @satisfies {Extension['document']} */\nexport const document = {\n  [42]: list,\n  [43]: list,\n  [45]: list,\n  [48]: list,\n  [49]: list,\n  [50]: list,\n  [51]: list,\n  [52]: list,\n  [53]: list,\n  [54]: list,\n  [55]: list,\n  [56]: list,\n  [57]: list,\n  [62]: blockQuote\n}\n\n/** @satisfies {Extension['contentInitial']} */\nexport const contentInitial = {\n  [91]: definition\n}\n\n/** @satisfies {Extension['flowInitial']} */\nexport const flowInitial = {\n  [-2]: codeIndented,\n  [-1]: codeIndented,\n  [32]: codeIndented\n}\n\n/** @satisfies {Extension['flow']} */\nexport const flow = {\n  [35]: headingAtx,\n  [42]: thematicBreak,\n  [45]: [setextUnderline, thematicBreak],\n  [60]: htmlFlow,\n  [61]: setextUnderline,\n  [95]: thematicBreak,\n  [96]: codeFenced,\n  [126]: codeFenced\n}\n\n/** @satisfies {Extension['string']} */\nexport const string = {\n  [38]: characterReference,\n  [92]: characterEscape\n}\n\n/** @satisfies {Extension['text']} */\nexport const text = {\n  [-5]: lineEnding,\n  [-4]: lineEnding,\n  [-3]: lineEnding,\n  [33]: labelStartImage,\n  [38]: characterReference,\n  [42]: attention,\n  [60]: [autolink, htmlText],\n  [91]: labelStartLink,\n  [92]: [hardBreakEscape, characterEscape],\n  [93]: labelEnd,\n  [95]: attention,\n  [96]: codeText\n}\n\n/** @satisfies {Extension['insideSpan']} */\nexport const insideSpan = {\n  null: [attention, resolveText]\n}\n\n/** @satisfies {Extension['attentionMarkers']} */\nexport const attentionMarkers = {\n  null: [42, 95]\n}\n\n/** @satisfies {Extension['disable']} */\nexport const disable = {\n  null: []\n}\n","/**\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Value} Value\n */\n\n/**\n * @callback Preprocessor\n * @param {Value} value\n * @param {Encoding | null | undefined} [encoding]\n * @param {boolean | null | undefined} [end=false]\n * @returns {Array<Chunk>}\n */\n\nconst search = /[\\0\\t\\n\\r]/g\n\n/**\n * @returns {Preprocessor}\n */\nexport function preprocess() {\n  let column = 1\n  let buffer = ''\n  /** @type {boolean | undefined} */\n  let start = true\n  /** @type {boolean | undefined} */\n  let atCarriageReturn\n  return preprocessor\n\n  /** @type {Preprocessor} */\n  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\n    // @ts-expect-error `Buffer` does allow an encoding.\n    value = buffer + value.toString(encoding)\n    startPosition = 0\n    buffer = ''\n    if (start) {\n      // To do: `markdown-rs` actually parses BOMs (byte order mark).\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++\n      }\n      start = undefined\n    }\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition\n      match = search.exec(value)\n      endPosition =\n        match && match.index !== undefined ? match.index : value.length\n      code = value.charCodeAt(endPosition)\n      if (!match) {\n        buffer = value.slice(startPosition)\n        break\n      }\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3)\n        atCarriageReturn = undefined\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5)\n          atCarriageReturn = undefined\n        }\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition))\n          column += endPosition - startPosition\n        }\n        switch (code) {\n          case 0: {\n            chunks.push(65533)\n            column++\n            break\n          }\n          case 9: {\n            next = Math.ceil(column / 4) * 4\n            chunks.push(-2)\n            while (column++ < next) chunks.push(-1)\n            break\n          }\n          case 10: {\n            chunks.push(-4)\n            column = 1\n            break\n          }\n          default: {\n            atCarriageReturn = true\n            column = 1\n          }\n        }\n      }\n      startPosition = endPosition + 1\n    }\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5)\n      if (buffer) chunks.push(buffer)\n      chunks.push(null)\n    }\n    return chunks\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Value} Value\n *\n * @typedef {import('unist').Parent} UnistParent\n * @typedef {import('unist').Point} Point\n *\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n * @typedef {import('mdast').StaticPhrasingContent} StaticPhrasingContent\n * @typedef {import('mdast').Content} Content\n * @typedef {import('mdast').Break} Break\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('mdast').Code} Code\n * @typedef {import('mdast').Definition} Definition\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('mdast').HTML} HTML\n * @typedef {import('mdast').Image} Image\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('mdast').Link} Link\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('mdast').List} List\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('mdast').Text} Text\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n * @typedef {import('mdast').ReferenceType} ReferenceType\n * @typedef {import('../index.js').CompileData} CompileData\n */\n\n/**\n * @typedef {Root | Content} Node\n * @typedef {Extract<Node, UnistParent>} Parent\n *\n * @typedef {Omit<UnistParent, 'type' | 'children'> & {type: 'fragment', children: Array<PhrasingContent>}} Fragment\n */\n\n/**\n * @callback Transform\n *   Extra transform, to change the AST afterwards.\n * @param {Root} tree\n *   Tree to transform.\n * @returns {Root | undefined | null | void}\n *   New tree or nothing (in which case the current tree is used).\n *\n * @callback Handle\n *   Handle a token.\n * @param {CompileContext} this\n *   Context.\n * @param {Token} token\n *   Current token.\n * @returns {void}\n *   Nothing.\n *\n * @typedef {Record<string, Handle>} Handles\n *   Token types mapping to handles\n *\n * @callback OnEnterError\n *   Handle the case where the `right` token is open, but it is closed (by the\n *   `left` token) or because we reached the end of the document.\n * @param {Omit<CompileContext, 'sliceSerialize'>} this\n *   Context.\n * @param {Token | undefined} left\n *   Left token.\n * @param {Token} right\n *   Right token.\n * @returns {void}\n *   Nothing.\n *\n * @callback OnExitError\n *   Handle the case where the `right` token is open but it is closed by\n *   exiting the `left` token.\n * @param {Omit<CompileContext, 'sliceSerialize'>} this\n *   Context.\n * @param {Token} left\n *   Left token.\n * @param {Token} right\n *   Right token.\n * @returns {void}\n *   Nothing.\n *\n * @typedef {[Token, OnEnterError | undefined]} TokenTuple\n *   Open token on the stack, with an optional error handler for when\n *   that token isn’t closed properly.\n */\n\n/**\n * @typedef Config\n *   Configuration.\n *\n *   We have our defaults, but extensions will add more.\n * @property {Array<string>} canContainEols\n *   Token types where line endings are used.\n * @property {Handles} enter\n *   Opening handles.\n * @property {Handles} exit\n *   Closing handles.\n * @property {Array<Transform>} transforms\n *   Tree transforms.\n *\n * @typedef {Partial<Config>} Extension\n *   Change how markdown tokens from micromark are turned into mdast.\n *\n * @typedef CompileContext\n *   mdast compiler context.\n * @property {Array<Node | Fragment>} stack\n *   Stack of nodes.\n * @property {Array<TokenTuple>} tokenStack\n *   Stack of tokens.\n * @property {<Key extends keyof CompileData>(key: Key) => CompileData[Key]} getData\n *   Get data from the key/value store.\n * @property {<Key extends keyof CompileData>(key: Key, value?: CompileData[Key]) => void} setData\n *   Set data into the key/value store.\n * @property {(this: CompileContext) => void} buffer\n *   Capture some of the output data.\n * @property {(this: CompileContext) => string} resume\n *   Stop capturing and access the output data.\n * @property {<Kind extends Node>(this: CompileContext, node: Kind, token: Token, onError?: OnEnterError) => Kind} enter\n *   Enter a token.\n * @property {(this: CompileContext, token: Token, onError?: OnExitError) => Node} exit\n *   Exit a token.\n * @property {TokenizeContext['sliceSerialize']} sliceSerialize\n *   Get the string value of a token.\n * @property {Config} config\n *   Configuration.\n *\n * @typedef FromMarkdownOptions\n *   Configuration for how to build mdast.\n * @property {Array<Extension | Array<Extension>> | null | undefined} [mdastExtensions]\n *   Extensions for this utility to change how tokens are turned into a tree.\n *\n * @typedef {ParseOptions & FromMarkdownOptions} Options\n *   Configuration.\n */\n\n// To do: micromark: create a registry of tokens?\n// To do: next major: don’t return given `Node` from `enter`.\n// To do: next major: remove setter/getter.\n\nimport {toString} from 'mdast-util-to-string'\nimport {parse} from 'micromark/lib/parse.js'\nimport {preprocess} from 'micromark/lib/preprocess.js'\nimport {postprocess} from 'micromark/lib/postprocess.js'\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 * @param value\n *   Markdown to parse.\n * @param encoding\n *   Character encoding for when `value` is `Buffer`.\n * @param options\n *   Configuration.\n * @returns\n *   mdast tree.\n */\nexport const fromMarkdown =\n  /**\n   * @type {(\n   *   ((value: Value, encoding: Encoding, options?: Options | null | undefined) => Root) &\n   *   ((value: Value, options?: Options | null | undefined) => Root)\n   * )}\n   */\n\n  /**\n   * @param {Value} value\n   * @param {Encoding | Options | null | undefined} [encoding]\n   * @param {Options | null | undefined} [options]\n   * @returns {Root}\n   */\n  function (value, encoding, options) {\n    if (typeof encoding !== 'string') {\n      options = encoding\n      encoding = undefined\n    }\n    return compiler(options)(\n      postprocess(\n        parse(options).document().write(preprocess()(value, encoding, true))\n      )\n    )\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      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      setData,\n      getData\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 (\n        events[index][1].type === 'listOrdered' ||\n        events[index][1].type === 'listUnordered'\n      ) {\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(\n          Object.assign(\n            {\n              sliceSerialize: events[index][2].sliceSerialize\n            },\n            context\n          ),\n          events[index][1]\n        )\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(\n        events.length > 0\n          ? events[0][1].start\n          : {\n              line: 1,\n              column: 1,\n              offset: 0\n            }\n      ),\n      end: point(\n        events.length > 0\n          ? events[events.length - 2][1].end\n          : {\n              line: 1,\n              column: 1,\n              offset: 0\n            }\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      if (\n        event[1].type === 'listUnordered' ||\n        event[1].type === 'listOrdered' ||\n        event[1].type === 'blockQuote'\n      ) {\n        if (event[0] === 'enter') {\n          containerBalance++\n        } else {\n          containerBalance--\n        }\n        atMarker = undefined\n      } else if (event[1].type === 'lineEndingBlank') {\n        if (event[0] === 'enter') {\n          if (\n            listItem &&\n            !atMarker &&\n            !containerBalance &&\n            !firstBlankLineIndex\n          ) {\n            firstBlankLineIndex = index\n          }\n          atMarker = undefined\n        }\n      } else if (\n        event[1].type === 'linePrefix' ||\n        event[1].type === 'listItemValue' ||\n        event[1].type === 'listItemMarker' ||\n        event[1].type === 'listItemPrefix' ||\n        event[1].type === 'listItemPrefixWhitespace'\n      ) {\n        // Empty.\n      } else {\n        atMarker = undefined\n      }\n      if (\n        (!containerBalance &&\n          event[0] === 'enter' &&\n          event[1].type === 'listItemPrefix') ||\n        (containerBalance === -1 &&\n          event[0] === 'exit' &&\n          (event[1].type === 'listUnordered' ||\n            event[1].type === 'listOrdered'))\n      ) {\n        if (listItem) {\n          let tailIndex = index\n          lineIndex = undefined\n          while (tailIndex--) {\n            const tailEvent = events[tailIndex]\n            if (\n              tailEvent[1].type === 'lineEnding' ||\n              tailEvent[1].type === 'lineEndingBlank'\n            ) {\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 (\n              tailEvent[1].type === 'linePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefixWhitespace' ||\n              tailEvent[1].type === 'blockQuoteMarker' ||\n              tailEvent[1].type === 'listItemIndent'\n            ) {\n              // Empty\n            } else {\n              break\n            }\n          }\n          if (\n            firstBlankLineIndex &&\n            (!lineIndex || firstBlankLineIndex < lineIndex)\n          ) {\n            listItem._spread = true\n          }\n\n          // Fix position.\n          listItem.end = Object.assign(\n            {},\n            lineIndex ? events[lineIndex][1].start : event[1].end\n          )\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          listItem = {\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          // @ts-expect-error: `listItem` is most definitely defined, TS...\n          events.splice(index, 0, ['enter', listItem, 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   * Set data.\n   *\n   * @template {keyof CompileData} Key\n   *   Field type.\n   * @param {Key} key\n   *   Key of field.\n   * @param {CompileData[Key]} [value]\n   *   New value.\n   * @returns {void}\n   *   Nothing.\n   */\n  function setData(key, value) {\n    data[key] = value\n  }\n\n  /**\n   * Get data.\n   *\n   * @template {keyof CompileData} Key\n   *   Field type.\n   * @param {Key} key\n   *   Key of field.\n   * @returns {CompileData[Key]}\n   *   Value.\n   */\n  function getData(key) {\n    return data[key]\n  }\n\n  /**\n   * Create an opener handle.\n   *\n   * @param {(token: Token) => Node} create\n   *   Create a node.\n   * @param {Handle} [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 {void}\n     */\n    function open(token) {\n      enter.call(this, create(token), token)\n      if (and) and.call(this, token)\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @returns {void}\n   */\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    })\n  }\n\n  /**\n   * @template {Node} Kind\n   *   Node type.\n   * @this {CompileContext}\n   *   Context.\n   * @param {Kind} node\n   *   Node to enter.\n   * @param {Token} token\n   *   Corresponding token.\n   * @param {OnEnterError | undefined} [errorHandler]\n   *   Handle the case where this token is open, but it is closed by something else.\n   * @returns {Kind}\n   *   The given node.\n   */\n  function enter(node, token, errorHandler) {\n    const parent = this.stack[this.stack.length - 1]\n    // @ts-expect-error: Assume `Node` can exist as a child of `parent`.\n    parent.children.push(node)\n    this.stack.push(node)\n    this.tokenStack.push([token, errorHandler])\n    // @ts-expect-error: `end` will be patched later.\n    node.position = {\n      start: point(token.start)\n    }\n    return node\n  }\n\n  /**\n   * Create a closer handle.\n   *\n   * @param {Handle} [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 {void}\n     */\n    function close(token) {\n      if (and) and.call(this, token)\n      exit.call(this, token)\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   *   Context.\n   * @param {Token} token\n   *   Corresponding token.\n   * @param {OnExitError | undefined} [onExitError]\n   *   Handle the case where another token is open.\n   * @returns {Node}\n   *   The closed node.\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(\n        'Cannot close `' +\n          token.type +\n          '` (' +\n          stringifyPosition({\n            start: token.start,\n            end: token.end\n          }) +\n          '): it’s not open'\n      )\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    return node\n  }\n\n  /**\n   * @this {CompileContext}\n   * @returns {string}\n   */\n  function resume() {\n    return toString(this.stack.pop())\n  }\n\n  //\n  // Handlers.\n  //\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistordered() {\n    setData('expectingFirstListItemValue', true)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistitemvalue(token) {\n    if (getData('expectingFirstListItemValue')) {\n      const ancestor = this.stack[this.stack.length - 2]\n      ancestor.start = Number.parseInt(this.sliceSerialize(token), 10)\n      setData('expectingFirstListItemValue')\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 (getData('flowCodeInside')) return\n    this.buffer()\n    setData('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    setData('flowCodeInside')\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(\n      this.sliceSerialize(token)\n    ).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    setData('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).charCodeAt(0) === 61 ? 1 : 2\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheading() {\n    setData('setextHeadingSlurpLineEnding')\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    let tail = node.children[node.children.length - 1]\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text()\n      // @ts-expect-error: we’ll add `end` later.\n      tail.position = {\n        start: point(token.start)\n      }\n      // @ts-expect-error: Assume `parent` accepts `text`.\n      node.children.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 (getData('atHardBreak')) {\n      const tail = context.children[context.children.length - 1]\n      tail.position.end = point(token.end)\n      setData('atHardBreak')\n      return\n    }\n    if (\n      !getData('setextHeadingSlurpLineEnding') &&\n      config.canContainEols.includes(context.type)\n    ) {\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    setData('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    // To do: clean.\n    if (getData('inReference')) {\n      /** @type {ReferenceType} */\n      const referenceType = getData('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    setData('referenceType')\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    // To do: clean.\n    if (getData('inReference')) {\n      /** @type {ReferenceType} */\n      const referenceType = getData('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    setData('referenceType')\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    setData('inReference', true)\n    if (node.type === 'link') {\n      /** @type {Array<StaticPhrasingContent>} */\n      // @ts-expect-error: Assume static phrasing content.\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    setData('inReference')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterreference() {\n    setData('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(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n    setData('referenceType', 'full')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcharacterreferencemarker(token) {\n    setData('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 = getData('characterReferenceType')\n    /** @type {string} */\n    let value\n    if (type) {\n      value = decodeNumericCharacterReference(\n        data,\n        type === 'characterReferenceMarkerNumeric' ? 10 : 16\n      )\n      setData('characterReferenceType')\n    } else {\n      const result = decodeNamedCharacterReference(data)\n      value = result\n    }\n    const tail = this.stack.pop()\n    tail.value += value\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    // @ts-expect-error `depth` will be set later.\n    return {\n      type: 'heading',\n      depth: undefined,\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<Extension | Array<Extension>>} extensions\n * @returns {void}\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 {void}\n */\nfunction extension(combined, extension) {\n  /** @type {keyof Extension} */\n  let key\n  for (key in extension) {\n    if (own.call(extension, key)) {\n      if (key === 'canContainEols') {\n        const right = extension[key]\n        if (right) {\n          combined[key].push(...right)\n        }\n      } else if (key === 'transforms') {\n        const right = extension[key]\n        if (right) {\n          combined[key].push(...right)\n        }\n      } else if (key === 'enter' || key === 'exit') {\n        const right = extension[key]\n        if (right) {\n          Object.assign(combined[key], right)\n        }\n      }\n    }\n  }\n}\n\n/** @type {OnEnterError} */\nfunction defaultOnError(left, right) {\n  if (left) {\n    throw new Error(\n      'Cannot close `' +\n        left.type +\n        '` (' +\n        stringifyPosition({\n          start: left.start,\n          end: left.end\n        }) +\n        '): a different token (`' +\n        right.type +\n        '`, ' +\n        stringifyPosition({\n          start: right.start,\n          end: right.end\n        }) +\n        ') is open'\n    )\n  } else {\n    throw new Error(\n      'Cannot close document, a token (`' +\n        right.type +\n        '`, ' +\n        stringifyPosition({\n          start: right.start,\n          end: right.end\n        }) +\n        ') is still open'\n    )\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n */\n\nimport {subtokenize} from 'micromark-util-subtokenize'\n\n/**\n * @param {Array<Event>} events\n * @returns {Array<Event>}\n */\nexport function postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n  return events\n}\n","/**\n * @typedef {import('micromark-util-types').Create} Create\n * @typedef {import('micromark-util-types').FullNormalizedExtension} FullNormalizedExtension\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n */\n\nimport {combineExtensions} from 'micromark-util-combine-extensions'\nimport {content} from './initialize/content.js'\nimport {document} from './initialize/document.js'\nimport {flow} from './initialize/flow.js'\nimport {text, string} from './initialize/text.js'\nimport {createTokenizer} from './create-tokenizer.js'\nimport * as defaultConstructs from './constructs.js'\n\n/**\n * @param {ParseOptions | null | undefined} [options]\n * @returns {ParseContext}\n */\nexport function parse(options) {\n  const settings = options || {}\n  const constructs =\n    /** @type {FullNormalizedExtension} */\n    combineExtensions([defaultConstructs, ...(settings.extensions || [])])\n\n  /** @type {ParseContext} */\n  const parser = {\n    defined: [],\n    lazy: {},\n    constructs,\n    content: create(content),\n    document: create(document),\n    flow: create(flow),\n    string: create(string),\n    text: create(text)\n  }\n  return parser\n\n  /**\n   * @param {InitialConstruct} initial\n   */\n  function create(initial) {\n    return creator\n    /** @type {Create} */\n    function creator(from) {\n      return createTokenizer(parser, initial, from)\n    }\n  }\n}\n","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast-util-from-markdown').Options} Options\n */\n\nimport {fromMarkdown} from 'mdast-util-from-markdown'\n\n/**\n * @this {import('unified').Processor}\n * @type {import('unified').Plugin<[Options?] | void[], string, Root>}\n */\nexport default function remarkParse(options) {\n  /** @type {import('unified').ParserFunction<Root>} */\n  const parser = (doc) => {\n    // Assume options.\n    const settings = /** @type {Options} */ (this.data('settings'))\n\n    return fromMarkdown(\n      doc,\n      Object.assign({}, settings, 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: this.data('micromarkExtensions') || [],\n        mdastExtensions: this.data('fromMarkdownExtensions') || []\n      })\n    )\n  }\n\n  Object.assign(this, {Parser: parser})\n}\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 | undefined} url\n *   URI to sanitize.\n * @param {RegExp | null | undefined} [protocol]\n *   Allowed protocols.\n * @returns {string}\n *   Sanitized URI.\n */\nexport function sanitizeUri(url, protocol) {\n  const value = encode(normalizeUri(url || ''))\n  if (!protocol) {\n    return value\n  }\n  const colon = value.indexOf(':')\n  const questionMark = value.indexOf('?')\n  const numberSign = value.indexOf('#')\n  const slash = value.indexOf('/')\n  if (\n    // If there is no protocol, it’s relative.\n    colon < 0 ||\n    // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.\n    (slash > -1 && colon > slash) ||\n    (questionMark > -1 && colon > questionMark) ||\n    (numberSign > -1 && colon > numberSign) ||\n    // It is a protocol, it should be allowed.\n    protocol.test(value.slice(0, colon))\n  ) {\n    return value\n  }\n  return ''\n}\n\n/**\n * Normalize a URL.\n *\n * Encode unsafe characters with percent-encoding, skipping already encoded\n * sequences.\n *\n * @param {string} value\n *   URI to normalize.\n * @returns {string}\n *   Normalized URI.\n */\nexport function normalizeUri(value) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n  let start = 0\n  let skip = 0\n  while (++index < value.length) {\n    const code = value.charCodeAt(index)\n    /** @type {string} */\n    let replace = ''\n\n    // A correct percent encoded value.\n    if (\n      code === 37 &&\n      asciiAlphanumeric(value.charCodeAt(index + 1)) &&\n      asciiAlphanumeric(value.charCodeAt(index + 2))\n    ) {\n      skip = 2\n    }\n    // ASCII.\n    else if (code < 128) {\n      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {\n        replace = String.fromCharCode(code)\n      }\n    }\n    // Astral.\n    else if (code > 55295 && code < 57344) {\n      const next = value.charCodeAt(index + 1)\n\n      // A correct surrogate pair.\n      if (code < 56320 && next > 56319 && next < 57344) {\n        replace = String.fromCharCode(code, next)\n        skip = 1\n      }\n      // Lone surrogate.\n      else {\n        replace = '\\uFFFD'\n      }\n    }\n    // Unicode.\n    else {\n      replace = String.fromCharCode(code)\n    }\n    if (replace) {\n      result.push(value.slice(start, index), encodeURIComponent(replace))\n      start = index + skip + 1\n      replace = ''\n    }\n    if (skip) {\n      index += skip\n      skip = 0\n    }\n  }\n  return result.join('') + value.slice(start)\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist-util-is').Test} Test\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n */\n\n/**\n * Check if `Child` can be a child of `Ancestor`.\n *\n * Returns the ancestor when `Child` can be a child of `Ancestor`, or returns\n * `never`.\n *\n * @template {Node} Ancestor\n *   Node type.\n * @template {Node} Child\n *   Node type.\n * @typedef {(\n *   Ancestor extends Parent\n *     ? Child extends Ancestor['children'][number]\n *       ? Ancestor\n *       : never\n *     : never\n * )} ParentsOf\n */\n\n/**\n * @template {Node} [Visited=Node]\n *   Visited node type.\n * @template {Parent} [Ancestor=Parent]\n *   Ancestor type.\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 Node ? number | null : never} index\n *   Index of `node` in `parent`.\n * @param {Ancestor extends Node ? Ancestor | null : 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 */\n\n/**\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 *\n * @template {Node} Visited\n *   Node type.\n * @template {Parent} Ancestor\n *   Parent type.\n * @typedef {Visitor<Visited, ParentsOf<Ancestor, Visited>>} BuildVisitorFromMatch\n */\n\n/**\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 *\n * @template {Node} Descendant\n *   Node type.\n * @template {Test} Check\n *   Test type.\n * @typedef {(\n *   BuildVisitorFromMatch<\n *     import('unist-util-visit-parents/complex-types.js').Matches<Descendant, Check>,\n *     Extract<Descendant, Parent>\n *   >\n * )} BuildVisitorFromDescendants\n */\n\n/**\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 *\n * @template {Node} [Tree=Node]\n *   Node type.\n * @template {Test} [Check=string]\n *   Test type.\n * @typedef {(\n *   BuildVisitorFromDescendants<\n *     import('unist-util-visit-parents/complex-types.js').InclusiveDescendant<Tree>,\n *     Check\n *   >\n * )} BuildVisitor\n */\n\nimport {visitParents} 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 * @param tree\n *   Tree to traverse.\n * @param test\n *   `unist-util-is`-compatible test\n * @param visitor\n *   Handle each node.\n * @param reverse\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns\n *   Nothing.\n */\nexport const visit =\n  /**\n   * @type {(\n   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: BuildVisitor<Tree, Check>, reverse?: boolean | null | undefined) => void) &\n   *   (<Tree extends Node>(tree: Tree, visitor: BuildVisitor<Tree>, reverse?: boolean | null | undefined) => void)\n   * )}\n   */\n  (\n    /**\n     * @param {Node} tree\n     * @param {Test} test\n     * @param {Visitor} visitor\n     * @param {boolean | null | undefined} [reverse]\n     * @returns {void}\n     */\n    function (tree, test, visitor, reverse) {\n      if (typeof test === 'function' && typeof visitor !== 'function') {\n        reverse = visitor\n        visitor = test\n        test = null\n      }\n\n      visitParents(tree, test, overload, reverse)\n\n      /**\n       * @param {Node} node\n       * @param {Array<Parent>} parents\n       */\n      function overload(node, parents) {\n        const parent = parents[parents.length - 1]\n        return visitor(\n          node,\n          parent ? parent.children.indexOf(node) : null,\n          parent\n        )\n      }\n    }\n  )\n\nexport {CONTINUE, EXIT, SKIP} from 'unist-util-visit-parents'\n","/**\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\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 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 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 positional info of `node`.\n *\n * @param {NodeLike | Node | null | undefined} [node]\n *   Node.\n * @returns {Position}\n *   Position.\n */\nexport function position(node) {\n  return {start: pointStart(node), end: pointEnd(node)}\n}\n\n/**\n * Get the positional info of `node`.\n *\n * @param {'start' | 'end'} 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 {NodeLike | Node | null | undefined} [node]\n   * @returns {Point}\n   */\n  function point(node) {\n    const point = (node && node.position && node.position[type]) || {}\n\n    // To do: next major: don’t return points when invalid.\n    return {\n      // @ts-expect-error: in practice, null is allowed.\n      line: point.line || null,\n      // @ts-expect-error: in practice, null is allowed.\n      column: point.column || null,\n      // @ts-expect-error: in practice, null is allowed.\n      offset: point.offset > -1 ? point.offset : null\n    }\n  }\n}\n","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').Content} Content\n * @typedef {import('mdast').Definition} Definition\n */\n\n/**\n * @typedef {Root | Content} Node\n *\n * @callback GetDefinition\n *   Get a definition by identifier.\n * @param {string | null | undefined} [identifier]\n *   Identifier of definition.\n * @returns {Definition | null}\n *   Definition corresponding to `identifier` or `null`.\n */\n\nimport {visit} from 'unist-util-visit'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Find definitions in `tree`.\n *\n * Uses CommonMark precedence, which means that earlier definitions are\n * preferred over duplicate later definitions.\n *\n * @param {Node} tree\n *   Tree to check.\n * @returns {GetDefinition}\n *   Getter.\n */\nexport function definitions(tree) {\n  /** @type {Record<string, Definition>} */\n  const cache = Object.create(null)\n\n  if (!tree || !tree.type) {\n    throw new Error('mdast-util-definitions expected node')\n  }\n\n  visit(tree, 'definition', (definition) => {\n    const id = clean(definition.identifier)\n    if (id && !own.call(cache, id)) {\n      cache[id] = definition\n    }\n  })\n\n  return definition\n\n  /** @type {GetDefinition} */\n  function definition(identifier) {\n    const id = clean(identifier)\n    // To do: next major: return `undefined` when not found.\n    return id && own.call(cache, id) ? cache[id] : null\n  }\n}\n\n/**\n * @param {string | null | undefined} [value]\n * @returns {string}\n */\nfunction clean(value) {\n  return String(value || '').toUpperCase()\n}\n","/**\n * @typedef {import('mdast').FootnoteReference} FootnoteReference\n * @typedef {import('hast').Element} Element\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 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  if (index === -1) {\n    state.footnoteOrder.push(id)\n    state.footnoteCounts[id] = 1\n    counter = state.footnoteOrder.length\n  } else {\n    state.footnoteCounts[id]++\n    counter = index + 1\n  }\n\n  const reuseCounter = state.footnoteCounts[id]\n\n  /** @type {Element} */\n  const link = {\n    type: 'element',\n    tagName: 'a',\n    properties: {\n      href: '#' + state.clobberPrefix + 'fn-' + safeId,\n      id:\n        state.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').ElementContent} ElementContent\n *\n * @typedef {import('mdast').Content} Content\n * @typedef {import('mdast').Reference} Reference\n * @typedef {import('mdast').Root} Root\n *\n * @typedef {import('./state.js').State} State\n */\n\n/**\n * @typedef {Root | Content} Nodes\n * @typedef {Extract<Nodes, Reference>} References\n */\n\n// To do: next major: always return array.\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 {References} node\n *   Reference node (image, link).\n * @returns {ElementContent | 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').Content} Content\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Parent} Parent\n * @typedef {import('mdast').Root} Root\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * @typedef {Root | Content} Nodes\n * @typedef {Extract<Nodes, Parent>} Parents\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 | null | 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 === undefined || spread === null\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 {footnote} from './footnote.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 */\nexport const handlers = {\n  blockquote,\n  break: hardBreak,\n  code,\n  delete: strikethrough,\n  emphasis,\n  footnoteReference,\n  footnote,\n  heading,\n  html,\n  imageReference,\n  image,\n  inlineCode,\n  linkReference,\n  link,\n  listItem,\n  list,\n  paragraph,\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  // To do: next major: return `undefined`.\n  return null\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('../state.js').State} State\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/**\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\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  // To do: next major, use `node.lang` w/o regex, the splitting’s been going\n  // on for years in remark now.\n  const lang = node.lang ? node.lang.match(/^[^ \\t]+(?=[ \\t]|$)/) : null\n  /** @type {Properties} */\n  const properties = {}\n\n  if (lang) {\n    properties.className = ['language-' + 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\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/**\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').Footnote} Footnote\n * @typedef {import('../state.js').State} State\n */\n\nimport {footnoteReference} from './footnote-reference.js'\n\n// To do: when both:\n// * <https://github.com/micromark/micromark-extension-footnote>\n// * <https://github.com/syntax-tree/mdast-util-footnote>\n// …are archived, remove this (also from mdast).\n// These inline notes are not used in GFM.\n\n/**\n * Turn an mdast `footnote` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Footnote} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function footnote(state, node) {\n  const footnoteById = state.footnoteById\n  let no = 1\n\n  while (no in footnoteById) no++\n\n  const identifier = String(no)\n\n  footnoteById[identifier] = {\n    type: 'footnoteDefinition',\n    identifier,\n    children: [{type: 'paragraph', children: node.children}],\n    position: node.position\n  }\n\n  return footnoteReference(state, {\n    type: 'footnoteReference',\n    identifier,\n    position: node.position\n  })\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('../state.js').State} State\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/**\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 {Raw | Element | null}\n *   hast node.\n */\nexport function html(state, node) {\n  if (state.dangerous) {\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  // To do: next major: return `undefined`.\n  return null\n}\n","/**\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Element} Element\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 {ElementContent | Array<ElementContent>}\n *   hast node.\n */\nexport function imageReference(state, node) {\n  const def = state.definition(node.identifier)\n\n  if (!def) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {src: normalizeUri(def.url || ''), alt: node.alt}\n\n  if (def.title !== null && def.title !== undefined) {\n    properties.title = def.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/**\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 {ElementContent | Array<ElementContent>}\n *   hast node.\n */\nexport function linkReference(state, node) {\n  const def = state.definition(node.identifier)\n\n  if (!def) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {href: normalizeUri(def.url || '')}\n\n  if (def.title !== null && def.title !== undefined) {\n    properties.title = def.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/**\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/**\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').Root} HastRoot\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('mdast').Root} MdastRoot\n * @typedef {import('../state.js').State} State\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 {HastRoot | HastElement}\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/**\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 {pointStart, pointEnd} 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.line && end.line) 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/**\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').Properties} Properties\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('mdast').Content} Content\n * @typedef {import('mdast').Parent} Parent\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').TableRow} TableRow\n * @typedef {import('../state.js').State} State\n */\n\n/**\n * @typedef {Root | Content} Nodes\n * @typedef {Extract<Nodes, Parent>} Parents\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 | null | 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  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(node, 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 {HastText | HastElement}\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/**\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').Content} HastContent\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').ElementContent} HastElementContent\n * @typedef {import('hast').Properties} HastProperties\n * @typedef {import('hast').Root} HastRoot\n * @typedef {import('hast').Text} HastText\n *\n * @typedef {import('mdast').Content} MdastContent\n * @typedef {import('mdast').Definition} MdastDefinition\n * @typedef {import('mdast').FootnoteDefinition} MdastFootnoteDefinition\n * @typedef {import('mdast').Parent} MdastParent\n * @typedef {import('mdast').Root} MdastRoot\n */\n\n/**\n * @typedef {HastRoot | HastContent} HastNodes\n * @typedef {MdastRoot | MdastContent} MdastNodes\n * @typedef {Extract<MdastNodes, MdastParent>} MdastParents\n *\n * @typedef EmbeddedHastFields\n *   hast fields.\n * @property {string | null | undefined} [hName]\n *   Generate a specific element with this tag name instead.\n * @property {HastProperties | null | undefined} [hProperties]\n *   Generate an element with these properties instead.\n * @property {Array<HastElementContent> | null | undefined} [hChildren]\n *   Generate an element with this content instead.\n *\n * @typedef {Record<string, unknown> & EmbeddedHastFields} MdastData\n *   mdast data with embedded hast fields.\n *\n * @typedef {MdastNodes & {data?: MdastData | null | undefined}} MdastNodeWithData\n *   mdast node with embedded hast data.\n *\n * @typedef PointLike\n *   Point-like value.\n * @property {number | null | undefined} [line]\n *   Line.\n * @property {number | null | undefined} [column]\n *   Column.\n * @property {number | null | undefined} [offset]\n *   Offset.\n *\n * @typedef PositionLike\n *   Position-like value.\n * @property {PointLike | null | undefined} [start]\n *   Point-like value.\n * @property {PointLike | null | undefined} [end]\n *   Point-like value.\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 | null | undefined} parent\n *   Parent of `node`.\n * @returns {HastElementContent | Array<HastElementContent> | null | undefined}\n *   hast node.\n *\n * @callback HFunctionProps\n *   Signature of `state` for when props are passed.\n * @param {MdastNodes | PositionLike | null | undefined} node\n *   mdast node or unist position.\n * @param {string} tagName\n *   HTML tag name.\n * @param {HastProperties} props\n *   Properties.\n * @param {Array<HastElementContent> | null | undefined} [children]\n *   hast content.\n * @returns {HastElement}\n *   Compiled element.\n *\n * @callback HFunctionNoProps\n *   Signature of `state` for when no props are passed.\n * @param {MdastNodes | PositionLike | null | undefined} node\n *   mdast node or unist position.\n * @param {string} tagName\n *   HTML tag name.\n * @param {Array<HastElementContent> | null | undefined} [children]\n *   hast content.\n * @returns {HastElement}\n *   Compiled element.\n *\n * @typedef HFields\n *   Info on `state`.\n * @property {boolean} dangerous\n *   Whether HTML is allowed.\n * @property {string} clobberPrefix\n *   Prefix to use to prevent DOM clobbering.\n * @property {string} footnoteLabel\n *   Label to use to introduce the footnote section.\n * @property {string} footnoteLabelTagName\n *   HTML used for the footnote label.\n * @property {HastProperties} footnoteLabelProperties\n *   Properties on the HTML tag used for the footnote label.\n * @property {string} footnoteBackLabel\n *   Label to use from backreferences back to their footnote call.\n * @property {(identifier: string) => MdastDefinition | null} definition\n *   Definition cache.\n * @property {Record<string, MdastFootnoteDefinition>} footnoteById\n *   Footnote definitions by their identifier.\n * @property {Array<string>} footnoteOrder\n *   Identifiers of order when footnote calls first appear in tree order.\n * @property {Record<string, number>} footnoteCounts\n *   Counts for how often the same footnote was called.\n * @property {Handlers} handlers\n *   Applied handlers.\n * @property {Handler} unknownHandler\n *   Handler for any none not in `passThrough` or otherwise handled.\n * @property {(from: MdastNodes, node: HastNodes) => void} patch\n *   Copy a node’s positional info.\n * @property {<Type extends HastNodes>(from: MdastNodes, to: Type) => Type | HastElement} applyData\n *   Honor the `data` of `from`, and generate an element instead of `node`.\n * @property {(node: MdastNodes, parent: MdastParents | null | undefined) => HastElementContent | Array<HastElementContent> | null | undefined} one\n *   Transform an mdast node to hast.\n * @property {(node: MdastNodes) => Array<HastElementContent>} all\n *   Transform the children of an mdast parent to hast.\n * @property {<Type extends HastContent>(nodes: Array<Type>, loose?: boolean | null | undefined) => Array<Type | HastText>} wrap\n *   Wrap `nodes` with line endings between each node, adds initial/final line endings when `loose`.\n * @property {(left: MdastNodeWithData | PositionLike | null | undefined, right: HastElementContent) => HastElementContent} augment\n *   Like `state` but lower-level and usable on non-elements.\n *   Deprecated: use `patch` and `applyData`.\n * @property {Array<string>} passThrough\n *   List of node types to pass through untouched (except for their children).\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.\n * @property {string | null | undefined} [clobberPrefix='user-content-']\n *   Prefix to use before the `id` attribute on footnotes to prevent it from\n *   *clobbering*.\n * @property {string | null | undefined} [footnoteBackLabel='Back to content']\n *   Label to use from backreferences back to their footnote call (affects\n *   screen readers).\n * @property {string | null | undefined} [footnoteLabel='Footnotes']\n *   Label to use for the footnotes section (affects screen readers).\n * @property {HastProperties | null | undefined} [footnoteLabelProperties={className: ['sr-only']}]\n *   Properties to use on the footnote label (note that `id: 'footnote-label'`\n *   is always added as footnote calls use it with `aria-describedby` to\n *   provide an accessible label).\n * @property {string | null | undefined} [footnoteLabelTagName='h2']\n *   Tag name to use for the footnote label.\n * @property {Handlers | null | undefined} [handlers]\n *   Extra handlers for nodes.\n * @property {Array<string> | 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 * @property {Handler | null | undefined} [unknownHandler]\n *   Handler for all unknown nodes.\n *\n * @typedef {Record<string, Handler>} Handlers\n *   Handle nodes.\n *\n * @typedef {HFunctionProps & HFunctionNoProps & HFields} State\n *   Info passed around.\n */\n\nimport {visit} from 'unist-util-visit'\nimport {position, pointStart, pointEnd} from 'unist-util-position'\nimport {generated} from 'unist-util-generated'\nimport {definitions} from 'mdast-util-definitions'\nimport {handlers} from './handlers/index.js'\n\nconst own = {}.hasOwnProperty\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.\n * @returns {State}\n *   `state` function.\n */\nexport function createState(tree, options) {\n  const settings = options || {}\n  const dangerous = settings.allowDangerousHtml || false\n  /** @type {Record<string, MdastFootnoteDefinition>} */\n  const footnoteById = {}\n\n  // To do: next major: add `options` to state, remove:\n  // `dangerous`, `clobberPrefix`, `footnoteLabel`, `footnoteLabelTagName`,\n  // `footnoteLabelProperties`, `footnoteBackLabel`, `passThrough`,\n  // `unknownHandler`.\n\n  // To do: next major: move to `state.options.allowDangerousHtml`.\n  state.dangerous = dangerous\n  // To do: next major: move to `state.options`.\n  state.clobberPrefix =\n    settings.clobberPrefix === undefined || settings.clobberPrefix === null\n      ? 'user-content-'\n      : settings.clobberPrefix\n  // To do: next major: move to `state.options`.\n  state.footnoteLabel = settings.footnoteLabel || 'Footnotes'\n  // To do: next major: move to `state.options`.\n  state.footnoteLabelTagName = settings.footnoteLabelTagName || 'h2'\n  // To do: next major: move to `state.options`.\n  state.footnoteLabelProperties = settings.footnoteLabelProperties || {\n    className: ['sr-only']\n  }\n  // To do: next major: move to `state.options`.\n  state.footnoteBackLabel = settings.footnoteBackLabel || 'Back to content'\n  // To do: next major: move to `state.options`.\n  state.unknownHandler = settings.unknownHandler\n  // To do: next major: move to `state.options`.\n  state.passThrough = settings.passThrough\n\n  state.handlers = {...handlers, ...settings.handlers}\n\n  // To do: next major: replace utility with `definitionById` object, so we\n  // only walk once (as we need footnotes too).\n  state.definition = definitions(tree)\n  state.footnoteById = footnoteById\n  /** @type {Array<string>} */\n  state.footnoteOrder = []\n  /** @type {Record<string, number>} */\n  state.footnoteCounts = {}\n\n  state.patch = patch\n  state.applyData = applyData\n  state.one = oneBound\n  state.all = allBound\n  state.wrap = wrap\n  // To do: next major: remove `augment`.\n  state.augment = augment\n\n  visit(tree, 'footnoteDefinition', (definition) => {\n    const id = String(definition.identifier).toUpperCase()\n\n    // Mimick CM behavior of link definitions.\n    // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/8290999/index.js#L26>.\n    if (!own.call(footnoteById, id)) {\n      footnoteById[id] = definition\n    }\n  })\n\n  // @ts-expect-error Hush, it’s fine!\n  return state\n\n  /**\n   * Finalise the created `right`, a hast node, from `left`, an mdast node.\n   *\n   * @param {MdastNodeWithData | PositionLike | null | undefined} left\n   * @param {HastElementContent} right\n   * @returns {HastElementContent}\n   */\n  /* c8 ignore start */\n  // To do: next major: remove.\n  function augment(left, right) {\n    // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n    if (left && 'data' in left && left.data) {\n      /** @type {MdastData} */\n      const data = left.data\n\n      if (data.hName) {\n        if (right.type !== 'element') {\n          right = {\n            type: 'element',\n            tagName: '',\n            properties: {},\n            children: []\n          }\n        }\n\n        right.tagName = data.hName\n      }\n\n      if (right.type === 'element' && data.hProperties) {\n        right.properties = {...right.properties, ...data.hProperties}\n      }\n\n      if ('children' in right && right.children && data.hChildren) {\n        right.children = data.hChildren\n      }\n    }\n\n    if (left) {\n      const ctx = 'type' in left ? left : {position: left}\n\n      if (!generated(ctx)) {\n        // @ts-expect-error: fine.\n        right.position = {start: pointStart(ctx), end: pointEnd(ctx)}\n      }\n    }\n\n    return right\n  }\n  /* c8 ignore stop */\n\n  /**\n   * Create an element for `node`.\n   *\n   * @type {HFunctionProps}\n   */\n  /* c8 ignore start */\n  // To do: next major: remove.\n  function state(node, tagName, props, children) {\n    if (Array.isArray(props)) {\n      children = props\n      props = {}\n    }\n\n    // @ts-expect-error augmenting an element yields an element.\n    return augment(node, {\n      type: 'element',\n      tagName,\n      properties: props || {},\n      children: children || []\n    })\n  }\n  /* c8 ignore stop */\n\n  /**\n   * Transform an mdast node into a hast node.\n   *\n   * @param {MdastNodes} node\n   *   mdast node.\n   * @param {MdastParents | null | undefined} [parent]\n   *   Parent of `node`.\n   * @returns {HastElementContent | Array<HastElementContent> | null | undefined}\n   *   Resulting hast node.\n   */\n  function oneBound(node, parent) {\n    // @ts-expect-error: that’s a state :)\n    return one(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 allBound(parent) {\n    // @ts-expect-error: that’s a state :)\n    return all(state, parent)\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 {void}\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 {Type | HastElement}\n *   Nothing.\n */\nfunction applyData(from, to) {\n  /** @type {Type | HastElement} */\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 is likely to keep the content around (otherwise: pass\n      // `hChildren`).\n      else {\n        result = {\n          type: 'element',\n          tagName: hName,\n          properties: {},\n          children: []\n        }\n\n        // To do: next major: take the children from the `root`, or inject the\n        // raw/text/comment or so into the element?\n        // if ('children' in node) {\n        //   // @ts-expect-error: assume `children` are allowed in elements.\n        //   result.children = node.children\n        // } else {\n        //   // @ts-expect-error: assume `node` is allowed in elements.\n        //   result.children.push(node)\n        // }\n      }\n    }\n\n    if (result.type === 'element' && hProperties) {\n      result.properties = {...result.properties, ...hProperties}\n    }\n\n    if (\n      'children' in result &&\n      result.children &&\n      hChildren !== null &&\n      hChildren !== undefined\n    ) {\n      // @ts-expect-error: assume valid children are defined.\n      result.children = hChildren\n    }\n  }\n\n  return result\n}\n\n/**\n * Transform an mdast node into a hast node.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastNodes} node\n *   mdast node.\n * @param {MdastParents | null | undefined} [parent]\n *   Parent of `node`.\n * @returns {HastElementContent | Array<HastElementContent> | null | undefined}\n *   Resulting hast node.\n */\n// To do: next major: do not expose, keep bound.\nexport function one(state, node, parent) {\n  const type = node && node.type\n\n  // Fail on non-nodes.\n  if (!type) {\n    throw new Error('Expected node, got `' + node + '`')\n  }\n\n  if (own.call(state.handlers, type)) {\n    return state.handlers[type](state, node, parent)\n  }\n\n  if (state.passThrough && state.passThrough.includes(type)) {\n    // To do: next major: deep clone.\n    // @ts-expect-error: types of passed through nodes are expected to be added manually.\n    return 'children' in node ? {...node, children: all(state, node)} : node\n  }\n\n  if (state.unknownHandler) {\n    return state.unknownHandler(state, node, parent)\n  }\n\n  return defaultUnknownHandler(state, node)\n}\n\n/**\n * Transform the children of an mdast node into hast nodes.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastNodes} parent\n *   mdast node to compile\n * @returns {Array<HastElementContent>}\n *   Resulting hast nodes.\n */\n// To do: next major: do not expose, keep bound.\nexport function all(state, 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 = one(state, 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 = result.value.replace(/^\\s+/, '')\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 = head.value.replace(/^\\s+/, '')\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 * Transform an unknown node.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastNodes} node\n *   Unknown mdast node.\n * @returns {HastText | HastElement}\n *   Resulting hast node.\n */\nfunction defaultUnknownHandler(state, node) {\n  const data = node.data || {}\n  /** @type {HastText | HastElement} */\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: all(state, 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 {HastContent} Type\n *   Node type.\n * @param {Array<Type>} nodes\n *   List of nodes to wrap.\n * @param {boolean | null | undefined} [loose=false]\n *   Whether to add line endings at start and end.\n * @returns {Array<Type | HastText>}\n *   Wrapped nodes.\n */\nexport function wrap(nodes, loose) {\n  /** @type {Array<Type | HastText>} */\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 * @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 * @typedef NodeLike\n * @property {PositionLike | null | undefined} [position]\n */\n\n/**\n * Check if `node` is generated.\n *\n * @param {NodeLike | null | undefined} [node]\n *   Node to check.\n * @returns {boolean}\n *   Whether `node` is generated (does not have positional info).\n */\nexport function generated(node) {\n  return (\n    !node ||\n    !node.position ||\n    !node.position.start ||\n    !node.position.start.line ||\n    !node.position.start.column ||\n    !node.position.end ||\n    !node.position.end.line ||\n    !node.position.end.column\n  )\n}\n","/**\n * @typedef {import('hast').Content} HastContent\n * @typedef {import('hast').Root} HastRoot\n *\n * @typedef {import('mdast').Content} MdastContent\n * @typedef {import('mdast').Root} MdastRoot\n *\n * @typedef {import('./state.js').Options} Options\n */\n\n/**\n * @typedef {HastRoot | HastContent} HastNodes\n * @typedef {MdastRoot | MdastContent} MdastNodes\n */\n\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.\n * @returns {HastNodes | null | undefined}\n *   hast tree.\n */\n// To do: next major: always return a single `root`.\nexport function toHast(tree, options) {\n  const state = createState(tree, options)\n  const node = state.one(tree, null)\n  const foot = footer(state)\n\n  if (foot) {\n    // @ts-expect-error If there’s a footer, there were definitions, meaning block\n    // content.\n    // So assume `node` is a parent node.\n    node.children.push({type: 'text', value: '\\n'}, foot)\n  }\n\n  // To do: next major: always return root?\n  return Array.isArray(node) ? {type: 'root', children: node} : node\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n *\n * @typedef {import('./state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\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 */\nexport function footer(state) {\n  /** @type {Array<ElementContent>} */\n  const listItems = []\n  let index = -1\n\n  while (++index < state.footnoteOrder.length) {\n    const def = state.footnoteById[state.footnoteOrder[index]]\n\n    if (!def) {\n      continue\n    }\n\n    const content = state.all(def)\n    const id = String(def.identifier).toUpperCase()\n    const safeId = normalizeUri(id.toLowerCase())\n    let referenceIndex = 0\n    /** @type {Array<ElementContent>} */\n    const backReferences = []\n\n    while (++referenceIndex <= state.footnoteCounts[id]) {\n      /** @type {Element} */\n      const backReference = {\n        type: 'element',\n        tagName: 'a',\n        properties: {\n          href:\n            '#' +\n            state.clobberPrefix +\n            'fnref-' +\n            safeId +\n            (referenceIndex > 1 ? '-' + referenceIndex : ''),\n          dataFootnoteBackref: true,\n          className: ['data-footnote-backref'],\n          ariaLabel: state.footnoteBackLabel\n        },\n        children: [{type: 'text', value: '↩'}]\n      }\n\n      if (referenceIndex > 1) {\n        backReference.children.push({\n          type: 'element',\n          tagName: 'sup',\n          children: [{type: 'text', value: String(referenceIndex)}]\n        })\n      }\n\n      if (backReferences.length > 0) {\n        backReferences.push({type: 'text', value: ' '})\n      }\n\n      backReferences.push(backReference)\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: state.clobberPrefix + 'fn-' + safeId},\n      children: state.wrap(content, true)\n    }\n\n    state.patch(def, 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: state.footnoteLabelTagName,\n        properties: {\n          // To do: use structured clone.\n          ...JSON.parse(JSON.stringify(state.footnoteLabelProperties)),\n          id: 'footnote-label'\n        },\n        children: [{type: 'text', value: state.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('hast').Root} HastRoot\n * @typedef {import('mdast').Root} MdastRoot\n * @typedef {import('mdast-util-to-hast').Options} Options\n * @typedef {import('unified').Processor<any, any, any, any>} Processor\n *\n * @typedef {import('mdast-util-to-hast')} DoNotTouchAsThisImportIncludesRawInTree\n */\n\nimport {toHast} from 'mdast-util-to-hast'\n\n// Note: the `<MdastRoot, HastRoot>` overload doesn’t seem to work :'(\n\n/**\n * Plugin that turns markdown into HTML to support rehype.\n *\n * *   If a destination processor is given, that processor runs with a new HTML\n *     (hast) tree (bridge-mode).\n *     As the given processor runs with a hast tree, and rehype plugins support\n *     hast, that means rehype plugins can be used with the given processor.\n *     The hast tree is discarded in the end.\n *     It’s highly unlikely that you want to do this.\n * *   The common case is to not pass a destination processor, in which case the\n *     current processor continues running with a new HTML (hast) tree\n *     (mutate-mode).\n *     As the current processor continues with a hast tree, and rehype plugins\n *     support hast, that means rehype plugins can be used after\n *     `remark-rehype`.\n *     It’s likely that this is what you want to do.\n *\n * @param destination\n *   Optional unified processor.\n * @param options\n *   Options passed to `mdast-util-to-hast`.\n */\nconst remarkRehype =\n  /** @type {(import('unified').Plugin<[Processor, Options?]|[null|undefined, Options?]|[Options]|[], MdastRoot>)} */\n  (\n    function (destination, options) {\n      return destination && 'run' in destination\n        ? bridge(destination, options)\n        : mutate(destination || options)\n    }\n  )\n\nexport default remarkRehype\n\n/**\n * Bridge-mode.\n * Runs the destination with the new hast tree.\n *\n * @type {import('unified').Plugin<[Processor, Options?], MdastRoot>}\n */\nfunction bridge(destination, options) {\n  return (node, file, next) => {\n    destination.run(toHast(node, options), file, (error) => {\n      next(error)\n    })\n  }\n}\n\n/**\n * Mutate-mode.\n * Further plugins run on the hast tree.\n *\n * @type {import('unified').Plugin<[Options?]|void[], MdastRoot, HastRoot>}\n */\nfunction mutate(options) {\n  // @ts-expect-error: assume a corresponding node is returned by `toHast`.\n  return (node) => toHast(node, options)\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    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\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","import {visit} from 'unist-util-visit'\n\n/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Element} Element\n *\n * @callback AllowElement\n * @param {Element} element\n * @param {number} index\n * @param {Element|Root} parent\n * @returns {boolean|undefined}\n *\n * @typedef Options\n * @property {Array<string>} [allowedElements]\n * @property {Array<string>} [disallowedElements=[]]\n * @property {AllowElement} [allowElement]\n * @property {boolean} [unwrapDisallowed=false]\n */\n\n/**\n * @type {import('unified').Plugin<[Options], Root>}\n */\nexport default function rehypeFilter(options) {\n  if (options.allowedElements && options.disallowedElements) {\n    throw new TypeError(\n      'Only one of `allowedElements` and `disallowedElements` should be defined'\n    )\n  }\n\n  if (\n    options.allowedElements ||\n    options.disallowedElements ||\n    options.allowElement\n  ) {\n    return (tree) => {\n      visit(tree, 'element', (node, index, parent_) => {\n        const parent = /** @type {Element|Root} */ (parent_)\n        /** @type {boolean|undefined} */\n        let remove\n\n        if (options.allowedElements) {\n          remove = !options.allowedElements.includes(node.tagName)\n        } else if (options.disallowedElements) {\n          remove = options.disallowedElements.includes(node.tagName)\n        }\n\n        if (!remove && options.allowElement && typeof index === 'number') {\n          remove = !options.allowElement(node, index, parent)\n        }\n\n        if (remove && typeof index === 'number') {\n          if (options.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        return undefined\n      })\n    }\n  }\n}\n","const protocols = ['http', 'https', 'mailto', 'tel']\n\n/**\n * @param {string} uri\n * @returns {string}\n */\nexport function uriTransformer(uri) {\n  const url = (uri || '').trim()\n  const first = url.charAt(0)\n\n  if (first === '#' || first === '/') {\n    return url\n  }\n\n  const colon = url.indexOf(':')\n  if (colon === -1) {\n    return url\n  }\n\n  let index = -1\n\n  while (++index < protocols.length) {\n    const protocol = protocols[index]\n\n    if (\n      colon === protocol.length &&\n      url.slice(0, protocol.length).toLowerCase() === protocol\n    ) {\n      return url\n    }\n  }\n\n  index = url.indexOf('?')\n  if (index !== -1 && colon > index) {\n    return url\n  }\n\n  index = url.indexOf('#')\n  if (index !== -1 && colon > index) {\n    return url\n  }\n\n  // eslint-disable-next-line no-script-url\n  return 'javascript:void(0)'\n}\n","/**\n * Check if the given value is *inter-element whitespace*.\n *\n * @param {unknown} thing\n *   Thing to check (typically `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`).\n *   If a node is passed it must be a `Text` node, whose `value` field is\n *   checked.\n */\nexport function whitespace(thing) {\n  /** @type {string} */\n  const value =\n    // @ts-expect-error looks like a node.\n    thing && typeof thing === 'object' && thing.type === 'text'\n      ? // @ts-expect-error looks like a text.\n        thing.value || ''\n      : thing\n\n  // HTML whitespace expression.\n  // See <https://infra.spec.whatwg.org/#ascii-whitespace>.\n  return typeof value === 'string' && value.replace(/[ \\t\\n\\f\\r]/g, '') === ''\n}\n","/**\n * @typedef {import('./util/schema.js').Schema} Schema\n */\n\nimport {normalize} from './normalize.js'\nimport {DefinedInfo} from './util/defined-info.js'\nimport {Info} from './util/info.js'\n\nconst valid = /^data[-\\w.:]+$/i\nconst dash = /-[a-z]/g\nconst cap = /[A-Z]/g\n\n/**\n * @param {Schema} schema\n * @param {string} value\n * @returns {Info}\n */\nexport function find(schema, value) {\n  const normal = normalize(value)\n  let prop = value\n  let Type = Info\n\n  if (normal in schema.normal) {\n    return schema.property[schema.normal[normal]]\n  }\n\n  if (normal.length > 4 && normal.slice(0, 4) === 'data' && valid.test(value)) {\n    // Attribute or property.\n    if (value.charAt(4) === '-') {\n      // Turn it into a property.\n      const rest = value.slice(5).replace(dash, camelcase)\n      prop = 'data' + rest.charAt(0).toUpperCase() + rest.slice(1)\n    } else {\n      // Turn it into an attribute.\n      const rest = value.slice(4)\n\n      if (!dash.test(rest)) {\n        let dashes = rest.replace(cap, kebab)\n\n        if (dashes.charAt(0) !== '-') {\n          dashes = '-' + dashes\n        }\n\n        value = 'data' + dashes\n      }\n    }\n\n    Type = DefinedInfo\n  }\n\n  return new Type(prop, value)\n}\n\n/**\n * @param {string} $0\n * @returns {string}\n */\nfunction kebab($0) {\n  return '-' + $0.toLowerCase()\n}\n\n/**\n * @param {string} $0\n * @returns {string}\n */\nfunction camelcase($0) {\n  return $0.charAt(1).toUpperCase()\n}\n","/**\n * `hast` is close to `React`, but differs in a couple of cases.\n *\n * To get a React property from a hast property, check if it is in\n * `hastToReact`, if it is, then use the corresponding value,\n * otherwise, use the hast property.\n *\n * @type {Record<string, string>}\n */\nexport const hastToReact = {\n  classId: 'classID',\n  dataType: 'datatype',\n  itemId: 'itemID',\n  strokeDashArray: 'strokeDasharray',\n  strokeDashOffset: 'strokeDashoffset',\n  strokeLineCap: 'strokeLinecap',\n  strokeLineJoin: 'strokeLinejoin',\n  strokeMiterLimit: 'strokeMiterlimit',\n  typeOf: 'typeof',\n  xLinkActuate: 'xlinkActuate',\n  xLinkArcRole: 'xlinkArcrole',\n  xLinkHref: 'xlinkHref',\n  xLinkRole: 'xlinkRole',\n  xLinkShow: 'xlinkShow',\n  xLinkTitle: 'xlinkTitle',\n  xLinkType: 'xlinkType',\n  xmlnsXLink: 'xmlnsXlink'\n}\n","/**\n * @template T\n * @typedef {import('react').ComponentType<T>} ComponentType<T>\n */\n\n/**\n * @template T\n * @typedef {import('react').ComponentPropsWithoutRef<T>} ComponentPropsWithoutRef<T>\n */\n\n/**\n * @typedef {import('react').ReactNode} ReactNode\n * @typedef {import('unist').Position} Position\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Text} Text\n * @typedef {import('hast').Comment} Comment\n * @typedef {import('hast').DocType} Doctype\n * @typedef {import('property-information').Info} Info\n * @typedef {import('property-information').Schema} Schema\n * @typedef {import('./complex-types').ReactMarkdownProps} ReactMarkdownProps\n *\n * @typedef Raw\n * @property {'raw'} type\n * @property {string} value\n *\n * @typedef Context\n * @property {Options} options\n * @property {Schema} schema\n * @property {number} listDepth\n *\n * @callback TransformLink\n * @param {string} href\n * @param {Array<ElementContent>} children\n * @param {string?} title\n * @returns {string}\n *\n * @callback TransformImage\n * @param {string} src\n * @param {string} alt\n * @param {string?} title\n * @returns {string}\n *\n * @typedef {import('react').HTMLAttributeAnchorTarget} TransformLinkTargetType\n *\n * @callback TransformLinkTarget\n * @param {string} href\n * @param {Array<ElementContent>} children\n * @param {string?} title\n * @returns {TransformLinkTargetType|undefined}\n *\n * @typedef {keyof JSX.IntrinsicElements} ReactMarkdownNames\n *\n * To do: is `data-sourcepos` typeable?\n *\n * @typedef {ComponentPropsWithoutRef<'code'> & ReactMarkdownProps & {inline?: boolean}} CodeProps\n * @typedef {ComponentPropsWithoutRef<'h1'> & ReactMarkdownProps & {level: number}} HeadingProps\n * @typedef {ComponentPropsWithoutRef<'li'> & ReactMarkdownProps & {checked: boolean|null, index: number, ordered: boolean}} LiProps\n * @typedef {ComponentPropsWithoutRef<'ol'> & ReactMarkdownProps & {depth: number, ordered: true}} OrderedListProps\n * @typedef {ComponentPropsWithoutRef<'table'> & ReactMarkdownProps & {style?: Record<string, unknown>, isHeader: boolean}} TableCellProps\n * @typedef {ComponentPropsWithoutRef<'tr'> & ReactMarkdownProps & {isHeader: boolean}} TableRowProps\n * @typedef {ComponentPropsWithoutRef<'ul'> & ReactMarkdownProps & {depth: number, ordered: false}} UnorderedListProps\n *\n * @typedef {ComponentType<CodeProps>} CodeComponent\n * @typedef {ComponentType<HeadingProps>} HeadingComponent\n * @typedef {ComponentType<LiProps>} LiComponent\n * @typedef {ComponentType<OrderedListProps>} OrderedListComponent\n * @typedef {ComponentType<TableCellProps>} TableCellComponent\n * @typedef {ComponentType<TableRowProps>} TableRowComponent\n * @typedef {ComponentType<UnorderedListProps>} UnorderedListComponent\n *\n * @typedef SpecialComponents\n * @property {CodeComponent|ReactMarkdownNames} code\n * @property {HeadingComponent|ReactMarkdownNames} h1\n * @property {HeadingComponent|ReactMarkdownNames} h2\n * @property {HeadingComponent|ReactMarkdownNames} h3\n * @property {HeadingComponent|ReactMarkdownNames} h4\n * @property {HeadingComponent|ReactMarkdownNames} h5\n * @property {HeadingComponent|ReactMarkdownNames} h6\n * @property {LiComponent|ReactMarkdownNames} li\n * @property {OrderedListComponent|ReactMarkdownNames} ol\n * @property {TableCellComponent|ReactMarkdownNames} td\n * @property {TableCellComponent|ReactMarkdownNames} th\n * @property {TableRowComponent|ReactMarkdownNames} tr\n * @property {UnorderedListComponent|ReactMarkdownNames} ul\n *\n * @typedef {Partial<Omit<import('./complex-types').NormalComponents, keyof SpecialComponents> & SpecialComponents>} Components\n *\n * @typedef Options\n * @property {boolean} [sourcePos=false]\n * @property {boolean} [rawSourcePos=false]\n * @property {boolean} [skipHtml=false]\n * @property {boolean} [includeElementIndex=false]\n * @property {null|false|TransformLink} [transformLinkUri]\n * @property {TransformImage} [transformImageUri]\n * @property {TransformLinkTargetType|TransformLinkTarget} [linkTarget]\n * @property {Components} [components]\n */\n\nimport React from 'react'\nimport ReactIs from 'react-is'\nimport {whitespace} from 'hast-util-whitespace'\nimport {svg, find, hastToReact} from 'property-information'\nimport {stringify as spaces} from 'space-separated-tokens'\nimport {stringify as commas} from 'comma-separated-tokens'\nimport style from 'style-to-object'\n\nconst own = {}.hasOwnProperty\n\n// The table-related elements that must not contain whitespace text according\n// to React.\nconst tableElements = new Set(['table', 'thead', 'tbody', 'tfoot', 'tr'])\n\n/**\n * @param {Context} context\n * @param {Element|Root} node\n */\nexport function childrenToReact(context, node) {\n  /** @type {Array<ReactNode>} */\n  const children = []\n  let childIndex = -1\n  /** @type {Comment|Doctype|Element|Raw|Text} */\n  let child\n\n  while (++childIndex < node.children.length) {\n    child = node.children[childIndex]\n\n    if (child.type === 'element') {\n      children.push(toReact(context, child, childIndex, node))\n    } else if (child.type === 'text') {\n      // Currently, a warning is triggered by react for *any* white space in\n      // tables.\n      // So we drop it.\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/remarkjs/react-markdown/issues/576>.\n      if (\n        node.type !== 'element' ||\n        !tableElements.has(node.tagName) ||\n        !whitespace(child)\n      ) {\n        children.push(child.value)\n      }\n    } else if (child.type === 'raw' && !context.options.skipHtml) {\n      // Default behavior is to show (encoded) HTML.\n      children.push(child.value)\n    }\n  }\n\n  return children\n}\n\n/**\n * @param {Context} context\n * @param {Element} node\n * @param {number} index\n * @param {Element|Root} parent\n */\nfunction toReact(context, node, index, parent) {\n  const options = context.options\n  const parentSchema = context.schema\n  /** @type {ReactMarkdownNames} */\n  // @ts-expect-error assume a known HTML/SVG element.\n  const name = node.tagName\n  /** @type {Record<string, unknown>} */\n  const properties = {}\n  let schema = parentSchema\n  /** @type {string} */\n  let property\n\n  if (parentSchema.space === 'html' && name === 'svg') {\n    schema = svg\n    context.schema = schema\n  }\n\n  if (node.properties) {\n    for (property in node.properties) {\n      if (own.call(node.properties, property)) {\n        addProperty(properties, property, node.properties[property], context)\n      }\n    }\n  }\n\n  if (name === 'ol' || name === 'ul') {\n    context.listDepth++\n  }\n\n  const children = childrenToReact(context, node)\n\n  if (name === 'ol' || name === 'ul') {\n    context.listDepth--\n  }\n\n  // Restore parent schema.\n  context.schema = parentSchema\n\n  // Nodes created by plugins do not have positional info, in which case we use\n  // an object that matches the position interface.\n  const position = node.position || {\n    start: {line: null, column: null, offset: null},\n    end: {line: null, column: null, offset: null}\n  }\n  const component =\n    options.components && own.call(options.components, name)\n      ? options.components[name]\n      : name\n  const basic = typeof component === 'string' || component === React.Fragment\n\n  if (!ReactIs.isValidElementType(component)) {\n    throw new TypeError(\n      `Component for name \\`${name}\\` not defined or is not renderable`\n    )\n  }\n\n  properties.key = [\n    name,\n    position.start.line,\n    position.start.column,\n    index\n  ].join('-')\n\n  if (name === 'a' && options.linkTarget) {\n    properties.target =\n      typeof options.linkTarget === 'function'\n        ? options.linkTarget(\n            String(properties.href || ''),\n            node.children,\n            typeof properties.title === 'string' ? properties.title : null\n          )\n        : options.linkTarget\n  }\n\n  if (name === 'a' && options.transformLinkUri) {\n    properties.href = options.transformLinkUri(\n      String(properties.href || ''),\n      node.children,\n      typeof properties.title === 'string' ? properties.title : null\n    )\n  }\n\n  if (\n    !basic &&\n    name === 'code' &&\n    parent.type === 'element' &&\n    parent.tagName !== 'pre'\n  ) {\n    properties.inline = true\n  }\n\n  if (\n    !basic &&\n    (name === 'h1' ||\n      name === 'h2' ||\n      name === 'h3' ||\n      name === 'h4' ||\n      name === 'h5' ||\n      name === 'h6')\n  ) {\n    properties.level = Number.parseInt(name.charAt(1), 10)\n  }\n\n  if (name === 'img' && options.transformImageUri) {\n    properties.src = options.transformImageUri(\n      String(properties.src || ''),\n      String(properties.alt || ''),\n      typeof properties.title === 'string' ? properties.title : null\n    )\n  }\n\n  if (!basic && name === 'li' && parent.type === 'element') {\n    const input = getInputElement(node)\n    properties.checked =\n      input && input.properties ? Boolean(input.properties.checked) : null\n    properties.index = getElementsBeforeCount(parent, node)\n    properties.ordered = parent.tagName === 'ol'\n  }\n\n  if (!basic && (name === 'ol' || name === 'ul')) {\n    properties.ordered = name === 'ol'\n    properties.depth = context.listDepth\n  }\n\n  if (name === 'td' || name === 'th') {\n    if (properties.align) {\n      if (!properties.style) properties.style = {}\n      // @ts-expect-error assume `style` is an object\n      properties.style.textAlign = properties.align\n      delete properties.align\n    }\n\n    if (!basic) {\n      properties.isHeader = name === 'th'\n    }\n  }\n\n  if (!basic && name === 'tr' && parent.type === 'element') {\n    properties.isHeader = Boolean(parent.tagName === 'thead')\n  }\n\n  // If `sourcePos` is given, pass source information (line/column info from markdown source).\n  if (options.sourcePos) {\n    properties['data-sourcepos'] = flattenPosition(position)\n  }\n\n  if (!basic && options.rawSourcePos) {\n    properties.sourcePosition = node.position\n  }\n\n  // If `includeElementIndex` is given, pass node index info to components.\n  if (!basic && options.includeElementIndex) {\n    properties.index = getElementsBeforeCount(parent, node)\n    properties.siblingCount = getElementsBeforeCount(parent)\n  }\n\n  if (!basic) {\n    properties.node = node\n  }\n\n  // Ensure no React warnings are emitted for void elements w/ children.\n  return children.length > 0\n    ? React.createElement(component, properties, children)\n    : React.createElement(component, properties)\n}\n\n/**\n * @param {Element|Root} node\n * @returns {Element?}\n */\nfunction getInputElement(node) {\n  let index = -1\n\n  while (++index < node.children.length) {\n    const child = node.children[index]\n\n    if (child.type === 'element' && child.tagName === 'input') {\n      return child\n    }\n  }\n\n  return null\n}\n\n/**\n * @param {Element|Root} parent\n * @param {Element} [node]\n * @returns {number}\n */\nfunction getElementsBeforeCount(parent, node) {\n  let index = -1\n  let count = 0\n\n  while (++index < parent.children.length) {\n    if (parent.children[index] === node) break\n    if (parent.children[index].type === 'element') count++\n  }\n\n  return count\n}\n\n/**\n * @param {Record<string, unknown>} props\n * @param {string} prop\n * @param {unknown} value\n * @param {Context} ctx\n */\nfunction addProperty(props, prop, value, ctx) {\n  const info = find(ctx.schema, prop)\n  let result = value\n\n  // Ignore nullish and `NaN` values.\n  // eslint-disable-next-line no-self-compare\n  if (result === null || result === undefined || result !== result) {\n    return\n  }\n\n  // Accept `array`.\n  // Most props are space-separated.\n  if (Array.isArray(result)) {\n    result = info.commaSeparated ? commas(result) : spaces(result)\n  }\n\n  if (info.property === 'style' && typeof result === 'string') {\n    result = parseStyle(result)\n  }\n\n  if (info.space && info.property) {\n    props[\n      own.call(hastToReact, info.property)\n        ? hastToReact[info.property]\n        : info.property\n    ] = result\n  } else if (info.attribute) {\n    props[info.attribute] = result\n  }\n}\n\n/**\n * @param {string} value\n * @returns {Record<string, string>}\n */\nfunction parseStyle(value) {\n  /** @type {Record<string, string>} */\n  const result = {}\n\n  try {\n    style(value, iterator)\n  } catch {\n    // Silent.\n  }\n\n  return result\n\n  /**\n   * @param {string} name\n   * @param {string} v\n   */\n  function iterator(name, v) {\n    const k = name.slice(0, 4) === '-ms-' ? `ms-${name.slice(4)}` : name\n    result[k.replace(/-([a-z])/g, styleReplacer)] = v\n  }\n}\n\n/**\n * @param {unknown} _\n * @param {string} $1\n */\nfunction styleReplacer(_, $1) {\n  return $1.toUpperCase()\n}\n\n/**\n * @param {Position|{start: {line: null, column: null, offset: null}, end: {line: null, column: null, offset: null}}} pos\n * @returns {string}\n */\nfunction flattenPosition(pos) {\n  return [\n    pos.start.line,\n    ':',\n    pos.start.column,\n    '-',\n    pos.end.line,\n    ':',\n    pos.end.column\n  ]\n    .map((d) => String(d))\n    .join('')\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 * @typedef {import('react').ReactNode} ReactNode\n * @typedef {import('react').ReactElement<{}>} ReactElement\n * @typedef {import('unified').PluggableList} PluggableList\n * @typedef {import('hast').Root} Root\n * @typedef {import('./rehype-filter.js').Options} FilterOptions\n * @typedef {import('./ast-to-react.js').Options} TransformOptions\n *\n * @typedef CoreOptions\n * @property {string} children\n *\n * @typedef PluginOptions\n * @property {PluggableList} [remarkPlugins=[]]\n * @property {PluggableList} [rehypePlugins=[]]\n * @property {import('remark-rehype').Options | undefined} [remarkRehypeOptions={}]\n *\n * @typedef LayoutOptions\n * @property {string} [className]\n *\n * @typedef {CoreOptions & PluginOptions & LayoutOptions & FilterOptions & TransformOptions} ReactMarkdownOptions\n *\n * @typedef Deprecation\n * @property {string} id\n * @property {string} [to]\n */\n\nimport React from 'react'\nimport {VFile} from 'vfile'\nimport {unified} from 'unified'\nimport remarkParse from 'remark-parse'\nimport remarkRehype from 'remark-rehype'\nimport PropTypes from 'prop-types'\nimport {html} from 'property-information'\nimport rehypeFilter from './rehype-filter.js'\nimport {uriTransformer} from './uri-transformer.js'\nimport {childrenToReact} from './ast-to-react.js'\n\nconst own = {}.hasOwnProperty\nconst changelog =\n  'https://github.com/remarkjs/react-markdown/blob/main/changelog.md'\n\n/** @type {Record<string, Deprecation>} */\nconst deprecated = {\n  plugins: {to: 'plugins', id: 'change-plugins-to-remarkplugins'},\n  renderers: {to: 'components', id: 'change-renderers-to-components'},\n  astPlugins: {id: 'remove-buggy-html-in-markdown-parser'},\n  allowDangerousHtml: {id: 'remove-buggy-html-in-markdown-parser'},\n  escapeHtml: {id: 'remove-buggy-html-in-markdown-parser'},\n  source: {to: 'children', id: 'change-source-to-children'},\n  allowNode: {\n    to: 'allowElement',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n  },\n  allowedTypes: {\n    to: 'allowedElements',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n  },\n  disallowedTypes: {\n    to: 'disallowedElements',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n  },\n  includeNodeIndex: {\n    to: 'includeElementIndex',\n    id: 'change-includenodeindex-to-includeelementindex'\n  }\n}\n\n/**\n * React component to render markdown.\n *\n * @param {ReactMarkdownOptions} options\n * @returns {ReactElement}\n */\nexport function ReactMarkdown(options) {\n  for (const key in deprecated) {\n    if (own.call(deprecated, key) && own.call(options, key)) {\n      const deprecation = deprecated[key]\n      console.warn(\n        `[react-markdown] Warning: please ${\n          deprecation.to ? `use \\`${deprecation.to}\\` instead of` : 'remove'\n        } \\`${key}\\` (see <${changelog}#${deprecation.id}> for more info)`\n      )\n      delete deprecated[key]\n    }\n  }\n\n  const processor = unified()\n    .use(remarkParse)\n    .use(options.remarkPlugins || [])\n    .use(remarkRehype, {\n      ...options.remarkRehypeOptions,\n      allowDangerousHtml: true\n    })\n    .use(options.rehypePlugins || [])\n    .use(rehypeFilter, options)\n\n  const file = new VFile()\n\n  if (typeof options.children === 'string') {\n    file.value = options.children\n  } else if (options.children !== undefined && options.children !== null) {\n    console.warn(\n      `[react-markdown] Warning: please pass a string as \\`children\\` (not: \\`${options.children}\\`)`\n    )\n  }\n\n  const hastNode = processor.runSync(processor.parse(file), file)\n\n  if (hastNode.type !== 'root') {\n    throw new TypeError('Expected a `root` node')\n  }\n\n  /** @type {ReactElement} */\n  let result = React.createElement(\n    React.Fragment,\n    {},\n    childrenToReact({options, schema: html, listDepth: 0}, hastNode)\n  )\n\n  if (options.className) {\n    result = React.createElement('div', {className: options.className}, result)\n  }\n\n  return result\n}\n\nReactMarkdown.defaultProps = {transformLinkUri: uriTransformer}\n\nReactMarkdown.propTypes = {\n  // Core options:\n  children: PropTypes.string,\n  // Layout options:\n  className: PropTypes.string,\n  // Filter options:\n  allowElement: PropTypes.func,\n  allowedElements: PropTypes.arrayOf(PropTypes.string),\n  disallowedElements: PropTypes.arrayOf(PropTypes.string),\n  unwrapDisallowed: PropTypes.bool,\n  // Plugin options:\n  remarkPlugins: PropTypes.arrayOf(\n    PropTypes.oneOfType([\n      PropTypes.object,\n      PropTypes.func,\n      PropTypes.arrayOf(\n        PropTypes.oneOfType([\n          PropTypes.bool,\n          PropTypes.string,\n          PropTypes.object,\n          PropTypes.func,\n          PropTypes.arrayOf(\n            // prettier-ignore\n            // type-coverage:ignore-next-line\n            PropTypes.any\n          )\n        ])\n      )\n    ])\n  ),\n  rehypePlugins: PropTypes.arrayOf(\n    PropTypes.oneOfType([\n      PropTypes.object,\n      PropTypes.func,\n      PropTypes.arrayOf(\n        PropTypes.oneOfType([\n          PropTypes.bool,\n          PropTypes.string,\n          PropTypes.object,\n          PropTypes.func,\n          PropTypes.arrayOf(\n            // prettier-ignore\n            // type-coverage:ignore-next-line\n            PropTypes.any\n          )\n        ])\n      )\n    ])\n  ),\n  // Transform options:\n  sourcePos: PropTypes.bool,\n  rawSourcePos: PropTypes.bool,\n  skipHtml: PropTypes.bool,\n  includeElementIndex: PropTypes.bool,\n  transformLinkUri: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),\n  linkTarget: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  transformImageUri: PropTypes.func,\n  components: PropTypes.object\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Previous} Previous\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  asciiControl,\n  markdownLineEndingOrSpace,\n  unicodePunctuation,\n  unicodeWhitespace\n} from 'micromark-util-character'\nconst wwwPrefix = {\n  tokenize: tokenizeWwwPrefix,\n  partial: true\n}\nconst domain = {\n  tokenize: tokenizeDomain,\n  partial: true\n}\nconst path = {\n  tokenize: tokenizePath,\n  partial: true\n}\nconst trail = {\n  tokenize: tokenizeTrail,\n  partial: true\n}\nconst emailDomainDotTrail = {\n  tokenize: tokenizeEmailDomainDotTrail,\n  partial: true\n}\nconst wwwAutolink = {\n  tokenize: tokenizeWwwAutolink,\n  previous: previousWww\n}\nconst protocolAutolink = {\n  tokenize: tokenizeProtocolAutolink,\n  previous: previousProtocol\n}\nconst emailAutolink = {\n  tokenize: tokenizeEmailAutolink,\n  previous: previousEmail\n}\n\n/** @type {ConstructRecord} */\nconst text = {}\n\n// To do: next major: expose functions that yields extension.\n\n/**\n * Extension for `micromark` that can be passed in `extensions` to enable GFM\n * autolink literal syntax.\n *\n * @type {Extension}\n */\nexport const gfmAutolinkLiteral = {\n  text\n}\n\n/** @type {Code} */\nlet code = 48\n\n// Add alphanumerics.\nwhile (code < 123) {\n  text[code] = emailAutolink\n  code++\n  if (code === 58) code = 65\n  else if (code === 91) code = 97\n}\ntext[43] = emailAutolink\ntext[45] = emailAutolink\ntext[46] = emailAutolink\ntext[95] = emailAutolink\ntext[72] = [emailAutolink, protocolAutolink]\ntext[104] = [emailAutolink, protocolAutolink]\ntext[87] = [emailAutolink, wwwAutolink]\ntext[119] = [emailAutolink, wwwAutolink]\n\n// To do: perform email autolink literals on events, afterwards.\n// That’s where `markdown-rs` and `cmark-gfm` perform it.\n// It should look for `@`, then for atext backwards, and then for a label\n// forwards.\n// To do: `mailto:`, `xmpp:` protocol as prefix.\n\n/**\n * Email autolink literal.\n *\n * ```markdown\n * > | a contact@example.org b\n *       ^^^^^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeEmailAutolink(effects, ok, nok) {\n  const self = this\n  /** @type {boolean | undefined} */\n  let dot\n  /** @type {boolean} */\n  let data\n  return start\n\n  /**\n   * Start of email autolink literal.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (\n      !gfmAtext(code) ||\n      !previousEmail.call(self, self.previous) ||\n      previousUnbalanced(self.events)\n    ) {\n      return nok(code)\n    }\n    effects.enter('literalAutolink')\n    effects.enter('literalAutolinkEmail')\n    return atext(code)\n  }\n\n  /**\n   * In email atext.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atext(code) {\n    if (gfmAtext(code)) {\n      effects.consume(code)\n      return atext\n    }\n    if (code === 64) {\n      effects.consume(code)\n      return emailDomain\n    }\n    return nok(code)\n  }\n\n  /**\n   * In email domain.\n   *\n   * The reference code is a bit overly complex as it handles the `@`, of which\n   * there may be just one.\n   * Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L318>\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailDomain(code) {\n    // Dot followed by alphanumerical (not `-` or `_`).\n    if (code === 46) {\n      return effects.check(\n        emailDomainDotTrail,\n        emailDomainAfter,\n        emailDomainDot\n      )(code)\n    }\n\n    // Alphanumerical, `-`, and `_`.\n    if (code === 45 || code === 95 || asciiAlphanumeric(code)) {\n      data = true\n      effects.consume(code)\n      return emailDomain\n    }\n\n    // To do: `/` if xmpp.\n\n    // Note: normally we’d truncate trailing punctuation from the link.\n    // However, email autolink literals cannot contain any of those markers,\n    // except for `.`, but that can only occur if it isn’t trailing.\n    // So we can ignore truncating!\n    return emailDomainAfter(code)\n  }\n\n  /**\n   * In email domain, on dot that is not a trail.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *                      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailDomainDot(code) {\n    effects.consume(code)\n    dot = true\n    return emailDomain\n  }\n\n  /**\n   * After email domain.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *                          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailDomainAfter(code) {\n    // Domain must not be empty, must include a dot, and must end in alphabetical.\n    // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L332>.\n    if (data && dot && asciiAlpha(self.previous)) {\n      effects.exit('literalAutolinkEmail')\n      effects.exit('literalAutolink')\n      return ok(code)\n    }\n    return nok(code)\n  }\n}\n\n/**\n * `www` autolink literal.\n *\n * ```markdown\n * > | a www.example.org b\n *       ^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeWwwAutolink(effects, ok, nok) {\n  const self = this\n  return wwwStart\n\n  /**\n   * Start of www autolink literal.\n   *\n   * ```markdown\n   * > | www.example.com/a?b#c\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwStart(code) {\n    if (\n      (code !== 87 && code !== 119) ||\n      !previousWww.call(self, self.previous) ||\n      previousUnbalanced(self.events)\n    ) {\n      return nok(code)\n    }\n    effects.enter('literalAutolink')\n    effects.enter('literalAutolinkWww')\n    // Note: we *check*, so we can discard the `www.` we parsed.\n    // If it worked, we consider it as a part of the domain.\n    return effects.check(\n      wwwPrefix,\n      effects.attempt(domain, effects.attempt(path, wwwAfter), nok),\n      nok\n    )(code)\n  }\n\n  /**\n   * After a www autolink literal.\n   *\n   * ```markdown\n   * > | www.example.com/a?b#c\n   *                          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwAfter(code) {\n    effects.exit('literalAutolinkWww')\n    effects.exit('literalAutolink')\n    return ok(code)\n  }\n}\n\n/**\n * Protocol autolink literal.\n *\n * ```markdown\n * > | a https://example.org b\n *       ^^^^^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeProtocolAutolink(effects, ok, nok) {\n  const self = this\n  let buffer = ''\n  let seen = false\n  return protocolStart\n\n  /**\n   * Start of protocol autolink literal.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolStart(code) {\n    if (\n      (code === 72 || code === 104) &&\n      previousProtocol.call(self, self.previous) &&\n      !previousUnbalanced(self.events)\n    ) {\n      effects.enter('literalAutolink')\n      effects.enter('literalAutolinkHttp')\n      buffer += String.fromCodePoint(code)\n      effects.consume(code)\n      return protocolPrefixInside\n    }\n    return nok(code)\n  }\n\n  /**\n   * In protocol.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *     ^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolPrefixInside(code) {\n    // `5` is size of `https`\n    if (asciiAlpha(code) && buffer.length < 5) {\n      // @ts-expect-error: definitely number.\n      buffer += String.fromCodePoint(code)\n      effects.consume(code)\n      return protocolPrefixInside\n    }\n    if (code === 58) {\n      const protocol = buffer.toLowerCase()\n      if (protocol === 'http' || protocol === 'https') {\n        effects.consume(code)\n        return protocolSlashesInside\n      }\n    }\n    return nok(code)\n  }\n\n  /**\n   * In slashes.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *           ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolSlashesInside(code) {\n    if (code === 47) {\n      effects.consume(code)\n      if (seen) {\n        return afterProtocol\n      }\n      seen = true\n      return protocolSlashesInside\n    }\n    return nok(code)\n  }\n\n  /**\n   * After protocol, before domain.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterProtocol(code) {\n    // To do: this is different from `markdown-rs`:\n    // https://github.com/wooorm/markdown-rs/blob/b3a921c761309ae00a51fe348d8a43adbc54b518/src/construct/gfm_autolink_literal.rs#L172-L182\n    return code === null ||\n      asciiControl(code) ||\n      markdownLineEndingOrSpace(code) ||\n      unicodeWhitespace(code) ||\n      unicodePunctuation(code)\n      ? nok(code)\n      : effects.attempt(domain, effects.attempt(path, protocolAfter), nok)(code)\n  }\n\n  /**\n   * After a protocol autolink literal.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *                              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolAfter(code) {\n    effects.exit('literalAutolinkHttp')\n    effects.exit('literalAutolink')\n    return ok(code)\n  }\n}\n\n/**\n * `www` prefix.\n *\n * ```markdown\n * > | a www.example.org b\n *       ^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeWwwPrefix(effects, ok, nok) {\n  let size = 0\n  return wwwPrefixInside\n\n  /**\n   * In www prefix.\n   *\n   * ```markdown\n   * > | www.example.com\n   *     ^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwPrefixInside(code) {\n    if ((code === 87 || code === 119) && size < 3) {\n      size++\n      effects.consume(code)\n      return wwwPrefixInside\n    }\n    if (code === 46 && size === 3) {\n      effects.consume(code)\n      return wwwPrefixAfter\n    }\n    return nok(code)\n  }\n\n  /**\n   * After www prefix.\n   *\n   * ```markdown\n   * > | www.example.com\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwPrefixAfter(code) {\n    // If there is *anything*, we can link.\n    return code === null ? nok(code) : ok(code)\n  }\n}\n\n/**\n * Domain.\n *\n * ```markdown\n * > | a https://example.org b\n *               ^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDomain(effects, ok, nok) {\n  /** @type {boolean | undefined} */\n  let underscoreInLastSegment\n  /** @type {boolean | undefined} */\n  let underscoreInLastLastSegment\n  /** @type {boolean | undefined} */\n  let seen\n  return domainInside\n\n  /**\n   * In domain.\n   *\n   * ```markdown\n   * > | https://example.com/a\n   *             ^^^^^^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function domainInside(code) {\n    // Check whether this marker, which is a trailing punctuation\n    // marker, optionally followed by more trailing markers, and then\n    // followed by an end.\n    if (code === 46 || code === 95) {\n      return effects.check(trail, domainAfter, domainAtPunctuation)(code)\n    }\n\n    // GH documents that only alphanumerics (other than `-`, `.`, and `_`) can\n    // occur, which sounds like ASCII only, but they also support `www.點看.com`,\n    // so that’s Unicode.\n    // Instead of some new production for Unicode alphanumerics, markdown\n    // already has that for Unicode punctuation and whitespace, so use those.\n    // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L12>.\n    if (\n      code === null ||\n      markdownLineEndingOrSpace(code) ||\n      unicodeWhitespace(code) ||\n      (code !== 45 && unicodePunctuation(code))\n    ) {\n      return domainAfter(code)\n    }\n    seen = true\n    effects.consume(code)\n    return domainInside\n  }\n\n  /**\n   * In domain, at potential trailing punctuation, that was not trailing.\n   *\n   * ```markdown\n   * > | https://example.com\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function domainAtPunctuation(code) {\n    // There is an underscore in the last segment of the domain\n    if (code === 95) {\n      underscoreInLastSegment = true\n    }\n    // Otherwise, it’s a `.`: save the last segment underscore in the\n    // penultimate segment slot.\n    else {\n      underscoreInLastLastSegment = underscoreInLastSegment\n      underscoreInLastSegment = undefined\n    }\n    effects.consume(code)\n    return domainInside\n  }\n\n  /**\n   * After domain.\n   *\n   * ```markdown\n   * > | https://example.com/a\n   *                        ^\n   * ```\n   *\n   * @type {State} */\n  function domainAfter(code) {\n    // Note: that’s GH says a dot is needed, but it’s not true:\n    // <https://github.com/github/cmark-gfm/issues/279>\n    if (underscoreInLastLastSegment || underscoreInLastSegment || !seen) {\n      return nok(code)\n    }\n    return ok(code)\n  }\n}\n\n/**\n * Path.\n *\n * ```markdown\n * > | a https://example.org/stuff b\n *                          ^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizePath(effects, ok) {\n  let sizeOpen = 0\n  let sizeClose = 0\n  return pathInside\n\n  /**\n   * In path.\n   *\n   * ```markdown\n   * > | https://example.com/a\n   *                        ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function pathInside(code) {\n    if (code === 40) {\n      sizeOpen++\n      effects.consume(code)\n      return pathInside\n    }\n\n    // To do: `markdown-rs` also needs this.\n    // If this is a paren, and there are less closings than openings,\n    // we don’t check for a trail.\n    if (code === 41 && sizeClose < sizeOpen) {\n      return pathAtPunctuation(code)\n    }\n\n    // Check whether this trailing punctuation marker is optionally\n    // followed by more trailing markers, and then followed\n    // by an end.\n    if (\n      code === 33 ||\n      code === 34 ||\n      code === 38 ||\n      code === 39 ||\n      code === 41 ||\n      code === 42 ||\n      code === 44 ||\n      code === 46 ||\n      code === 58 ||\n      code === 59 ||\n      code === 60 ||\n      code === 63 ||\n      code === 93 ||\n      code === 95 ||\n      code === 126\n    ) {\n      return effects.check(trail, ok, pathAtPunctuation)(code)\n    }\n    if (\n      code === null ||\n      markdownLineEndingOrSpace(code) ||\n      unicodeWhitespace(code)\n    ) {\n      return ok(code)\n    }\n    effects.consume(code)\n    return pathInside\n  }\n\n  /**\n   * In path, at potential trailing punctuation, that was not trailing.\n   *\n   * ```markdown\n   * > | https://example.com/a\"b\n   *                          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function pathAtPunctuation(code) {\n    // Count closing parens.\n    if (code === 41) {\n      sizeClose++\n    }\n    effects.consume(code)\n    return pathInside\n  }\n}\n\n/**\n * Trail.\n *\n * This calls `ok` if this *is* the trail, followed by an end, which means\n * the entire trail is not part of the link.\n * It calls `nok` if this *is* part of the link.\n *\n * ```markdown\n * > | https://example.com\").\n *                        ^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTrail(effects, ok, nok) {\n  return trail\n\n  /**\n   * In trail of domain or path.\n   *\n   * ```markdown\n   * > | https://example.com\").\n   *                        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trail(code) {\n    // Regular trailing punctuation.\n    if (\n      code === 33 ||\n      code === 34 ||\n      code === 39 ||\n      code === 41 ||\n      code === 42 ||\n      code === 44 ||\n      code === 46 ||\n      code === 58 ||\n      code === 59 ||\n      code === 63 ||\n      code === 95 ||\n      code === 126\n    ) {\n      effects.consume(code)\n      return trail\n    }\n\n    // `&` followed by one or more alphabeticals and then a `;`, is\n    // as a whole considered as trailing punctuation.\n    // In all other cases, it is considered as continuation of the URL.\n    if (code === 38) {\n      effects.consume(code)\n      return trailCharRefStart\n    }\n\n    // Needed because we allow literals after `[`, as we fix:\n    // <https://github.com/github/cmark-gfm/issues/278>.\n    // Check that it is not followed by `(` or `[`.\n    if (code === 93) {\n      effects.consume(code)\n      return trailBracketAfter\n    }\n    if (\n      // `<` is an end.\n      code === 60 ||\n      // So is whitespace.\n      code === null ||\n      markdownLineEndingOrSpace(code) ||\n      unicodeWhitespace(code)\n    ) {\n      return ok(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * In trail, after `]`.\n   *\n   * > 👉 **Note**: this deviates from `cmark-gfm` to fix a bug.\n   * > See end of <https://github.com/github/cmark-gfm/issues/278> for more.\n   *\n   * ```markdown\n   * > | https://example.com](\n   *                         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trailBracketAfter(code) {\n    // Whitespace or something that could start a resource or reference is the end.\n    // Switch back to trail otherwise.\n    if (\n      code === null ||\n      code === 40 ||\n      code === 91 ||\n      markdownLineEndingOrSpace(code) ||\n      unicodeWhitespace(code)\n    ) {\n      return ok(code)\n    }\n    return trail(code)\n  }\n\n  /**\n   * In character-reference like trail, after `&`.\n   *\n   * ```markdown\n   * > | https://example.com&amp;).\n   *                         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trailCharRefStart(code) {\n    // When non-alpha, it’s not a trail.\n    return asciiAlpha(code) ? trailCharRefInside(code) : nok(code)\n  }\n\n  /**\n   * In character-reference like trail.\n   *\n   * ```markdown\n   * > | https://example.com&amp;).\n   *                         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trailCharRefInside(code) {\n    // Switch back to trail if this is well-formed.\n    if (code === 59) {\n      effects.consume(code)\n      return trail\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return trailCharRefInside\n    }\n\n    // It’s not a trail.\n    return nok(code)\n  }\n}\n\n/**\n * Dot in email domain trail.\n *\n * This calls `ok` if this *is* the trail, followed by an end, which means\n * the trail is not part of the link.\n * It calls `nok` if this *is* part of the link.\n *\n * ```markdown\n * > | contact@example.org.\n *                        ^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeEmailDomainDotTrail(effects, ok, nok) {\n  return start\n\n  /**\n   * Dot.\n   *\n   * ```markdown\n   * > | contact@example.org.\n   *                    ^   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // Must be dot.\n    effects.consume(code)\n    return after\n  }\n\n  /**\n   * After dot.\n   *\n   * ```markdown\n   * > | contact@example.org.\n   *                     ^   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // Not a trail if alphanumeric.\n    return asciiAlphanumeric(code) ? nok(code) : ok(code)\n  }\n}\n\n/**\n * See:\n * <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L156>.\n *\n * @type {Previous}\n */\nfunction previousWww(code) {\n  return (\n    code === null ||\n    code === 40 ||\n    code === 42 ||\n    code === 95 ||\n    code === 91 ||\n    code === 93 ||\n    code === 126 ||\n    markdownLineEndingOrSpace(code)\n  )\n}\n\n/**\n * See:\n * <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L214>.\n *\n * @type {Previous}\n */\nfunction previousProtocol(code) {\n  return !asciiAlpha(code)\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Previous}\n */\nfunction previousEmail(code) {\n  // Do not allow a slash “inside” atext.\n  // The reference code is a bit weird, but that’s what it results in.\n  // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L307>.\n  // Other than slash, every preceding character is allowed.\n  return !(code === 47 || gfmAtext(code))\n}\n\n/**\n * @param {Code} code\n * @returns {boolean}\n */\nfunction gfmAtext(code) {\n  return (\n    code === 43 ||\n    code === 45 ||\n    code === 46 ||\n    code === 95 ||\n    asciiAlphanumeric(code)\n  )\n}\n\n/**\n * @param {Array<Event>} events\n * @returns {boolean}\n */\nfunction previousUnbalanced(events) {\n  let index = events.length\n  let result = false\n  while (index--) {\n    const token = events[index][1]\n    if (\n      (token.type === 'labelLink' || token.type === 'labelImage') &&\n      !token._balanced\n    ) {\n      result = true\n      break\n    }\n\n    // If we’ve seen this token, and it was marked as not having any unbalanced\n    // bracket before it, we can exit.\n    if (token._gfmAutolinkLiteralWalkedInto) {\n      result = false\n      break\n    }\n  }\n  if (events.length > 0 && !result) {\n    // Mark the last token as “walked into” w/o finding\n    // anything.\n    events[events.length - 1][1]._gfmAutolinkLiteralWalkedInto = true\n  }\n  return result\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {blankLine} from 'micromark-core-commonmark'\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEndingOrSpace} from 'micromark-util-character'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nconst indent = {\n  tokenize: tokenizeIndent,\n  partial: true\n}\n\n// To do: micromark should support a `_hiddenGfmFootnoteSupport`, which only\n// affects label start (image).\n// That will let us drop `tokenizePotentialGfmFootnote*`.\n// It currently has a `_hiddenFootnoteSupport`, which affects that and more.\n// That can be removed when `micromark-extension-footnote` is archived.\n\n/**\n * Create an extension for `micromark` to enable GFM footnote syntax.\n *\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to\n *   enable GFM footnote syntax.\n */\nexport function gfmFootnote() {\n  /** @type {Extension} */\n  return {\n    document: {\n      [91]: {\n        tokenize: tokenizeDefinitionStart,\n        continuation: {\n          tokenize: tokenizeDefinitionContinuation\n        },\n        exit: gfmFootnoteDefinitionEnd\n      }\n    },\n    text: {\n      [91]: {\n        tokenize: tokenizeGfmFootnoteCall\n      },\n      [93]: {\n        add: 'after',\n        tokenize: tokenizePotentialGfmFootnoteCall,\n        resolveTo: resolveToPotentialGfmFootnoteCall\n      }\n    }\n  }\n}\n\n// To do: remove after micromark update.\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizePotentialGfmFootnoteCall(effects, ok, nok) {\n  const self = this\n  let index = self.events.length\n  /** @type {Array<string>} */\n  // @ts-expect-error It’s fine!\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = [])\n  /** @type {Token} */\n  let labelStart\n\n  // Find an opening.\n  while (index--) {\n    const token = self.events[index][1]\n    if (token.type === 'labelImage') {\n      labelStart = token\n      break\n    }\n\n    // Exit if we’ve walked far enough.\n    if (\n      token.type === 'gfmFootnoteCall' ||\n      token.type === 'labelLink' ||\n      token.type === 'label' ||\n      token.type === 'image' ||\n      token.type === 'link'\n    ) {\n      break\n    }\n  }\n  return start\n\n  /**\n   * @type {State}\n   */\n  function start(code) {\n    if (!labelStart || !labelStart._balanced) {\n      return nok(code)\n    }\n    const id = normalizeIdentifier(\n      self.sliceSerialize({\n        start: labelStart.end,\n        end: self.now()\n      })\n    )\n    if (id.codePointAt(0) !== 94 || !defined.includes(id.slice(1))) {\n      return nok(code)\n    }\n    effects.enter('gfmFootnoteCallLabelMarker')\n    effects.consume(code)\n    effects.exit('gfmFootnoteCallLabelMarker')\n    return ok(code)\n  }\n}\n\n// To do: remove after micromark update.\n/** @type {Resolver} */\nfunction resolveToPotentialGfmFootnoteCall(events, context) {\n  let index = events.length\n  /** @type {Token | undefined} */\n  let labelStart\n\n  // Find an opening.\n  while (index--) {\n    if (\n      events[index][1].type === 'labelImage' &&\n      events[index][0] === 'enter'\n    ) {\n      labelStart = events[index][1]\n      break\n    }\n  }\n  // Change the `labelImageMarker` to a `data`.\n  events[index + 1][1].type = 'data'\n  events[index + 3][1].type = 'gfmFootnoteCallLabelMarker'\n\n  // The whole (without `!`):\n  /** @type {Token} */\n  const call = {\n    type: 'gfmFootnoteCall',\n    start: Object.assign({}, events[index + 3][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  }\n  // The `^` marker\n  /** @type {Token} */\n  const marker = {\n    type: 'gfmFootnoteCallMarker',\n    start: Object.assign({}, events[index + 3][1].end),\n    end: Object.assign({}, events[index + 3][1].end)\n  }\n  // Increment the end 1 character.\n  marker.end.column++\n  marker.end.offset++\n  marker.end._bufferIndex++\n  /** @type {Token} */\n  const string = {\n    type: 'gfmFootnoteCallString',\n    start: Object.assign({}, marker.end),\n    end: Object.assign({}, events[events.length - 1][1].start)\n  }\n  /** @type {Token} */\n  const chunk = {\n    type: 'chunkString',\n    contentType: 'string',\n    start: Object.assign({}, string.start),\n    end: Object.assign({}, string.end)\n  }\n\n  /** @type {Array<Event>} */\n  const replacement = [\n    // Take the `labelImageMarker` (now `data`, the `!`)\n    events[index + 1],\n    events[index + 2],\n    ['enter', call, context],\n    // The `[`\n    events[index + 3],\n    events[index + 4],\n    // The `^`.\n    ['enter', marker, context],\n    ['exit', marker, context],\n    // Everything in between.\n    ['enter', string, context],\n    ['enter', chunk, context],\n    ['exit', chunk, context],\n    ['exit', string, context],\n    // The ending (`]`, properly parsed and labelled).\n    events[events.length - 2],\n    events[events.length - 1],\n    ['exit', call, context]\n  ]\n  events.splice(index, events.length - index + 1, ...replacement)\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeGfmFootnoteCall(effects, ok, nok) {\n  const self = this\n  /** @type {Array<string>} */\n  // @ts-expect-error It’s fine!\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = [])\n  let size = 0\n  /** @type {boolean} */\n  let data\n\n  // Note: the implementation of `markdown-rs` is different, because it houses\n  // core *and* extensions in one project.\n  // Therefore, it can include footnote logic inside `label-end`.\n  // We can’t do that, but luckily, we can parse footnotes in a simpler way than\n  // needed for labels.\n  return start\n\n  /**\n   * Start of footnote label.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('gfmFootnoteCall')\n    effects.enter('gfmFootnoteCallLabelMarker')\n    effects.consume(code)\n    effects.exit('gfmFootnoteCallLabelMarker')\n    return callStart\n  }\n\n  /**\n   * After `[`, at `^`.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function callStart(code) {\n    if (code !== 94) return nok(code)\n    effects.enter('gfmFootnoteCallMarker')\n    effects.consume(code)\n    effects.exit('gfmFootnoteCallMarker')\n    effects.enter('gfmFootnoteCallString')\n    effects.enter('chunkString').contentType = 'string'\n    return callData\n  }\n\n  /**\n   * In label.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function callData(code) {\n    if (\n      // Too long.\n      size > 999 ||\n      // Closing brace with nothing.\n      (code === 93 && !data) ||\n      // Space or tab is not supported by GFM for some reason.\n      // `\\n` and `[` not being supported makes sense.\n      code === null ||\n      code === 91 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      return nok(code)\n    }\n    if (code === 93) {\n      effects.exit('chunkString')\n      const token = effects.exit('gfmFootnoteCallString')\n      if (!defined.includes(normalizeIdentifier(self.sliceSerialize(token)))) {\n        return nok(code)\n      }\n      effects.enter('gfmFootnoteCallLabelMarker')\n      effects.consume(code)\n      effects.exit('gfmFootnoteCallLabelMarker')\n      effects.exit('gfmFootnoteCall')\n      return ok\n    }\n    if (!markdownLineEndingOrSpace(code)) {\n      data = true\n    }\n    size++\n    effects.consume(code)\n    return code === 92 ? callEscape : callData\n  }\n\n  /**\n   * On character after escape.\n   *\n   * ```markdown\n   * > | a [^b\\c] d\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function callEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code)\n      size++\n      return callData\n    }\n    return callData(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinitionStart(effects, ok, nok) {\n  const self = this\n  /** @type {Array<string>} */\n  // @ts-expect-error It’s fine!\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = [])\n  /** @type {string} */\n  let identifier\n  let size = 0\n  /** @type {boolean | undefined} */\n  let data\n  return start\n\n  /**\n   * Start of GFM footnote definition.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('gfmFootnoteDefinition')._container = true\n    effects.enter('gfmFootnoteDefinitionLabel')\n    effects.enter('gfmFootnoteDefinitionLabelMarker')\n    effects.consume(code)\n    effects.exit('gfmFootnoteDefinitionLabelMarker')\n    return labelAtMarker\n  }\n\n  /**\n   * In label, at caret.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAtMarker(code) {\n    if (code === 94) {\n      effects.enter('gfmFootnoteDefinitionMarker')\n      effects.consume(code)\n      effects.exit('gfmFootnoteDefinitionMarker')\n      effects.enter('gfmFootnoteDefinitionLabelString')\n      effects.enter('chunkString').contentType = 'string'\n      return labelInside\n    }\n    return nok(code)\n  }\n\n  /**\n   * In label.\n   *\n   * > 👉 **Note**: `cmark-gfm` prevents whitespace from occurring in footnote\n   * > definition labels.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelInside(code) {\n    if (\n      // Too long.\n      size > 999 ||\n      // Closing brace with nothing.\n      (code === 93 && !data) ||\n      // Space or tab is not supported by GFM for some reason.\n      // `\\n` and `[` not being supported makes sense.\n      code === null ||\n      code === 91 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      return nok(code)\n    }\n    if (code === 93) {\n      effects.exit('chunkString')\n      const token = effects.exit('gfmFootnoteDefinitionLabelString')\n      identifier = normalizeIdentifier(self.sliceSerialize(token))\n      effects.enter('gfmFootnoteDefinitionLabelMarker')\n      effects.consume(code)\n      effects.exit('gfmFootnoteDefinitionLabelMarker')\n      effects.exit('gfmFootnoteDefinitionLabel')\n      return labelAfter\n    }\n    if (!markdownLineEndingOrSpace(code)) {\n      data = true\n    }\n    size++\n    effects.consume(code)\n    return code === 92 ? labelEscape : labelInside\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * > 👉 **Note**: `cmark-gfm` currently does not support escaped brackets:\n   * > <https://github.com/github/cmark-gfm/issues/240>\n   *\n   * ```markdown\n   * > | [^a\\*b]: c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code)\n      size++\n      return labelInside\n    }\n    return labelInside(code)\n  }\n\n  /**\n   * After definition label.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAfter(code) {\n    if (code === 58) {\n      effects.enter('definitionMarker')\n      effects.consume(code)\n      effects.exit('definitionMarker')\n      if (!defined.includes(identifier)) {\n        defined.push(identifier)\n      }\n\n      // Any whitespace after the marker is eaten, forming indented code\n      // is not possible.\n      // No space is also fine, just like a block quote marker.\n      return factorySpace(\n        effects,\n        whitespaceAfter,\n        'gfmFootnoteDefinitionWhitespace'\n      )\n    }\n    return nok(code)\n  }\n\n  /**\n   * After definition prefix.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function whitespaceAfter(code) {\n    // `markdown-rs` has a wrapping token for the prefix that is closed here.\n    return ok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinitionContinuation(effects, ok, nok) {\n  /// Start of footnote definition continuation.\n  ///\n  /// ```markdown\n  ///   | [^a]: b\n  /// > |     c\n  ///     ^\n  /// ```\n  //\n  // Either a blank line, which is okay, or an indented thing.\n  return effects.check(blankLine, ok, effects.attempt(indent, ok, nok))\n}\n\n/** @type {Exiter} */\nfunction gfmFootnoteDefinitionEnd(effects) {\n  effects.exit('gfmFootnoteDefinition')\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'gfmFootnoteDefinitionIndent',\n    4 + 1\n  )\n\n  /**\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'gfmFootnoteDefinitionIndent' &&\n      tail[2].sliceSerialize(tail[1], true).length === 4\n      ? ok(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean} [singleTilde=true]\n *   Whether to support strikethrough with a single tilde.\n *\n *   Single tildes work on github.com, but are technically prohibited by the\n *   GFM spec.\n */\n\nimport {splice} from 'micromark-util-chunked'\nimport {classifyCharacter} from 'micromark-util-classify-character'\nimport {resolveAll} from 'micromark-util-resolve-all'\n/**\n * Create an extension for `micromark` to enable GFM strikethrough syntax.\n *\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions`, to\n *   enable GFM strikethrough syntax.\n */\nexport function gfmStrikethrough(options) {\n  const options_ = options || {}\n  let single = options_.singleTilde\n  const tokenizer = {\n    tokenize: tokenizeStrikethrough,\n    resolveAll: resolveAllStrikethrough\n  }\n  if (single === null || single === undefined) {\n    single = true\n  }\n  return {\n    text: {\n      [126]: tokenizer\n    },\n    insideSpan: {\n      null: [tokenizer]\n    },\n    attentionMarkers: {\n      null: [126]\n    }\n  }\n\n  /**\n   * Take events and resolve strikethrough.\n   *\n   * @type {Resolver}\n   */\n  function resolveAllStrikethrough(events, context) {\n    let index = -1\n\n    // Walk through all events.\n    while (++index < events.length) {\n      // Find a token that can close.\n      if (\n        events[index][0] === 'enter' &&\n        events[index][1].type === 'strikethroughSequenceTemporary' &&\n        events[index][1]._close\n      ) {\n        let 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 (\n            events[open][0] === 'exit' &&\n            events[open][1].type === 'strikethroughSequenceTemporary' &&\n            events[open][1]._open &&\n            // If the sizes are the same:\n            events[index][1].end.offset - events[index][1].start.offset ===\n              events[open][1].end.offset - events[open][1].start.offset\n          ) {\n            events[index][1].type = 'strikethroughSequence'\n            events[open][1].type = 'strikethroughSequence'\n\n            /** @type {Token} */\n            const strikethrough = {\n              type: 'strikethrough',\n              start: Object.assign({}, events[open][1].start),\n              end: Object.assign({}, events[index][1].end)\n            }\n\n            /** @type {Token} */\n            const text = {\n              type: 'strikethroughText',\n              start: Object.assign({}, events[open][1].end),\n              end: Object.assign({}, events[index][1].start)\n            }\n\n            // Opening.\n            /** @type {Array<Event>} */\n            const nextEvents = [\n              ['enter', strikethrough, context],\n              ['enter', events[open][1], context],\n              ['exit', events[open][1], context],\n              ['enter', text, context]\n            ]\n            const insideSpan = context.parser.constructs.insideSpan.null\n            if (insideSpan) {\n              // Between.\n              splice(\n                nextEvents,\n                nextEvents.length,\n                0,\n                resolveAll(insideSpan, events.slice(open + 1, index), context)\n              )\n            }\n\n            // Closing.\n            splice(nextEvents, nextEvents.length, 0, [\n              ['exit', text, context],\n              ['enter', events[index][1], context],\n              ['exit', events[index][1], context],\n              ['exit', strikethrough, context]\n            ])\n            splice(events, open - 1, index - open + 3, nextEvents)\n            index = open + nextEvents.length - 2\n            break\n          }\n        }\n      }\n    }\n    index = -1\n    while (++index < events.length) {\n      if (events[index][1].type === 'strikethroughSequenceTemporary') {\n        events[index][1].type = 'data'\n      }\n    }\n    return events\n  }\n\n  /**\n   * @this {TokenizeContext}\n   * @type {Tokenizer}\n   */\n  function tokenizeStrikethrough(effects, ok, nok) {\n    const previous = this.previous\n    const events = this.events\n    let size = 0\n    return start\n\n    /** @type {State} */\n    function start(code) {\n      if (\n        previous === 126 &&\n        events[events.length - 1][1].type !== 'characterEscape'\n      ) {\n        return nok(code)\n      }\n      effects.enter('strikethroughSequenceTemporary')\n      return more(code)\n    }\n\n    /** @type {State} */\n    function more(code) {\n      const before = classifyCharacter(previous)\n      if (code === 126) {\n        // If this is the third marker, exit.\n        if (size > 1) return nok(code)\n        effects.consume(code)\n        size++\n        return more\n      }\n      if (size < 2 && !single) return nok(code)\n      const token = effects.exit('strikethroughSequenceTemporary')\n      const after = classifyCharacter(code)\n      token._open = !after || (after === 2 && Boolean(before))\n      token._close = !before || (before === 2 && Boolean(after))\n      return ok(code)\n    }\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n */\n\n// Port of `edit_map.rs` from `markdown-rs`.\n// This should move to `markdown-js` later.\n\n// Deal with several changes in events, batching them together.\n//\n// Preferably, changes should be kept to a minimum.\n// Sometimes, it’s needed to change the list of events, because parsing can be\n// messy, and it helps to expose a cleaner interface of events to the compiler\n// and other users.\n// It can also help to merge many adjacent similar events.\n// And, in other cases, it’s needed to parse subcontent: pass some events\n// through another tokenizer and inject the result.\n\n/**\n * @typedef {[number, number, Array<Event>]} Change\n * @typedef {[number, number, number]} Jump\n */\n\n/**\n * Tracks a bunch of edits.\n */\nexport class EditMap {\n  /**\n   * Create a new edit map.\n   */\n  constructor() {\n    /**\n     * Record of changes.\n     *\n     * @type {Array<Change>}\n     */\n    this.map = []\n  }\n\n  /**\n   * Create an edit: a remove and/or add at a certain place.\n   *\n   * @param {number} index\n   * @param {number} remove\n   * @param {Array<Event>} add\n   * @returns {void}\n   */\n  add(index, remove, add) {\n    addImpl(this, index, remove, add)\n  }\n\n  // To do: not used here.\n  // /**\n  //  * Create an edit: but insert `add` before existing additions.\n  //  *\n  //  * @param {number} index\n  //  * @param {number} remove\n  //  * @param {Array<Event>} add\n  //  * @returns {void}\n  //  */\n  // addBefore(index, remove, add) {\n  //   addImpl(this, index, remove, add, true)\n  // }\n\n  /**\n   * Done, change the events.\n   *\n   * @param {Array<Event>} events\n   * @returns {void}\n   */\n  consume(events) {\n    this.map.sort((a, b) => a[0] - b[0])\n\n    /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */\n    if (this.map.length === 0) {\n      return\n    }\n\n    // To do: if links are added in events, like they are in `markdown-rs`,\n    // this is needed.\n    // // Calculate jumps: where items in the current list move to.\n    // /** @type {Array<Jump>} */\n    // const jumps = []\n    // let index = 0\n    // let addAcc = 0\n    // let removeAcc = 0\n    // while (index < this.map.length) {\n    //   const [at, remove, add] = this.map[index]\n    //   removeAcc += remove\n    //   addAcc += add.length\n    //   jumps.push([at, removeAcc, addAcc])\n    //   index += 1\n    // }\n    //\n    // . shiftLinks(events, jumps)\n\n    let index = this.map.length\n    /** @type {Array<Array<Event>>} */\n    const vecs = []\n    while (index > 0) {\n      index -= 1\n      vecs.push(events.slice(this.map[index][0] + this.map[index][1]))\n      // eslint-disable-next-line unicorn/no-array-push-push\n      vecs.push(this.map[index][2])\n\n      // Truncate rest.\n      events.length = this.map[index][0]\n    }\n    vecs.push([...events])\n    events.length = 0\n    let slice = vecs.pop()\n    while (slice) {\n      events.push(...slice)\n      slice = vecs.pop()\n    }\n\n    // Truncate everything.\n    this.map.length = 0\n  }\n}\n\n/**\n * Create an edit.\n *\n * @param {EditMap} editMap\n * @param {number} at\n * @param {number} remove\n * @param {Array<Event>} add\n * @returns {void}\n */\nfunction addImpl(editMap, at, remove, add) {\n  let index = 0\n\n  /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */\n  if (remove === 0 && add.length === 0) {\n    return\n  }\n  while (index < editMap.map.length) {\n    if (editMap.map[index][0] === at) {\n      editMap.map[index][1] += remove\n\n      // To do: before not used.\n      // if (before) {\n      //   add.push(...editMap.map[index][2])\n      //   editMap.map[index][2] = add\n      // } else {\n      editMap.map[index][2].push(...add)\n      // }\n\n      return\n    }\n    index += 1\n  }\n  editMap.map.push([at, remove, add])\n}\n\n// /**\n//  * Shift `previous` and `next` links according to `jumps`.\n//  *\n//  * This fixes links in case there are events removed or added between them.\n//  *\n//  * @param {Array<Event>} events\n//  * @param {Array<Jump>} jumps\n//  */\n// function shiftLinks(events, jumps) {\n//   let jumpIndex = 0\n//   let index = 0\n//   let add = 0\n//   let rm = 0\n\n//   while (index < events.length) {\n//     const rmCurr = rm\n\n//     while (jumpIndex < jumps.length && jumps[jumpIndex][0] <= index) {\n//       add = jumps[jumpIndex][2]\n//       rm = jumps[jumpIndex][1]\n//       jumpIndex += 1\n//     }\n\n//     // Ignore items that will be removed.\n//     if (rm > rmCurr) {\n//       index += rm - rmCurr\n//     } else {\n//       console.log('to do: links?', add, rmCurr)\n//       // ?\n//       // if let Some(link) = &events[index].link {\n//       //     if let Some(next) = link.next {\n//       //         events[next].link.as_mut().unwrap().previous = Some(index + add - rm);\n//       //         while jumpIndex < jumps.len() && jumps[jumpIndex].0 <= next {\n//       //             add = jumps[jumpIndex].2;\n//       //             rm = jumps[jumpIndex].1;\n//       //             jumpIndex += 1;\n//       //         }\n//       //         events[index].link.as_mut().unwrap().next = Some(next + add - rm);\n//       //         index = next;\n//       //         continue;\n//       //     }\n//       // }\n//       index += 1\n//     }\n//   }\n// }\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n */\n\n/**\n * @typedef {'left' | 'center' | 'right' | 'none'} Align\n */\n\n/**\n * Figure out the alignment of a GFM table.\n *\n * @param {Array<Event>} events\n * @param {number} index\n * @returns {Array<Align>}\n */\nexport function gfmTableAlign(events, index) {\n  let inDelimiterRow = false\n  /** @type {Array<Align>} */\n  const align = []\n  while (index < events.length) {\n    const event = events[index]\n    if (inDelimiterRow) {\n      if (event[0] === 'enter') {\n        // Start of alignment value: set a new column.\n        // To do: `markdown-rs` uses `tableDelimiterCellValue`.\n        if (event[1].type === 'tableContent') {\n          align.push(\n            events[index + 1][1].type === 'tableDelimiterMarker'\n              ? 'left'\n              : 'none'\n          )\n        }\n      }\n      // Exits:\n      // End of alignment value: change the column.\n      // To do: `markdown-rs` uses `tableDelimiterCellValue`.\n      else if (event[1].type === 'tableContent') {\n        if (events[index - 1][1].type === 'tableDelimiterMarker') {\n          const alignIndex = align.length - 1\n          align[alignIndex] = align[alignIndex] === 'left' ? 'center' : 'right'\n        }\n      }\n      // Done!\n      else if (event[1].type === 'tableDelimiterRow') {\n        break\n      }\n    } else if (event[0] === 'enter' && event[1].type === 'tableDelimiterRow') {\n      inDelimiterRow = true\n    }\n    index += 1\n  }\n  return align\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\n/**\n * @typedef {[number, number, number, number]} Range\n *   Cell info.\n *\n * @typedef {0 | 1 | 2 | 3} RowKind\n *   Where we are: `1` for head row, `2` for delimiter row, `3` for body row.\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {EditMap} from './edit-map.js'\nimport {gfmTableAlign} from './infer.js'\n\n// To do: next major: expose functions.\n\n/**\n * Extension for `micromark` that can be passed in `extensions` to enable GFM\n * table syntax.\n *\n * @type {Extension}\n */\nexport const gfmTable = {\n  flow: {\n    null: {\n      tokenize: tokenizeTable,\n      resolveAll: resolveTable\n    }\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTable(effects, ok, nok) {\n  const self = this\n  let size = 0\n  let sizeB = 0\n  /** @type {boolean | undefined} */\n  let seen\n  return start\n\n  /**\n   * Start of a GFM table.\n   *\n   * If there is a valid table row or table head before, then we try to parse\n   * another row.\n   * Otherwise, we try to parse a head.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *   | | - |\n   * > | | b |\n   *     ^\n   * ```\n   * @type {State}\n   */\n  function start(code) {\n    let index = self.events.length - 1\n    while (index > -1) {\n      const type = self.events[index][1].type\n      if (\n        type === 'lineEnding' ||\n        // Note: markdown-rs uses `whitespace` instead of `linePrefix`\n        type === 'linePrefix'\n      )\n        index--\n      else break\n    }\n    const tail = index > -1 ? self.events[index][1].type : null\n    const next =\n      tail === 'tableHead' || tail === 'tableRow' ? bodyRowStart : headRowBefore\n\n    // Don’t allow lazy body rows.\n    if (next === bodyRowStart && self.parser.lazy[self.now().line]) {\n      return nok(code)\n    }\n    return next(code)\n  }\n\n  /**\n   * Before table head row.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowBefore(code) {\n    effects.enter('tableHead')\n    effects.enter('tableRow')\n    return headRowStart(code)\n  }\n\n  /**\n   * Before table head row, after whitespace.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowStart(code) {\n    if (code === 124) {\n      return headRowBreak(code)\n    }\n\n    // To do: micromark-js should let us parse our own whitespace in extensions,\n    // like `markdown-rs`:\n    //\n    // ```js\n    // // 4+ spaces.\n    // if (markdownSpace(code)) {\n    //   return nok(code)\n    // }\n    // ```\n\n    seen = true\n    // Count the first character, that isn’t a pipe, double.\n    sizeB += 1\n    return headRowBreak(code)\n  }\n\n  /**\n   * At break in table head row.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *       ^\n   *         ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowBreak(code) {\n    if (code === null) {\n      // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.\n      return nok(code)\n    }\n    if (markdownLineEnding(code)) {\n      // If anything other than one pipe (ignoring whitespace) was used, it’s fine.\n      if (sizeB > 1) {\n        sizeB = 0\n        // To do: check if this works.\n        // Feel free to interrupt:\n        self.interrupt = true\n        effects.exit('tableRow')\n        effects.enter('lineEnding')\n        effects.consume(code)\n        effects.exit('lineEnding')\n        return headDelimiterStart\n      }\n\n      // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.\n      return nok(code)\n    }\n    if (markdownSpace(code)) {\n      // To do: check if this is fine.\n      // effects.attempt(State::Next(StateName::GfmTableHeadRowBreak), State::Nok)\n      // State::Retry(space_or_tab(tokenizer))\n      return factorySpace(effects, headRowBreak, 'whitespace')(code)\n    }\n    sizeB += 1\n    if (seen) {\n      seen = false\n      // Header cell count.\n      size += 1\n    }\n    if (code === 124) {\n      effects.enter('tableCellDivider')\n      effects.consume(code)\n      effects.exit('tableCellDivider')\n      // Whether a delimiter was seen.\n      seen = true\n      return headRowBreak\n    }\n\n    // Anything else is cell data.\n    effects.enter('data')\n    return headRowData(code)\n  }\n\n  /**\n   * In table head row data.\n   *\n   * ```markdown\n   * > | | a |\n   *       ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowData(code) {\n    if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {\n      effects.exit('data')\n      return headRowBreak(code)\n    }\n    effects.consume(code)\n    return code === 92 ? headRowEscape : headRowData\n  }\n\n  /**\n   * In table head row escape.\n   *\n   * ```markdown\n   * > | | a\\-b |\n   *         ^\n   *   | | ---- |\n   *   | | c    |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowEscape(code) {\n    if (code === 92 || code === 124) {\n      effects.consume(code)\n      return headRowData\n    }\n    return headRowData(code)\n  }\n\n  /**\n   * Before delimiter row.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *     ^\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterStart(code) {\n    // Reset `interrupt`.\n    self.interrupt = false\n\n    // Note: in `markdown-rs`, we need to handle piercing here too.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code)\n    }\n    effects.enter('tableDelimiterRow')\n    // Track if we’ve seen a `:` or `|`.\n    seen = false\n    if (markdownSpace(code)) {\n      return factorySpace(\n        effects,\n        headDelimiterBefore,\n        'linePrefix',\n        self.parser.constructs.disable.null.includes('codeIndented')\n          ? undefined\n          : 4\n      )(code)\n    }\n    return headDelimiterBefore(code)\n  }\n\n  /**\n   * Before delimiter row, after optional whitespace.\n   *\n   * Reused when a `|` is found later, to parse another cell.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *     ^\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterBefore(code) {\n    if (code === 45 || code === 58) {\n      return headDelimiterValueBefore(code)\n    }\n    if (code === 124) {\n      seen = true\n      // If we start with a pipe, we open a cell marker.\n      effects.enter('tableCellDivider')\n      effects.consume(code)\n      effects.exit('tableCellDivider')\n      return headDelimiterCellBefore\n    }\n\n    // More whitespace / empty row not allowed at start.\n    return headDelimiterNok(code)\n  }\n\n  /**\n   * After `|`, before delimiter cell.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterCellBefore(code) {\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headDelimiterValueBefore, 'whitespace')(code)\n    }\n    return headDelimiterValueBefore(code)\n  }\n\n  /**\n   * Before delimiter cell value.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterValueBefore(code) {\n    // Align: left.\n    if (code === 58) {\n      sizeB += 1\n      seen = true\n      effects.enter('tableDelimiterMarker')\n      effects.consume(code)\n      effects.exit('tableDelimiterMarker')\n      return headDelimiterLeftAlignmentAfter\n    }\n\n    // Align: none.\n    if (code === 45) {\n      sizeB += 1\n      // To do: seems weird that this *isn’t* left aligned, but that state is used?\n      return headDelimiterLeftAlignmentAfter(code)\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return headDelimiterCellAfter(code)\n    }\n    return headDelimiterNok(code)\n  }\n\n  /**\n   * After delimiter cell left alignment marker.\n   *\n   * ```markdown\n   *   | | a  |\n   * > | | :- |\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterLeftAlignmentAfter(code) {\n    if (code === 45) {\n      effects.enter('tableDelimiterFiller')\n      return headDelimiterFiller(code)\n    }\n\n    // Anything else is not ok after the left-align colon.\n    return headDelimiterNok(code)\n  }\n\n  /**\n   * In delimiter cell filler.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterFiller(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return headDelimiterFiller\n    }\n\n    // Align is `center` if it was `left`, `right` otherwise.\n    if (code === 58) {\n      seen = true\n      effects.exit('tableDelimiterFiller')\n      effects.enter('tableDelimiterMarker')\n      effects.consume(code)\n      effects.exit('tableDelimiterMarker')\n      return headDelimiterRightAlignmentAfter\n    }\n    effects.exit('tableDelimiterFiller')\n    return headDelimiterRightAlignmentAfter(code)\n  }\n\n  /**\n   * After delimiter cell right alignment marker.\n   *\n   * ```markdown\n   *   | |  a |\n   * > | | -: |\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterRightAlignmentAfter(code) {\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headDelimiterCellAfter, 'whitespace')(code)\n    }\n    return headDelimiterCellAfter(code)\n  }\n\n  /**\n   * After delimiter cell.\n   *\n   * ```markdown\n   *   | |  a |\n   * > | | -: |\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterCellAfter(code) {\n    if (code === 124) {\n      return headDelimiterBefore(code)\n    }\n    if (code === null || markdownLineEnding(code)) {\n      // Exit when:\n      // * there was no `:` or `|` at all (it’s a thematic break or setext\n      //   underline instead)\n      // * the header cell count is not the delimiter cell count\n      if (!seen || size !== sizeB) {\n        return headDelimiterNok(code)\n      }\n\n      // Note: in markdown-rs`, a reset is needed here.\n      effects.exit('tableDelimiterRow')\n      effects.exit('tableHead')\n      // To do: in `markdown-rs`, resolvers need to be registered manually.\n      // effects.register_resolver(ResolveName::GfmTable)\n      return ok(code)\n    }\n    return headDelimiterNok(code)\n  }\n\n  /**\n   * In delimiter row, at a disallowed byte.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | x |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterNok(code) {\n    // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.\n    return nok(code)\n  }\n\n  /**\n   * Before table body row.\n   *\n   * ```markdown\n   *   | | a |\n   *   | | - |\n   * > | | b |\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowStart(code) {\n    // Note: in `markdown-rs` we need to manually take care of a prefix,\n    // but in `micromark-js` that is done for us, so if we’re here, we’re\n    // never at whitespace.\n    effects.enter('tableRow')\n    return bodyRowBreak(code)\n  }\n\n  /**\n   * At break in table body row.\n   *\n   * ```markdown\n   *   | | a |\n   *   | | - |\n   * > | | b |\n   *     ^\n   *       ^\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowBreak(code) {\n    if (code === 124) {\n      effects.enter('tableCellDivider')\n      effects.consume(code)\n      effects.exit('tableCellDivider')\n      return bodyRowBreak\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('tableRow')\n      return ok(code)\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, bodyRowBreak, 'whitespace')(code)\n    }\n\n    // Anything else is cell content.\n    effects.enter('data')\n    return bodyRowData(code)\n  }\n\n  /**\n   * In table body row data.\n   *\n   * ```markdown\n   *   | | a |\n   *   | | - |\n   * > | | b |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowData(code) {\n    if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {\n      effects.exit('data')\n      return bodyRowBreak(code)\n    }\n    effects.consume(code)\n    return code === 92 ? bodyRowEscape : bodyRowData\n  }\n\n  /**\n   * In table body row escape.\n   *\n   * ```markdown\n   *   | | a    |\n   *   | | ---- |\n   * > | | b\\-c |\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowEscape(code) {\n    if (code === 92 || code === 124) {\n      effects.consume(code)\n      return bodyRowData\n    }\n    return bodyRowData(code)\n  }\n}\n\n/** @type {Resolver} */\n// eslint-disable-next-line complexity\nfunction resolveTable(events, context) {\n  let index = -1\n  let inFirstCellAwaitingPipe = true\n  /** @type {RowKind} */\n  let rowKind = 0\n  /** @type {Range} */\n  let lastCell = [0, 0, 0, 0]\n  /** @type {Range} */\n  let cell = [0, 0, 0, 0]\n  let afterHeadAwaitingFirstBodyRow = false\n  let lastTableEnd = 0\n  /** @type {Token | undefined} */\n  let currentTable\n  /** @type {Token | undefined} */\n  let currentBody\n  /** @type {Token | undefined} */\n  let currentCell\n  const map = new EditMap()\n  while (++index < events.length) {\n    const event = events[index]\n    const token = event[1]\n    if (event[0] === 'enter') {\n      // Start of head.\n      if (token.type === 'tableHead') {\n        afterHeadAwaitingFirstBodyRow = false\n\n        // Inject previous (body end and) table end.\n        if (lastTableEnd !== 0) {\n          flushTableEnd(map, context, lastTableEnd, currentTable, currentBody)\n          currentBody = undefined\n          lastTableEnd = 0\n        }\n\n        // Inject table start.\n        currentTable = {\n          type: 'table',\n          start: Object.assign({}, token.start),\n          // Note: correct end is set later.\n          end: Object.assign({}, token.end)\n        }\n        map.add(index, 0, [['enter', currentTable, context]])\n      } else if (\n        token.type === 'tableRow' ||\n        token.type === 'tableDelimiterRow'\n      ) {\n        inFirstCellAwaitingPipe = true\n        currentCell = undefined\n        lastCell = [0, 0, 0, 0]\n        cell = [0, index + 1, 0, 0]\n\n        // Inject table body start.\n        if (afterHeadAwaitingFirstBodyRow) {\n          afterHeadAwaitingFirstBodyRow = false\n          currentBody = {\n            type: 'tableBody',\n            start: Object.assign({}, token.start),\n            // Note: correct end is set later.\n            end: Object.assign({}, token.end)\n          }\n          map.add(index, 0, [['enter', currentBody, context]])\n        }\n        rowKind = token.type === 'tableDelimiterRow' ? 2 : currentBody ? 3 : 1\n      }\n      // Cell data.\n      else if (\n        rowKind &&\n        (token.type === 'data' ||\n          token.type === 'tableDelimiterMarker' ||\n          token.type === 'tableDelimiterFiller')\n      ) {\n        inFirstCellAwaitingPipe = false\n\n        // First value in cell.\n        if (cell[2] === 0) {\n          if (lastCell[1] !== 0) {\n            cell[0] = cell[1]\n            currentCell = flushCell(\n              map,\n              context,\n              lastCell,\n              rowKind,\n              undefined,\n              currentCell\n            )\n            lastCell = [0, 0, 0, 0]\n          }\n          cell[2] = index\n        }\n      } else if (token.type === 'tableCellDivider') {\n        if (inFirstCellAwaitingPipe) {\n          inFirstCellAwaitingPipe = false\n        } else {\n          if (lastCell[1] !== 0) {\n            cell[0] = cell[1]\n            currentCell = flushCell(\n              map,\n              context,\n              lastCell,\n              rowKind,\n              undefined,\n              currentCell\n            )\n          }\n          lastCell = cell\n          cell = [lastCell[1], index, 0, 0]\n        }\n      }\n    }\n    // Exit events.\n    else if (token.type === 'tableHead') {\n      afterHeadAwaitingFirstBodyRow = true\n      lastTableEnd = index\n    } else if (\n      token.type === 'tableRow' ||\n      token.type === 'tableDelimiterRow'\n    ) {\n      lastTableEnd = index\n      if (lastCell[1] !== 0) {\n        cell[0] = cell[1]\n        currentCell = flushCell(\n          map,\n          context,\n          lastCell,\n          rowKind,\n          index,\n          currentCell\n        )\n      } else if (cell[1] !== 0) {\n        currentCell = flushCell(map, context, cell, rowKind, index, currentCell)\n      }\n      rowKind = 0\n    } else if (\n      rowKind &&\n      (token.type === 'data' ||\n        token.type === 'tableDelimiterMarker' ||\n        token.type === 'tableDelimiterFiller')\n    ) {\n      cell[3] = index\n    }\n  }\n  if (lastTableEnd !== 0) {\n    flushTableEnd(map, context, lastTableEnd, currentTable, currentBody)\n  }\n  map.consume(context.events)\n\n  // To do: move this into `html`, when events are exposed there.\n  // That’s what `markdown-rs` does.\n  // That needs updates to `mdast-util-gfm-table`.\n  index = -1\n  while (++index < context.events.length) {\n    const event = context.events[index]\n    if (event[0] === 'enter' && event[1].type === 'table') {\n      event[1]._align = gfmTableAlign(context.events, index)\n    }\n  }\n  return events\n}\n\n/// Generate a cell.\n/**\n *\n * @param {EditMap} map\n * @param {TokenizeContext} context\n * @param {Range} range\n * @param {RowKind} rowKind\n * @param {number | undefined} rowEnd\n * @param {Token | undefined} previousCell\n * @returns {Token | undefined}\n */\n// eslint-disable-next-line max-params\nfunction flushCell(map, context, range, rowKind, rowEnd, previousCell) {\n  // `markdown-rs` uses:\n  // rowKind === 2 ? 'tableDelimiterCell' : 'tableCell'\n  const groupName =\n    rowKind === 1\n      ? 'tableHeader'\n      : rowKind === 2\n      ? 'tableDelimiter'\n      : 'tableData'\n  // `markdown-rs` uses:\n  // rowKind === 2 ? 'tableDelimiterCellValue' : 'tableCellText'\n  const valueName = 'tableContent'\n\n  // Insert an exit for the previous cell, if there is one.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //          ^-- exit\n  //           ^^^^-- this cell\n  // ```\n  if (range[0] !== 0) {\n    previousCell.end = Object.assign({}, getPoint(context.events, range[0]))\n    map.add(range[0], 0, [['exit', previousCell, context]])\n  }\n\n  // Insert enter of this cell.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //           ^-- enter\n  //           ^^^^-- this cell\n  // ```\n  const now = getPoint(context.events, range[1])\n  previousCell = {\n    type: groupName,\n    start: Object.assign({}, now),\n    // Note: correct end is set later.\n    end: Object.assign({}, now)\n  }\n  map.add(range[1], 0, [['enter', previousCell, context]])\n\n  // Insert text start at first data start and end at last data end, and\n  // remove events between.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //            ^-- enter\n  //             ^-- exit\n  //           ^^^^-- this cell\n  // ```\n  if (range[2] !== 0) {\n    const relatedStart = getPoint(context.events, range[2])\n    const relatedEnd = getPoint(context.events, range[3])\n    /** @type {Token} */\n    const valueToken = {\n      type: valueName,\n      start: Object.assign({}, relatedStart),\n      end: Object.assign({}, relatedEnd)\n    }\n    map.add(range[2], 0, [['enter', valueToken, context]])\n    if (rowKind !== 2) {\n      // Fix positional info on remaining events\n      const start = context.events[range[2]]\n      const end = context.events[range[3]]\n      start[1].end = Object.assign({}, end[1].end)\n      start[1].type = 'chunkText'\n      start[1].contentType = 'text'\n\n      // Remove if needed.\n      if (range[3] > range[2] + 1) {\n        const a = range[2] + 1\n        const b = range[3] - range[2] - 1\n        map.add(a, b, [])\n      }\n    }\n    map.add(range[3] + 1, 0, [['exit', valueToken, context]])\n  }\n\n  // Insert an exit for the last cell, if at the row end.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //                    ^-- exit\n  //               ^^^^^^-- this cell (the last one contains two “between” parts)\n  // ```\n  if (rowEnd !== undefined) {\n    previousCell.end = Object.assign({}, getPoint(context.events, rowEnd))\n    map.add(rowEnd, 0, [['exit', previousCell, context]])\n    previousCell = undefined\n  }\n  return previousCell\n}\n\n/**\n * Generate table end (and table body end).\n *\n * @param {EditMap} map\n * @param {TokenizeContext} context\n * @param {number} index\n * @param {Token} table\n * @param {Token | undefined} tableBody\n */\n// eslint-disable-next-line max-params\nfunction flushTableEnd(map, context, index, table, tableBody) {\n  /** @type {Array<Event>} */\n  const exits = []\n  const related = getPoint(context.events, index)\n  if (tableBody) {\n    tableBody.end = Object.assign({}, related)\n    exits.push(['exit', tableBody, context])\n  }\n  table.end = Object.assign({}, related)\n  exits.push(['exit', table, context])\n  map.add(index + 1, 0, exits)\n}\n\n/**\n * @param {Array<Event>} events\n * @param {number} index\n * @returns {readonly Point}\n */\nfunction getPoint(events, index) {\n  const event = events[index]\n  const side = event[0] === 'enter' ? 'start' : 'end'\n  return event[1][side]\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEndingOrSpace,\n  markdownLineEnding,\n  markdownSpace\n} from 'micromark-util-character'\nconst tasklistCheck = {\n  tokenize: tokenizeTasklistCheck\n}\n\n// To do: next major: expose function to make extension.\n\n/**\n * Extension for `micromark` that can be passed in `extensions`, to\n * enable GFM task list items syntax.\n *\n * @type {Extension}\n */\nexport const gfmTaskListItem = {\n  text: {\n    [91]: tasklistCheck\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTasklistCheck(effects, ok, nok) {\n  const self = this\n  return open\n\n  /**\n   * At start of task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (\n      // Exit if there’s stuff before.\n      self.previous !== null ||\n      // Exit if not in the first content that is the first child of a list\n      // item.\n      !self._gfmTasklistFirstContentOfListItem\n    ) {\n      return nok(code)\n    }\n    effects.enter('taskListCheck')\n    effects.enter('taskListCheckMarker')\n    effects.consume(code)\n    effects.exit('taskListCheckMarker')\n    return inside\n  }\n\n  /**\n   * In task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    // Currently we match how GH works in files.\n    // To match how GH works in comments, use `markdownSpace` (`[\\t ]`) instead\n    // of `markdownLineEndingOrSpace` (`[\\t\\n\\r ]`).\n    if (markdownLineEndingOrSpace(code)) {\n      effects.enter('taskListCheckValueUnchecked')\n      effects.consume(code)\n      effects.exit('taskListCheckValueUnchecked')\n      return close\n    }\n    if (code === 88 || code === 120) {\n      effects.enter('taskListCheckValueChecked')\n      effects.consume(code)\n      effects.exit('taskListCheckValueChecked')\n      return close\n    }\n    return nok(code)\n  }\n\n  /**\n   * At close of task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function close(code) {\n    if (code === 93) {\n      effects.enter('taskListCheckMarker')\n      effects.consume(code)\n      effects.exit('taskListCheckMarker')\n      effects.exit('taskListCheck')\n      return after\n    }\n    return nok(code)\n  }\n\n  /**\n   * @type {State}\n   */\n  function after(code) {\n    // EOL in paragraph means there must be something else after it.\n    if (markdownLineEnding(code)) {\n      return ok(code)\n    }\n\n    // Space or tab?\n    // Check what comes after.\n    if (markdownSpace(code)) {\n      return effects.check(\n        {\n          tokenize: spaceThenNonSpace\n        },\n        ok,\n        nok\n      )(code)\n    }\n\n    // EOF, or non-whitespace, both wrong.\n    return nok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction spaceThenNonSpace(effects, ok, nok) {\n  return factorySpace(effects, after, 'whitespace')\n\n  /**\n   * After whitespace, after task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // EOF means there was nothing, so bad.\n    // EOL means there’s content after it, so good.\n    // Impossible to have more spaces.\n    // Anything else is good.\n    return code === null ? nok(code) : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-extension-gfm-footnote').HtmlOptions} HtmlOptions\n * @typedef {import('micromark-extension-gfm-strikethrough').Options} Options\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension\n */\n\nimport {\n  combineExtensions,\n  combineHtmlExtensions\n} from 'micromark-util-combine-extensions'\nimport {\n  gfmAutolinkLiteral,\n  gfmAutolinkLiteralHtml\n} from 'micromark-extension-gfm-autolink-literal'\nimport {gfmFootnote, gfmFootnoteHtml} from 'micromark-extension-gfm-footnote'\nimport {\n  gfmStrikethrough,\n  gfmStrikethroughHtml\n} from 'micromark-extension-gfm-strikethrough'\nimport {gfmTable, gfmTableHtml} from 'micromark-extension-gfm-table'\nimport {gfmTagfilterHtml} from 'micromark-extension-gfm-tagfilter'\nimport {\n  gfmTaskListItem,\n  gfmTaskListItemHtml\n} from 'micromark-extension-gfm-task-list-item'\n\n/**\n * Create an extension for `micromark` to enable GFM syntax.\n *\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n *\n *   Passed to `micromark-extens-gfm-strikethrough`.\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to enable GFM\n *   syntax.\n */\nexport function gfm(options) {\n  return combineExtensions([\n    gfmAutolinkLiteral,\n    gfmFootnote(),\n    gfmStrikethrough(options),\n    gfmTable,\n    gfmTaskListItem\n  ])\n}\n\n/**\n * Create an extension for `micromark` to support GFM when serializing to HTML.\n *\n * @param {HtmlOptions | null | undefined} [options]\n *   Configuration.\n *\n *   Passed to `micromark-extens-gfm-footnote`.\n * @returns {HtmlExtension}\n *   Extension for `micromark` that can be passed in `htmlExtensions` to\n *   support GFM when serializing to HTML.\n */\nexport function gfmHtml(options) {\n  return combineHtmlExtensions([\n    gfmAutolinkLiteralHtml,\n    gfmFootnoteHtml(options),\n    gfmStrikethroughHtml,\n    gfmTableHtml,\n    gfmTagfilterHtml,\n    gfmTaskListItemHtml\n  ])\n}\n","/**\n * Count how often a character (or substring) is used in a string.\n *\n * @param {string} value\n *   Value to search in.\n * @param {string} character\n *   Character (or substring) to look for.\n * @return {number}\n *   Number of times `character` occurred in `value`.\n */\nexport function ccount(value, character) {\n  const source = String(value)\n\n  if (typeof character !== 'string') {\n    throw new TypeError('Expected character')\n  }\n\n  let count = 0\n  let index = source.indexOf(character)\n\n  while (index !== -1) {\n    count++\n    index = source.indexOf(character, index + character.length)\n  }\n\n  return count\n}\n","/**\n * @typedef {import('mdast').Parent} MdastParent\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').Content} Content\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n * @typedef {import('mdast').Text} Text\n * @typedef {import('unist-util-visit-parents').Test} Test\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n */\n\n/**\n * @typedef {Content | Root} Node\n * @typedef {Extract<Node, MdastParent>} Parent\n * @typedef {Exclude<Parent, Root>} ContentParent\n *\n * @typedef RegExpMatchObject\n *   Info on the match.\n * @property {number} index\n *   The index of the search at which the result was found.\n * @property {string} input\n *   A copy of the search string in the text node.\n * @property {[Root, ...Array<ContentParent>, Text]} stack\n *   All ancestors of the text node, where the last node is the text itself.\n *\n * @callback ReplaceFunction\n *   Callback called when a search matches.\n * @param {...any} parameters\n *   The parameters are the result of corresponding search expression:\n *\n *   * `value` (`string`) — whole match\n *   * `...capture` (`Array<string>`) — matches from regex capture groups\n *   * `match` (`RegExpMatchObject`) — info on the match\n * @returns {Array<PhrasingContent> | PhrasingContent | string | false | undefined | null}\n *   Thing to replace with.\n *\n *   * when `null`, `undefined`, `''`, remove the match\n *   * …or when `false`, do not replace at all\n *   * …or when `string`, replace with a text node of that value\n *   * …or when `Node` or `Array<Node>`, replace with those nodes\n *\n * @typedef {string | RegExp} Find\n *   Pattern to find.\n *\n *   Strings are escaped and then turned into global expressions.\n *\n * @typedef {Array<FindAndReplaceTuple>} FindAndReplaceList\n *   Several find and replaces, in array form.\n * @typedef {Record<string, Replace>} FindAndReplaceSchema\n *   Several find and replaces, in object form.\n * @typedef {[Find, Replace]} FindAndReplaceTuple\n *   Find and replace in tuple form.\n * @typedef {string | ReplaceFunction} Replace\n *   Thing to replace with.\n * @typedef {[RegExp, ReplaceFunction]} Pair\n *   Normalized find and replace.\n * @typedef {Array<Pair>} Pairs\n *   All find and replaced.\n *\n * @typedef Options\n *   Configuration.\n * @property {Test | null | undefined} [ignore]\n *   Test for which nodes to ignore.\n */\n\nimport escape from 'escape-string-regexp'\nimport {visitParents} from 'unist-util-visit-parents'\nimport {convert} from 'unist-util-is'\n\nconst own = {}.hasOwnProperty\n\n/**\n * Find patterns in a tree and replace them.\n *\n * The algorithm searches the tree in *preorder* for complete values in `Text`\n * nodes.\n * Partial matches are not supported.\n *\n * @param tree\n *   Tree to change.\n * @param find\n *   Patterns to find.\n * @param replace\n *   Things to replace with (when `find` is `Find`) or configuration.\n * @param options\n *   Configuration (when `find` is not `Find`).\n * @returns\n *   Given, modified, tree.\n */\n// To do: next major: remove `find` & `replace` combo, remove schema.\nexport const findAndReplace =\n  /**\n   * @type {(\n   *   (<Tree extends Node>(tree: Tree, find: Find, replace?: Replace | null | undefined, options?: Options | null | undefined) => Tree) &\n   *   (<Tree extends Node>(tree: Tree, schema: FindAndReplaceSchema | FindAndReplaceList, options?: Options | null | undefined) => Tree)\n   * )}\n   **/\n  (\n    /**\n     * @template {Node} Tree\n     * @param {Tree} tree\n     * @param {Find | FindAndReplaceSchema | FindAndReplaceList} find\n     * @param {Replace | Options | null | undefined} [replace]\n     * @param {Options | null | undefined} [options]\n     * @returns {Tree}\n     */\n    function (tree, find, replace, options) {\n      /** @type {Options | null | undefined} */\n      let settings\n      /** @type {FindAndReplaceSchema|FindAndReplaceList} */\n      let schema\n\n      if (typeof find === 'string' || find instanceof RegExp) {\n        // @ts-expect-error don’t expect options twice.\n        schema = [[find, replace]]\n        settings = options\n      } else {\n        schema = find\n        // @ts-expect-error don’t expect replace twice.\n        settings = replace\n      }\n\n      if (!settings) {\n        settings = {}\n      }\n\n      const ignored = convert(settings.ignore || [])\n      const pairs = toPairs(schema)\n      let pairIndex = -1\n\n      while (++pairIndex < pairs.length) {\n        visitParents(tree, 'text', visitor)\n      }\n\n      // To do next major: don’t return the given tree.\n      return tree\n\n      /** @type {import('unist-util-visit-parents/complex-types.js').BuildVisitor<Root, 'text'>} */\n      function visitor(node, parents) {\n        let index = -1\n        /** @type {Parent | undefined} */\n        let grandparent\n\n        while (++index < parents.length) {\n          const parent = parents[index]\n\n          if (\n            ignored(\n              parent,\n              // @ts-expect-error: TS doesn’t understand but it’s perfect.\n              grandparent ? grandparent.children.indexOf(parent) : undefined,\n              grandparent\n            )\n          ) {\n            return\n          }\n\n          grandparent = parent\n        }\n\n        if (grandparent) {\n          return handler(node, parents)\n        }\n      }\n\n      /**\n       * Handle a text node which is not in an ignored parent.\n       *\n       * @param {Text} node\n       *   Text node.\n       * @param {Array<Parent>} parents\n       *   Parents.\n       * @returns {VisitorResult}\n       *   Result.\n       */\n      function handler(node, parents) {\n        const parent = parents[parents.length - 1]\n        const find = pairs[pairIndex][0]\n        const replace = pairs[pairIndex][1]\n        let start = 0\n        // @ts-expect-error: TS is wrong, some of these children can be text.\n        const index = parent.children.indexOf(node)\n        let change = false\n        /** @type {Array<PhrasingContent>} */\n        let nodes = []\n\n        find.lastIndex = 0\n\n        let match = find.exec(node.value)\n\n        while (match) {\n          const position = match.index\n          /** @type {RegExpMatchObject} */\n          const matchObject = {\n            index: match.index,\n            input: match.input,\n            // @ts-expect-error: stack is fine.\n            stack: [...parents, node]\n          }\n          let value = replace(...match, matchObject)\n\n          if (typeof value === 'string') {\n            value = value.length > 0 ? {type: 'text', value} : undefined\n          }\n\n          // It wasn’t a match after all.\n          if (value !== false) {\n            if (start !== position) {\n              nodes.push({\n                type: 'text',\n                value: node.value.slice(start, position)\n              })\n            }\n\n            if (Array.isArray(value)) {\n              nodes.push(...value)\n            } else if (value) {\n              nodes.push(value)\n            }\n\n            start = position + match[0].length\n            change = true\n          }\n\n          if (!find.global) {\n            break\n          }\n\n          match = find.exec(node.value)\n        }\n\n        if (change) {\n          if (start < node.value.length) {\n            nodes.push({type: 'text', value: node.value.slice(start)})\n          }\n\n          parent.children.splice(index, 1, ...nodes)\n        } else {\n          nodes = [node]\n        }\n\n        return index + nodes.length\n      }\n    }\n  )\n\n/**\n * Turn a schema into pairs.\n *\n * @param {FindAndReplaceSchema | FindAndReplaceList} schema\n *   Schema.\n * @returns {Pairs}\n *   Clean pairs.\n */\nfunction toPairs(schema) {\n  /** @type {Pairs} */\n  const result = []\n\n  if (typeof schema !== 'object') {\n    throw new TypeError('Expected array or object as schema')\n  }\n\n  if (Array.isArray(schema)) {\n    let index = -1\n\n    while (++index < schema.length) {\n      result.push([\n        toExpression(schema[index][0]),\n        toFunction(schema[index][1])\n      ])\n    }\n  } else {\n    /** @type {string} */\n    let key\n\n    for (key in schema) {\n      if (own.call(schema, key)) {\n        result.push([toExpression(key), toFunction(schema[key])])\n      }\n    }\n  }\n\n  return result\n}\n\n/**\n * Turn a find into an expression.\n *\n * @param {Find} find\n *   Find.\n * @returns {RegExp}\n *   Expression.\n */\nfunction toExpression(find) {\n  return typeof find === 'string' ? new RegExp(escape(find), 'g') : find\n}\n\n/**\n * Turn a replace into a function.\n *\n * @param {Replace} replace\n *   Replace.\n * @returns {ReplaceFunction}\n *   Function.\n */\nfunction toFunction(replace) {\n  return typeof replace === 'function' ? replace : () => replace\n}\n","export default function escapeStringRegexp(string) {\n\tif (typeof string !== 'string') {\n\t\tthrow new TypeError('Expected a string');\n\t}\n\n\t// Escape characters with special meaning either inside or outside character sets.\n\t// Use a simple backslash escape when it’s always valid, and a `\\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.\n\treturn string\n\t\t.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&')\n\t\t.replace(/-/g, '\\\\x2d');\n}\n","/**\n * @typedef {import('mdast').Link} Link\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n *\n * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n * @typedef {import('mdast-util-from-markdown').Transform} FromMarkdownTransform\n *\n * @typedef {import('mdast-util-to-markdown').ConstructName} ConstructName\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n *\n * @typedef {import('mdast-util-find-and-replace').ReplaceFunction} ReplaceFunction\n * @typedef {import('mdast-util-find-and-replace').RegExpMatchObject} RegExpMatchObject\n */\n\nimport {ccount} from 'ccount'\nimport {findAndReplace} from 'mdast-util-find-and-replace'\nimport {unicodePunctuation, unicodeWhitespace} from 'micromark-util-character'\n\n/** @type {ConstructName} */\nconst inConstruct = 'phrasing'\n/** @type {Array<ConstructName>} */\nconst notInConstruct = ['autolink', 'link', 'image', 'label']\n\n// To do: next major: expose functions instead of extensions.\n\n/**\n * Extension for `mdast-util-from-markdown` to enable GFM autolink literals.\n *\n * @type {FromMarkdownExtension}\n */\nexport const gfmAutolinkLiteralFromMarkdown = {\n  transforms: [transformGfmAutolinkLiterals],\n  enter: {\n    literalAutolink: enterLiteralAutolink,\n    literalAutolinkEmail: enterLiteralAutolinkValue,\n    literalAutolinkHttp: enterLiteralAutolinkValue,\n    literalAutolinkWww: enterLiteralAutolinkValue\n  },\n  exit: {\n    literalAutolink: exitLiteralAutolink,\n    literalAutolinkEmail: exitLiteralAutolinkEmail,\n    literalAutolinkHttp: exitLiteralAutolinkHttp,\n    literalAutolinkWww: exitLiteralAutolinkWww\n  }\n}\n\n/**\n * Extension for `mdast-util-to-markdown` to enable GFM autolink literals.\n *\n * @type {ToMarkdownExtension}\n */\nexport const gfmAutolinkLiteralToMarkdown = {\n  unsafe: [\n    {\n      character: '@',\n      before: '[+\\\\-.\\\\w]',\n      after: '[\\\\-.\\\\w]',\n      inConstruct,\n      notInConstruct\n    },\n    {\n      character: '.',\n      before: '[Ww]',\n      after: '[\\\\-.\\\\w]',\n      inConstruct,\n      notInConstruct\n    },\n    {character: ':', before: '[ps]', after: '\\\\/', inConstruct, notInConstruct}\n  ]\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterLiteralAutolink(token) {\n  this.enter({type: 'link', title: null, url: '', children: []}, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterLiteralAutolinkValue(token) {\n  this.config.enter.autolinkProtocol.call(this, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitLiteralAutolinkHttp(token) {\n  this.config.exit.autolinkProtocol.call(this, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitLiteralAutolinkWww(token) {\n  this.config.exit.data.call(this, token)\n  const node = /** @type {Link} */ (this.stack[this.stack.length - 1])\n  node.url = 'http://' + this.sliceSerialize(token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitLiteralAutolinkEmail(token) {\n  this.config.exit.autolinkEmail.call(this, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitLiteralAutolink(token) {\n  this.exit(token)\n}\n\n/** @type {FromMarkdownTransform} */\nfunction transformGfmAutolinkLiterals(tree) {\n  findAndReplace(\n    tree,\n    [\n      [/(https?:\\/\\/|www(?=\\.))([-.\\w]+)([^ \\t\\r\\n]*)/gi, findUrl],\n      [/([-.\\w+]+)@([-\\w]+(?:\\.[-\\w]+)+)/g, findEmail]\n    ],\n    {ignore: ['link', 'linkReference']}\n  )\n}\n\n/**\n * @type {ReplaceFunction}\n * @param {string} _\n * @param {string} protocol\n * @param {string} domain\n * @param {string} path\n * @param {RegExpMatchObject} match\n * @returns {Link | Array<PhrasingContent> | false}\n */\n// eslint-disable-next-line max-params\nfunction findUrl(_, protocol, domain, path, match) {\n  let prefix = ''\n\n  // Not an expected previous character.\n  if (!previous(match)) {\n    return false\n  }\n\n  // Treat `www` as part of the domain.\n  if (/^w/i.test(protocol)) {\n    domain = protocol + domain\n    protocol = ''\n    prefix = 'http://'\n  }\n\n  if (!isCorrectDomain(domain)) {\n    return false\n  }\n\n  const parts = splitUrl(domain + path)\n\n  if (!parts[0]) return false\n\n  /** @type {Link} */\n  const result = {\n    type: 'link',\n    title: null,\n    url: prefix + protocol + parts[0],\n    children: [{type: 'text', value: protocol + parts[0]}]\n  }\n\n  if (parts[1]) {\n    return [result, {type: 'text', value: parts[1]}]\n  }\n\n  return result\n}\n\n/**\n * @type {ReplaceFunction}\n * @param {string} _\n * @param {string} atext\n * @param {string} label\n * @param {RegExpMatchObject} match\n * @returns {Link | false}\n */\nfunction findEmail(_, atext, label, match) {\n  if (\n    // Not an expected previous character.\n    !previous(match, true) ||\n    // Label ends in not allowed character.\n    /[-\\d_]$/.test(label)\n  ) {\n    return false\n  }\n\n  return {\n    type: 'link',\n    title: null,\n    url: 'mailto:' + atext + '@' + label,\n    children: [{type: 'text', value: atext + '@' + label}]\n  }\n}\n\n/**\n * @param {string} domain\n * @returns {boolean}\n */\nfunction isCorrectDomain(domain) {\n  const parts = domain.split('.')\n\n  if (\n    parts.length < 2 ||\n    (parts[parts.length - 1] &&\n      (/_/.test(parts[parts.length - 1]) ||\n        !/[a-zA-Z\\d]/.test(parts[parts.length - 1]))) ||\n    (parts[parts.length - 2] &&\n      (/_/.test(parts[parts.length - 2]) ||\n        !/[a-zA-Z\\d]/.test(parts[parts.length - 2])))\n  ) {\n    return false\n  }\n\n  return true\n}\n\n/**\n * @param {string} url\n * @returns {[string, string | undefined]}\n */\nfunction splitUrl(url) {\n  const trailExec = /[!\"&'),.:;<>?\\]}]+$/.exec(url)\n\n  if (!trailExec) {\n    return [url, undefined]\n  }\n\n  url = url.slice(0, trailExec.index)\n\n  let trail = trailExec[0]\n  let closingParenIndex = trail.indexOf(')')\n  const openingParens = ccount(url, '(')\n  let closingParens = ccount(url, ')')\n\n  while (closingParenIndex !== -1 && openingParens > closingParens) {\n    url += trail.slice(0, closingParenIndex + 1)\n    trail = trail.slice(closingParenIndex + 1)\n    closingParenIndex = trail.indexOf(')')\n    closingParens++\n  }\n\n  return [url, trail]\n}\n\n/**\n * @param {RegExpMatchObject} match\n * @param {boolean | null | undefined} [email=false]\n * @returns {boolean}\n */\nfunction previous(match, email) {\n  const code = match.input.charCodeAt(match.index - 1)\n\n  return (\n    (match.index === 0 ||\n      unicodeWhitespace(code) ||\n      unicodePunctuation(code)) &&\n    (!email || code !== 47)\n  )\n}\n","/**\n * @typedef {import('../types.js').AssociationId} AssociationId\n */\n\nimport {decodeString} from 'micromark-util-decode-string'\n\n/**\n * Get an identifier from an association to match it to others.\n *\n * Associations are nodes that match to something else through an ID:\n * <https://github.com/syntax-tree/mdast#association>.\n *\n * The `label` of an association is the string value: character escapes and\n * references work, and casing is intact.\n * The `identifier` is used to match one association to another:\n * controversially, character escapes and references don’t work in this\n * matching: `&copy;` does not match `©`, and `\\+` does not match `+`.\n *\n * But casing is ignored (and whitespace) is trimmed and collapsed: ` A\\nb`\n * matches `a b`.\n * So, we do prefer the label when figuring out how we’re going to serialize:\n * it has whitespace, casing, and we can ignore most useless character\n * escapes and all character references.\n *\n * @type {AssociationId}\n */\nexport function association(node) {\n  if (node.label || !node.identifier) {\n    return node.label || ''\n  }\n\n  return decodeString(node.identifier)\n}\n","/**\n * @typedef {import('../types.js').FlowContent} FlowContent\n * @typedef {import('../types.js').Node} Node\n * @typedef {import('../types.js').Parent} Parent\n * @typedef {import('../types.js').State} State\n * @typedef {import('../types.js').TrackFields} TrackFields\n */\n\n/**\n * @param {Parent & {children: Array<FlowContent>}} parent\n *   Parent of flow nodes.\n * @param {State} state\n *   Info passed around about the current state.\n * @param {TrackFields} info\n *   Info on where we are in the document we are generating.\n * @returns {string}\n *   Serialized children, joined by (blank) lines.\n */\nexport function containerFlow(parent, state, info) {\n  const indexStack = state.indexStack\n  const children = parent.children || []\n  const tracker = state.createTracker(info)\n  /** @type {Array<string>} */\n  const results = []\n  let index = -1\n\n  indexStack.push(-1)\n\n  while (++index < children.length) {\n    const child = children[index]\n\n    indexStack[indexStack.length - 1] = index\n\n    results.push(\n      tracker.move(\n        state.handle(child, parent, state, {\n          before: '\\n',\n          after: '\\n',\n          ...tracker.current()\n        })\n      )\n    )\n\n    if (child.type !== 'list') {\n      state.bulletLastUsed = undefined\n    }\n\n    if (index < children.length - 1) {\n      results.push(\n        tracker.move(between(child, children[index + 1], parent, state))\n      )\n    }\n  }\n\n  indexStack.pop()\n\n  return results.join('')\n}\n\n/**\n * @param {Node} left\n * @param {Node} right\n * @param {Parent} parent\n * @param {State} state\n * @returns {string}\n */\nfunction between(left, right, parent, state) {\n  let index = state.join.length\n\n  while (index--) {\n    const result = state.join[index](left, right, parent, state)\n\n    if (result === true || result === 1) {\n      break\n    }\n\n    if (typeof result === 'number') {\n      return '\\n'.repeat(1 + result)\n    }\n\n    if (result === false) {\n      return '\\n\\n<!---->\\n\\n'\n    }\n  }\n\n  return '\\n\\n'\n}\n","/**\n * @typedef {import('../types.js').IndentLines} IndentLines\n */\n\nconst eol = /\\r?\\n|\\r/g\n\n/**\n * @type {IndentLines}\n */\nexport function indentLines(value, map) {\n  /** @type {Array<string>} */\n  const result = []\n  let start = 0\n  let line = 0\n  /** @type {RegExpExecArray | null} */\n  let match\n\n  while ((match = eol.exec(value))) {\n    one(value.slice(start, match.index))\n    result.push(match[0])\n    start = match.index + match[0].length\n    line++\n  }\n\n  one(value.slice(start))\n\n  return result.join('')\n\n  /**\n   * @param {string} value\n   */\n  function one(value) {\n    result.push(map(value, line, !value))\n  }\n}\n","/**\n * @typedef {import('../types.js').Unsafe} Unsafe\n */\n\n/**\n * @param {Unsafe} pattern\n * @returns {RegExp}\n */\nexport function patternCompile(pattern) {\n  if (!pattern._compiled) {\n    const before =\n      (pattern.atBreak ? '[\\\\r\\\\n][\\\\t ]*' : '') +\n      (pattern.before ? '(?:' + pattern.before + ')' : '')\n\n    pattern._compiled = new RegExp(\n      (before ? '(' + before + ')' : '') +\n        (/[|\\\\{}()[\\]^$+*?.-]/.test(pattern.character) ? '\\\\' : '') +\n        pattern.character +\n        (pattern.after ? '(?:' + pattern.after + ')' : ''),\n      'g'\n    )\n  }\n\n  return pattern._compiled\n}\n","/**\n * @typedef {import('../types.js').Unsafe} Unsafe\n * @typedef {import('../types.js').ConstructName} ConstructName\n */\n\n/**\n * @param {Array<ConstructName>} stack\n * @param {Unsafe} pattern\n * @returns {boolean}\n */\nexport function patternInScope(stack, pattern) {\n  return (\n    listInScope(stack, pattern.inConstruct, true) &&\n    !listInScope(stack, pattern.notInConstruct, false)\n  )\n}\n\n/**\n * @param {Array<ConstructName>} stack\n * @param {Unsafe['inConstruct']} list\n * @param {boolean} none\n * @returns {boolean}\n */\nfunction listInScope(stack, list, none) {\n  if (typeof list === 'string') {\n    list = [list]\n  }\n\n  if (!list || list.length === 0) {\n    return none\n  }\n\n  let index = -1\n\n  while (++index < list.length) {\n    if (stack.includes(list[index])) {\n      return true\n    }\n  }\n\n  return false\n}\n","/**\n * @typedef {import('../types.js').State} State\n * @typedef {import('../types.js').SafeConfig} SafeConfig\n */\n\nimport {patternCompile} from './pattern-compile.js'\nimport {patternInScope} from './pattern-in-scope.js'\n\n/**\n * Make a string safe for embedding in markdown constructs.\n *\n * In markdown, almost all punctuation characters can, in certain cases,\n * result in something.\n * Whether they do is highly subjective to where they happen and in what\n * they happen.\n *\n * To solve this, `mdast-util-to-markdown` tracks:\n *\n * * Characters before and after something;\n * * What “constructs” we are in.\n *\n * This information is then used by this function to escape or encode\n * special characters.\n *\n * @param {State} state\n *   Info passed around about the current state.\n * @param {string | null | undefined} input\n *   Raw value to make safe.\n * @param {SafeConfig} config\n *   Configuration.\n * @returns {string}\n *   Serialized markdown safe for embedding.\n */\nexport function safe(state, input, config) {\n  const value = (config.before || '') + (input || '') + (config.after || '')\n  /** @type {Array<number>} */\n  const positions = []\n  /** @type {Array<string>} */\n  const result = []\n  /** @type {Record<number, {before: boolean, after: boolean}>} */\n  const infos = {}\n  let index = -1\n\n  while (++index < state.unsafe.length) {\n    const pattern = state.unsafe[index]\n\n    if (!patternInScope(state.stack, pattern)) {\n      continue\n    }\n\n    const expression = patternCompile(pattern)\n    /** @type {RegExpExecArray | null} */\n    let match\n\n    while ((match = expression.exec(value))) {\n      const before = 'before' in pattern || Boolean(pattern.atBreak)\n      const after = 'after' in pattern\n      const position = match.index + (before ? match[1].length : 0)\n\n      if (positions.includes(position)) {\n        if (infos[position].before && !before) {\n          infos[position].before = false\n        }\n\n        if (infos[position].after && !after) {\n          infos[position].after = false\n        }\n      } else {\n        positions.push(position)\n        infos[position] = {before, after}\n      }\n    }\n  }\n\n  positions.sort(numerical)\n\n  let start = config.before ? config.before.length : 0\n  const end = value.length - (config.after ? config.after.length : 0)\n  index = -1\n\n  while (++index < positions.length) {\n    const position = positions[index]\n\n    // Character before or after matched:\n    if (position < start || position >= end) {\n      continue\n    }\n\n    // If this character is supposed to be escaped because it has a condition on\n    // the next character, and the next character is definitly being escaped,\n    // then skip this escape.\n    if (\n      (position + 1 < end &&\n        positions[index + 1] === position + 1 &&\n        infos[position].after &&\n        !infos[position + 1].before &&\n        !infos[position + 1].after) ||\n      (positions[index - 1] === position - 1 &&\n        infos[position].before &&\n        !infos[position - 1].before &&\n        !infos[position - 1].after)\n    ) {\n      continue\n    }\n\n    if (start !== position) {\n      // If we have to use a character reference, an ampersand would be more\n      // correct, but as backslashes only care about punctuation, either will\n      // do the trick\n      result.push(escapeBackslashes(value.slice(start, position), '\\\\'))\n    }\n\n    start = position\n\n    if (\n      /[!-/:-@[-`{-~]/.test(value.charAt(position)) &&\n      (!config.encode || !config.encode.includes(value.charAt(position)))\n    ) {\n      // Character escape.\n      result.push('\\\\')\n    } else {\n      // Character reference.\n      result.push(\n        '&#x' + value.charCodeAt(position).toString(16).toUpperCase() + ';'\n      )\n      start++\n    }\n  }\n\n  result.push(escapeBackslashes(value.slice(start, end), config.after))\n\n  return result.join('')\n}\n\n/**\n * @param {number} a\n * @param {number} b\n * @returns {number}\n */\nfunction numerical(a, b) {\n  return a - b\n}\n\n/**\n * @param {string} value\n * @param {string} after\n * @returns {string}\n */\nfunction escapeBackslashes(value, after) {\n  const expression = /\\\\(?=[!-/:-@[-`{-~])/g\n  /** @type {Array<number>} */\n  const positions = []\n  /** @type {Array<string>} */\n  const results = []\n  const whole = value + after\n  let index = -1\n  let start = 0\n  /** @type {RegExpExecArray | null} */\n  let match\n\n  while ((match = expression.exec(whole))) {\n    positions.push(match.index)\n  }\n\n  while (++index < positions.length) {\n    if (start !== positions[index]) {\n      results.push(value.slice(start, positions[index]))\n    }\n\n    results.push('\\\\')\n    start = positions[index]\n  }\n\n  results.push(value.slice(start))\n\n  return results.join('')\n}\n","/**\n * @typedef {import('../types.js').CreateTracker} CreateTracker\n * @typedef {import('../types.js').TrackCurrent} TrackCurrent\n * @typedef {import('../types.js').TrackMove} TrackMove\n * @typedef {import('../types.js').TrackShift} TrackShift\n */\n\n/**\n * Track positional info in the output.\n *\n * @type {CreateTracker}\n */\nexport function track(config) {\n  // Defaults are used to prevent crashes when older utilities somehow activate\n  // this code.\n  /* c8 ignore next 5 */\n  const options = config || {}\n  const now = options.now || {}\n  let lineShift = options.lineShift || 0\n  let line = now.line || 1\n  let column = now.column || 1\n\n  return {move, current, shift}\n\n  /**\n   * Get the current tracked info.\n   *\n   * @type {TrackCurrent}\n   */\n  function current() {\n    return {now: {line, column}, lineShift}\n  }\n\n  /**\n   * Define an increased line shift (the typical indent for lines).\n   *\n   * @type {TrackShift}\n   */\n  function shift(value) {\n    lineShift += value\n  }\n\n  /**\n   * Move past some generated markdown.\n   *\n   * @type {TrackMove}\n   */\n  function move(input) {\n    // eslint-disable-next-line unicorn/prefer-default-parameters\n    const value = input || ''\n    const chunks = value.split(/\\r?\\n|\\r/g)\n    const tail = chunks[chunks.length - 1]\n    line += chunks.length - 1\n    column =\n      chunks.length === 1 ? column + tail.length : 1 + tail.length + lineShift\n    return value\n  }\n}\n","/**\n * @typedef {import('mdast').FootnoteReference} FootnoteReference\n * @typedef {import('mdast').FootnoteDefinition} FootnoteDefinition\n * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Map} Map\n */\n\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {association} from 'mdast-util-to-markdown/lib/util/association.js'\nimport {containerFlow} from 'mdast-util-to-markdown/lib/util/container-flow.js'\nimport {indentLines} from 'mdast-util-to-markdown/lib/util/indent-lines.js'\nimport {safe} from 'mdast-util-to-markdown/lib/util/safe.js'\nimport {track} from 'mdast-util-to-markdown/lib/util/track.js'\n\nfootnoteReference.peek = footnoteReferencePeek\n\n// To do: next major: rename `context` -> `state`, `safeOptions` to `info`, use\n// utilities on `state`.\n\n/**\n * Create an extension for `mdast-util-from-markdown` to enable GFM footnotes\n * in markdown.\n *\n * @returns {FromMarkdownExtension}\n *   Extension for `mdast-util-from-markdown`.\n */\nexport function gfmFootnoteFromMarkdown() {\n  return {\n    enter: {\n      gfmFootnoteDefinition: enterFootnoteDefinition,\n      gfmFootnoteDefinitionLabelString: enterFootnoteDefinitionLabelString,\n      gfmFootnoteCall: enterFootnoteCall,\n      gfmFootnoteCallString: enterFootnoteCallString\n    },\n    exit: {\n      gfmFootnoteDefinition: exitFootnoteDefinition,\n      gfmFootnoteDefinitionLabelString: exitFootnoteDefinitionLabelString,\n      gfmFootnoteCall: exitFootnoteCall,\n      gfmFootnoteCallString: exitFootnoteCallString\n    }\n  }\n}\n\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM footnotes\n * in markdown.\n *\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown`.\n */\nexport function gfmFootnoteToMarkdown() {\n  return {\n    // This is on by default already.\n    unsafe: [{character: '[', inConstruct: ['phrasing', 'label', 'reference']}],\n    handlers: {footnoteDefinition, footnoteReference}\n  }\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterFootnoteDefinition(token) {\n  this.enter(\n    {type: 'footnoteDefinition', identifier: '', label: '', children: []},\n    token\n  )\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterFootnoteDefinitionLabelString() {\n  this.buffer()\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitFootnoteDefinitionLabelString(token) {\n  const label = this.resume()\n  const node = /** @type {FootnoteDefinition} */ (\n    this.stack[this.stack.length - 1]\n  )\n  node.label = label\n  node.identifier = normalizeIdentifier(\n    this.sliceSerialize(token)\n  ).toLowerCase()\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitFootnoteDefinition(token) {\n  this.exit(token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterFootnoteCall(token) {\n  this.enter({type: 'footnoteReference', identifier: '', label: ''}, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterFootnoteCallString() {\n  this.buffer()\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitFootnoteCallString(token) {\n  const label = this.resume()\n  const node = /** @type {FootnoteDefinition} */ (\n    this.stack[this.stack.length - 1]\n  )\n  node.label = label\n  node.identifier = normalizeIdentifier(\n    this.sliceSerialize(token)\n  ).toLowerCase()\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitFootnoteCall(token) {\n  this.exit(token)\n}\n\n/**\n * @type {ToMarkdownHandle}\n * @param {FootnoteReference} node\n */\nfunction footnoteReference(node, _, context, safeOptions) {\n  const tracker = track(safeOptions)\n  let value = tracker.move('[^')\n  const exit = context.enter('footnoteReference')\n  const subexit = context.enter('reference')\n  value += tracker.move(\n    safe(context, association(node), {\n      ...tracker.current(),\n      before: value,\n      after: ']'\n    })\n  )\n  subexit()\n  exit()\n  value += tracker.move(']')\n  return value\n}\n\n/** @type {ToMarkdownHandle} */\nfunction footnoteReferencePeek() {\n  return '['\n}\n\n/**\n * @type {ToMarkdownHandle}\n * @param {FootnoteDefinition} node\n */\nfunction footnoteDefinition(node, _, context, safeOptions) {\n  const tracker = track(safeOptions)\n  let value = tracker.move('[^')\n  const exit = context.enter('footnoteDefinition')\n  const subexit = context.enter('label')\n  value += tracker.move(\n    safe(context, association(node), {\n      ...tracker.current(),\n      before: value,\n      after: ']'\n    })\n  )\n  subexit()\n  value += tracker.move(\n    ']:' + (node.children && node.children.length > 0 ? ' ' : '')\n  )\n  tracker.shift(4)\n  value += tracker.move(\n    indentLines(containerFlow(node, context, tracker.current()), map)\n  )\n  exit()\n\n  return value\n}\n\n/** @type {Map} */\nfunction map(line, index, blank) {\n  if (index === 0) {\n    return line\n  }\n\n  return (blank ? '' : '    ') + line\n}\n","/**\n * @typedef {import('../types.js').Handle} Handle\n * @typedef {import('../types.js').Info} Info\n * @typedef {import('../types.js').Parent} Parent\n * @typedef {import('../types.js').PhrasingContent} PhrasingContent\n * @typedef {import('../types.js').State} State\n */\n\n/**\n * Serialize the children of a parent that contains phrasing children.\n *\n * These children will be joined flush together.\n *\n * @param {Parent & {children: Array<PhrasingContent>}} parent\n *   Parent of flow nodes.\n * @param {State} state\n *   Info passed around about the current state.\n * @param {Info} info\n *   Info on where we are in the document we are generating.\n * @returns {string}\n *   Serialized children, joined together.\n */\nexport function containerPhrasing(parent, state, info) {\n  const indexStack = state.indexStack\n  const children = parent.children || []\n  /** @type {Array<string>} */\n  const results = []\n  let index = -1\n  let before = info.before\n\n  indexStack.push(-1)\n  let tracker = state.createTracker(info)\n\n  while (++index < children.length) {\n    const child = children[index]\n    /** @type {string} */\n    let after\n\n    indexStack[indexStack.length - 1] = index\n\n    if (index + 1 < children.length) {\n      /** @type {Handle} */\n      // @ts-expect-error: hush, it’s actually a `zwitch`.\n      let handle = state.handle.handlers[children[index + 1].type]\n      /** @type {Handle} */\n      // @ts-expect-error: hush, it’s actually a `zwitch`.\n      if (handle && handle.peek) handle = handle.peek\n      after = handle\n        ? handle(children[index + 1], parent, state, {\n            before: '',\n            after: '',\n            ...tracker.current()\n          }).charAt(0)\n        : ''\n    } else {\n      after = info.after\n    }\n\n    // In some cases, html (text) can be found in phrasing right after an eol.\n    // When we’d serialize that, in most cases that would be seen as html\n    // (flow).\n    // As we can’t escape or so to prevent it from happening, we take a somewhat\n    // reasonable approach: replace that eol with a space.\n    // See: <https://github.com/syntax-tree/mdast-util-to-markdown/issues/15>\n    if (\n      results.length > 0 &&\n      (before === '\\r' || before === '\\n') &&\n      child.type === 'html'\n    ) {\n      results[results.length - 1] = results[results.length - 1].replace(\n        /(\\r?\\n|\\r)$/,\n        ' '\n      )\n      before = ' '\n\n      // To do: does this work to reset tracker?\n      tracker = state.createTracker(info)\n      tracker.move(results.join(''))\n    }\n\n    results.push(\n      tracker.move(\n        state.handle(child, parent, state, {\n          ...tracker.current(),\n          before,\n          after\n        })\n      )\n    )\n\n    before = results[results.length - 1].slice(-1)\n  }\n\n  indexStack.pop()\n\n  return results.join('')\n}\n","/**\n * @typedef {import('mdast').Delete} Delete\n *\n * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n *\n * @typedef {import('mdast-util-to-markdown').ConstructName} ConstructName\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n */\n\nimport {containerPhrasing} from 'mdast-util-to-markdown/lib/util/container-phrasing.js'\nimport {track} from 'mdast-util-to-markdown/lib/util/track.js'\n\n// To do: next major: expose functions.\n// To do: next major: use `state`, state utilities.\n\n/**\n * List of constructs that occur in phrasing (paragraphs, headings), but cannot\n * contain strikethrough.\n * So they sort of cancel each other out.\n * Note: could use a better name.\n *\n * Note: keep in sync with: <https://github.com/syntax-tree/mdast-util-to-markdown/blob/8ce8dbf/lib/unsafe.js#L14>\n *\n * @type {Array<ConstructName>}\n */\nconst constructsWithoutStrikethrough = [\n  'autolink',\n  'destinationLiteral',\n  'destinationRaw',\n  'reference',\n  'titleQuote',\n  'titleApostrophe'\n]\n\nhandleDelete.peek = peekDelete\n\n/**\n * Extension for `mdast-util-from-markdown` to enable GFM strikethrough.\n *\n * @type {FromMarkdownExtension}\n */\nexport const gfmStrikethroughFromMarkdown = {\n  canContainEols: ['delete'],\n  enter: {strikethrough: enterStrikethrough},\n  exit: {strikethrough: exitStrikethrough}\n}\n\n/**\n * Extension for `mdast-util-to-markdown` to enable GFM strikethrough.\n *\n * @type {ToMarkdownExtension}\n */\nexport const gfmStrikethroughToMarkdown = {\n  unsafe: [\n    {\n      character: '~',\n      inConstruct: 'phrasing',\n      notInConstruct: constructsWithoutStrikethrough\n    }\n  ],\n  handlers: {delete: handleDelete}\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterStrikethrough(token) {\n  this.enter({type: 'delete', children: []}, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitStrikethrough(token) {\n  this.exit(token)\n}\n\n/**\n * @type {ToMarkdownHandle}\n * @param {Delete} node\n */\nfunction handleDelete(node, _, context, safeOptions) {\n  const tracker = track(safeOptions)\n  const exit = context.enter('strikethrough')\n  let value = tracker.move('~~')\n  value += containerPhrasing(node, context, {\n    ...tracker.current(),\n    before: value,\n    after: '~'\n  })\n  value += tracker.move('~~')\n  exit()\n  return value\n}\n\n/** @type {ToMarkdownHandle} */\nfunction peekDelete() {\n  return '~'\n}\n","/**\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('../types.js').Parent} Parent\n * @typedef {import('../types.js').State} State\n */\n\nimport {patternCompile} from '../util/pattern-compile.js'\n\ninlineCode.peek = inlineCodePeek\n\n/**\n * @param {InlineCode} node\n * @param {Parent | undefined} _\n * @param {State} state\n * @returns {string}\n */\nexport function inlineCode(node, _, state) {\n  let value = node.value || ''\n  let sequence = '`'\n  let index = -1\n\n  // If there is a single grave accent on its own in the code, use a fence of\n  // two.\n  // If there are two in a row, use one.\n  while (new RegExp('(^|[^`])' + sequence + '([^`]|$)').test(value)) {\n    sequence += '`'\n  }\n\n  // If this is not just spaces or eols (tabs don’t count), and either the\n  // first or last character are a space, eol, or tick, then pad with spaces.\n  if (\n    /[^ \\r\\n]/.test(value) &&\n    ((/^[ \\r\\n]/.test(value) && /[ \\r\\n]$/.test(value)) || /^`|`$/.test(value))\n  ) {\n    value = ' ' + value + ' '\n  }\n\n  // We have a potential problem: certain characters after eols could result in\n  // blocks being seen.\n  // For example, if someone injected the string `'\\n# b'`, then that would\n  // result in an ATX heading.\n  // We can’t escape characters in `inlineCode`, but because eols are\n  // transformed to spaces when going from markdown to HTML anyway, we can swap\n  // them out.\n  while (++index < state.unsafe.length) {\n    const pattern = state.unsafe[index]\n    const expression = patternCompile(pattern)\n    /** @type {RegExpExecArray | null} */\n    let match\n\n    // Only look for `atBreak`s.\n    // Btw: note that `atBreak` patterns will always start the regex at LF or\n    // CR.\n    if (!pattern.atBreak) continue\n\n    while ((match = expression.exec(value))) {\n      let position = match.index\n\n      // Support CRLF (patterns only look for one of the characters).\n      if (\n        value.charCodeAt(position) === 10 /* `\\n` */ &&\n        value.charCodeAt(position - 1) === 13 /* `\\r` */\n      ) {\n        position--\n      }\n\n      value = value.slice(0, position) + ' ' + value.slice(match.index + 1)\n    }\n  }\n\n  return sequence + value + sequence\n}\n\n/**\n * @returns {string}\n */\nfunction inlineCodePeek() {\n  return '`'\n}\n","/**\n * @typedef Options\n *   Configuration (optional).\n * @property {string|null|ReadonlyArray<string|null|undefined>} [align]\n *   One style for all columns, or styles for their respective columns.\n *   Each style is either `'l'` (left), `'r'` (right), or `'c'` (center).\n *   Other values are treated as `''`, which doesn’t place the colon in the\n *   alignment row but does align left.\n *   *Only the lowercased first character is used, so `Right` is fine.*\n * @property {boolean} [padding=true]\n *   Whether to add a space of padding between delimiters and cells.\n *\n *   When `true`, there is padding:\n *\n *   ```markdown\n *   | Alpha | B     |\n *   | ----- | ----- |\n *   | C     | Delta |\n *   ```\n *\n *   When `false`, there is no padding:\n *\n *   ```markdown\n *   |Alpha|B    |\n *   |-----|-----|\n *   |C    |Delta|\n *   ```\n * @property {boolean} [delimiterStart=true]\n *   Whether to begin each row with the delimiter.\n *\n *   > 👉 **Note**: please don’t use this: it could create fragile structures\n *   > that aren’t understandable to some markdown parsers.\n *\n *   When `true`, there are starting delimiters:\n *\n *   ```markdown\n *   | Alpha | B     |\n *   | ----- | ----- |\n *   | C     | Delta |\n *   ```\n *\n *   When `false`, there are no starting delimiters:\n *\n *   ```markdown\n *   Alpha | B     |\n *   ----- | ----- |\n *   C     | Delta |\n *   ```\n * @property {boolean} [delimiterEnd=true]\n *   Whether to end each row with the delimiter.\n *\n *   > 👉 **Note**: please don’t use this: it could create fragile structures\n *   > that aren’t understandable to some markdown parsers.\n *\n *   When `true`, there are ending delimiters:\n *\n *   ```markdown\n *   | Alpha | B     |\n *   | ----- | ----- |\n *   | C     | Delta |\n *   ```\n *\n *   When `false`, there are no ending delimiters:\n *\n *   ```markdown\n *   | Alpha | B\n *   | ----- | -----\n *   | C     | Delta\n *   ```\n * @property {boolean} [alignDelimiters=true]\n *   Whether to align the delimiters.\n *   By default, they are aligned:\n *\n *   ```markdown\n *   | Alpha | B     |\n *   | ----- | ----- |\n *   | C     | Delta |\n *   ```\n *\n *   Pass `false` to make them staggered:\n *\n *   ```markdown\n *   | Alpha | B |\n *   | - | - |\n *   | C | Delta |\n *   ```\n * @property {(value: string) => number} [stringLength]\n *   Function to detect the length of table cell content.\n *   This is used when aligning the delimiters (`|`) between table cells.\n *   Full-width characters and emoji mess up delimiter alignment when viewing\n *   the markdown source.\n *   To fix this, you can pass this function, which receives the cell content\n *   and returns its “visible” size.\n *   Note that what is and isn’t visible depends on where the text is displayed.\n *\n *   Without such a function, the following:\n *\n *   ```js\n *   markdownTable([\n *     ['Alpha', 'Bravo'],\n *     ['中文', 'Charlie'],\n *     ['👩‍❤️‍👩', 'Delta']\n *   ])\n *   ```\n *\n *   Yields:\n *\n *   ```markdown\n *   | Alpha | Bravo |\n *   | - | - |\n *   | 中文 | Charlie |\n *   | 👩‍❤️‍👩 | Delta |\n *   ```\n *\n *   With [`string-width`](https://github.com/sindresorhus/string-width):\n *\n *   ```js\n *   import stringWidth from 'string-width'\n *\n *   markdownTable(\n *     [\n *       ['Alpha', 'Bravo'],\n *       ['中文', 'Charlie'],\n *       ['👩‍❤️‍👩', 'Delta']\n *     ],\n *     {stringLength: stringWidth}\n *   )\n *   ```\n *\n *   Yields:\n *\n *   ```markdown\n *   | Alpha | Bravo   |\n *   | ----- | ------- |\n *   | 中文  | Charlie |\n *   | 👩‍❤️‍👩    | Delta   |\n *   ```\n */\n\n/**\n * @typedef {Options} MarkdownTableOptions\n * @todo\n *   Remove next major.\n */\n\n/**\n * Generate a markdown ([GFM](https://docs.github.com/en/github/writing-on-github/working-with-advanced-formatting/organizing-information-with-tables)) table..\n *\n * @param {ReadonlyArray<ReadonlyArray<string|null|undefined>>} table\n *   Table data (matrix of strings).\n * @param {Options} [options]\n *   Configuration (optional).\n * @returns {string}\n */\nexport function markdownTable(table, options = {}) {\n  const align = (options.align || []).concat()\n  const stringLength = options.stringLength || defaultStringLength\n  /** @type {Array<number>} Character codes as symbols for alignment per column. */\n  const alignments = []\n  /** @type {Array<Array<string>>} Cells per row. */\n  const cellMatrix = []\n  /** @type {Array<Array<number>>} Sizes of each cell per row. */\n  const sizeMatrix = []\n  /** @type {Array<number>} */\n  const longestCellByColumn = []\n  let mostCellsPerRow = 0\n  let rowIndex = -1\n\n  // This is a superfluous loop if we don’t align delimiters, but otherwise we’d\n  // do superfluous work when aligning, so optimize for aligning.\n  while (++rowIndex < table.length) {\n    /** @type {Array<string>} */\n    const row = []\n    /** @type {Array<number>} */\n    const sizes = []\n    let columnIndex = -1\n\n    if (table[rowIndex].length > mostCellsPerRow) {\n      mostCellsPerRow = table[rowIndex].length\n    }\n\n    while (++columnIndex < table[rowIndex].length) {\n      const cell = serialize(table[rowIndex][columnIndex])\n\n      if (options.alignDelimiters !== false) {\n        const size = stringLength(cell)\n        sizes[columnIndex] = size\n\n        if (\n          longestCellByColumn[columnIndex] === undefined ||\n          size > longestCellByColumn[columnIndex]\n        ) {\n          longestCellByColumn[columnIndex] = size\n        }\n      }\n\n      row.push(cell)\n    }\n\n    cellMatrix[rowIndex] = row\n    sizeMatrix[rowIndex] = sizes\n  }\n\n  // Figure out which alignments to use.\n  let columnIndex = -1\n\n  if (typeof align === 'object' && 'length' in align) {\n    while (++columnIndex < mostCellsPerRow) {\n      alignments[columnIndex] = toAlignment(align[columnIndex])\n    }\n  } else {\n    const code = toAlignment(align)\n\n    while (++columnIndex < mostCellsPerRow) {\n      alignments[columnIndex] = code\n    }\n  }\n\n  // Inject the alignment row.\n  columnIndex = -1\n  /** @type {Array<string>} */\n  const row = []\n  /** @type {Array<number>} */\n  const sizes = []\n\n  while (++columnIndex < mostCellsPerRow) {\n    const code = alignments[columnIndex]\n    let before = ''\n    let after = ''\n\n    if (code === 99 /* `c` */) {\n      before = ':'\n      after = ':'\n    } else if (code === 108 /* `l` */) {\n      before = ':'\n    } else if (code === 114 /* `r` */) {\n      after = ':'\n    }\n\n    // There *must* be at least one hyphen-minus in each alignment cell.\n    let size =\n      options.alignDelimiters === false\n        ? 1\n        : Math.max(\n            1,\n            longestCellByColumn[columnIndex] - before.length - after.length\n          )\n\n    const cell = before + '-'.repeat(size) + after\n\n    if (options.alignDelimiters !== false) {\n      size = before.length + size + after.length\n\n      if (size > longestCellByColumn[columnIndex]) {\n        longestCellByColumn[columnIndex] = size\n      }\n\n      sizes[columnIndex] = size\n    }\n\n    row[columnIndex] = cell\n  }\n\n  // Inject the alignment row.\n  cellMatrix.splice(1, 0, row)\n  sizeMatrix.splice(1, 0, sizes)\n\n  rowIndex = -1\n  /** @type {Array<string>} */\n  const lines = []\n\n  while (++rowIndex < cellMatrix.length) {\n    const row = cellMatrix[rowIndex]\n    const sizes = sizeMatrix[rowIndex]\n    columnIndex = -1\n    /** @type {Array<string>} */\n    const line = []\n\n    while (++columnIndex < mostCellsPerRow) {\n      const cell = row[columnIndex] || ''\n      let before = ''\n      let after = ''\n\n      if (options.alignDelimiters !== false) {\n        const size =\n          longestCellByColumn[columnIndex] - (sizes[columnIndex] || 0)\n        const code = alignments[columnIndex]\n\n        if (code === 114 /* `r` */) {\n          before = ' '.repeat(size)\n        } else if (code === 99 /* `c` */) {\n          if (size % 2) {\n            before = ' '.repeat(size / 2 + 0.5)\n            after = ' '.repeat(size / 2 - 0.5)\n          } else {\n            before = ' '.repeat(size / 2)\n            after = before\n          }\n        } else {\n          after = ' '.repeat(size)\n        }\n      }\n\n      if (options.delimiterStart !== false && !columnIndex) {\n        line.push('|')\n      }\n\n      if (\n        options.padding !== false &&\n        // Don’t add the opening space if we’re not aligning and the cell is\n        // empty: there will be a closing space.\n        !(options.alignDelimiters === false && cell === '') &&\n        (options.delimiterStart !== false || columnIndex)\n      ) {\n        line.push(' ')\n      }\n\n      if (options.alignDelimiters !== false) {\n        line.push(before)\n      }\n\n      line.push(cell)\n\n      if (options.alignDelimiters !== false) {\n        line.push(after)\n      }\n\n      if (options.padding !== false) {\n        line.push(' ')\n      }\n\n      if (\n        options.delimiterEnd !== false ||\n        columnIndex !== mostCellsPerRow - 1\n      ) {\n        line.push('|')\n      }\n    }\n\n    lines.push(\n      options.delimiterEnd === false\n        ? line.join('').replace(/ +$/, '')\n        : line.join('')\n    )\n  }\n\n  return lines.join('\\n')\n}\n\n/**\n * @param {string|null|undefined} [value]\n * @returns {string}\n */\nfunction serialize(value) {\n  return value === null || value === undefined ? '' : String(value)\n}\n\n/**\n * @param {string} value\n * @returns {number}\n */\nfunction defaultStringLength(value) {\n  return value.length\n}\n\n/**\n * @param {string|null|undefined} value\n * @returns {number}\n */\nfunction toAlignment(value) {\n  const code = typeof value === 'string' ? value.codePointAt(0) : 0\n\n  return code === 67 /* `C` */ || code === 99 /* `c` */\n    ? 99 /* `c` */\n    : code === 76 /* `L` */ || code === 108 /* `l` */\n    ? 108 /* `l` */\n    : code === 82 /* `R` */ || code === 114 /* `r` */\n    ? 114 /* `r` */\n    : 0\n}\n","/**\n * @typedef {import('mdast').Table} Table\n * @typedef {import('mdast').TableRow} TableRow\n * @typedef {import('mdast').TableCell} TableCell\n * @typedef {import('mdast').InlineCode} InlineCode\n *\n * @typedef {import('markdown-table').MarkdownTableOptions} MarkdownTableOptions\n *\n * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n *\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Context} ToMarkdownContext\n * @typedef {import('mdast-util-to-markdown').SafeOptions} SafeOptions\n */\n\n/**\n * @typedef Options\n *   Configuration.\n * @property {boolean | null | undefined} [tableCellPadding=true]\n *   Whether to add a space of padding between delimiters and cells.\n * @property {boolean | null | undefined} [tablePipeAlign=true]\n *   Whether to align the delimiters.\n * @property {MarkdownTableOptions['stringLength'] | null | undefined} [stringLength]\n *   Function to detect the length of table cell content, used when aligning\n *   the delimiters between cells\n */\n\nimport {containerPhrasing} from 'mdast-util-to-markdown/lib/util/container-phrasing.js'\nimport {inlineCode} from 'mdast-util-to-markdown/lib/handle/inline-code.js'\nimport {markdownTable} from 'markdown-table'\n\n// To do: next major: use `state` and `state` utilities from `mdast-util-to-markdown`.\n// To do: next major: use `defaultHandlers.inlineCode`.\n// To do: next major: expose functions.\n\n/**\n * Extension for `mdast-util-from-markdown` to enable GFM tables.\n *\n * @type {FromMarkdownExtension}\n */\nexport const gfmTableFromMarkdown = {\n  enter: {\n    table: enterTable,\n    tableData: enterCell,\n    tableHeader: enterCell,\n    tableRow: enterRow\n  },\n  exit: {\n    codeText: exitCodeText,\n    table: exitTable,\n    tableData: exit,\n    tableHeader: exit,\n    tableRow: exit\n  }\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterTable(token) {\n  /** @type {Array<'left' | 'right' | 'center' | 'none'>} */\n  // @ts-expect-error: `align` is custom.\n  const align = token._align\n  this.enter(\n    {\n      type: 'table',\n      align: align.map((d) => (d === 'none' ? null : d)),\n      children: []\n    },\n    token\n  )\n  this.setData('inTable', true)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitTable(token) {\n  this.exit(token)\n  this.setData('inTable')\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterRow(token) {\n  this.enter({type: 'tableRow', children: []}, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exit(token) {\n  this.exit(token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterCell(token) {\n  this.enter({type: 'tableCell', children: []}, token)\n}\n\n// Overwrite the default code text data handler to unescape escaped pipes when\n// they are in tables.\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitCodeText(token) {\n  let value = this.resume()\n\n  if (this.getData('inTable')) {\n    value = value.replace(/\\\\([\\\\|])/g, replace)\n  }\n\n  const node = /** @type {InlineCode} */ (this.stack[this.stack.length - 1])\n  node.value = value\n  this.exit(token)\n}\n\n/**\n * @param {string} $0\n * @param {string} $1\n * @returns {string}\n */\nfunction replace($0, $1) {\n  // Pipes work, backslashes don’t (but can’t escape pipes).\n  return $1 === '|' ? $1 : $0\n}\n\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM tables in\n * markdown.\n *\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM tables.\n */\nexport function gfmTableToMarkdown(options) {\n  const settings = options || {}\n  const padding = settings.tableCellPadding\n  const alignDelimiters = settings.tablePipeAlign\n  const stringLength = settings.stringLength\n  const around = padding ? ' ' : '|'\n\n  return {\n    unsafe: [\n      {character: '\\r', inConstruct: 'tableCell'},\n      {character: '\\n', inConstruct: 'tableCell'},\n      // A pipe, when followed by a tab or space (padding), or a dash or colon\n      // (unpadded delimiter row), could result in a table.\n      {atBreak: true, character: '|', after: '[\\t :-]'},\n      // A pipe in a cell must be encoded.\n      {character: '|', inConstruct: 'tableCell'},\n      // A colon must be followed by a dash, in which case it could start a\n      // delimiter row.\n      {atBreak: true, character: ':', after: '-'},\n      // A delimiter row can also start with a dash, when followed by more\n      // dashes, a colon, or a pipe.\n      // This is a stricter version than the built in check for lists, thematic\n      // breaks, and setex heading underlines though:\n      // <https://github.com/syntax-tree/mdast-util-to-markdown/blob/51a2038/lib/unsafe.js#L57>\n      {atBreak: true, character: '-', after: '[:|-]'}\n    ],\n    handlers: {\n      table: handleTable,\n      tableRow: handleTableRow,\n      tableCell: handleTableCell,\n      inlineCode: inlineCodeWithTable\n    }\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {Table} node\n   */\n  function handleTable(node, _, context, safeOptions) {\n    return serializeData(\n      handleTableAsData(node, context, safeOptions),\n      node.align\n    )\n  }\n\n  /**\n   * This function isn’t really used normally, because we handle rows at the\n   * table level.\n   * But, if someone passes in a table row, this ensures we make somewhat sense.\n   *\n   * @type {ToMarkdownHandle}\n   * @param {TableRow} node\n   */\n  function handleTableRow(node, _, context, safeOptions) {\n    const row = handleTableRowAsData(node, context, safeOptions)\n    const value = serializeData([row])\n    // `markdown-table` will always add an align row\n    return value.slice(0, value.indexOf('\\n'))\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {TableCell} node\n   */\n  function handleTableCell(node, _, context, safeOptions) {\n    const exit = context.enter('tableCell')\n    const subexit = context.enter('phrasing')\n    const value = containerPhrasing(node, context, {\n      ...safeOptions,\n      before: around,\n      after: around\n    })\n    subexit()\n    exit()\n    return value\n  }\n\n  /**\n   * @param {Array<Array<string>>} matrix\n   * @param {Array<string | null | undefined> | null | undefined} [align]\n   */\n  function serializeData(matrix, align) {\n    return markdownTable(matrix, {\n      align,\n      // @ts-expect-error: `markdown-table` types should support `null`.\n      alignDelimiters,\n      // @ts-expect-error: `markdown-table` types should support `null`.\n      padding,\n      // @ts-expect-error: `markdown-table` types should support `null`.\n      stringLength\n    })\n  }\n\n  /**\n   * @param {Table} node\n   * @param {ToMarkdownContext} context\n   * @param {SafeOptions} safeOptions\n   */\n  function handleTableAsData(node, context, safeOptions) {\n    const children = node.children\n    let index = -1\n    /** @type {Array<Array<string>>} */\n    const result = []\n    const subexit = context.enter('table')\n\n    while (++index < children.length) {\n      result[index] = handleTableRowAsData(\n        children[index],\n        context,\n        safeOptions\n      )\n    }\n\n    subexit()\n\n    return result\n  }\n\n  /**\n   * @param {TableRow} node\n   * @param {ToMarkdownContext} context\n   * @param {SafeOptions} safeOptions\n   */\n  function handleTableRowAsData(node, context, safeOptions) {\n    const children = node.children\n    let index = -1\n    /** @type {Array<string>} */\n    const result = []\n    const subexit = context.enter('tableRow')\n\n    while (++index < children.length) {\n      // Note: the positional info as used here is incorrect.\n      // Making it correct would be impossible due to aligning cells?\n      // And it would need copy/pasting `markdown-table` into this project.\n      result[index] = handleTableCell(\n        children[index],\n        node,\n        context,\n        safeOptions\n      )\n    }\n\n    subexit()\n\n    return result\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {InlineCode} node\n   */\n  function inlineCodeWithTable(node, parent, context) {\n    let value = inlineCode(node, parent, context)\n\n    if (context.stack.includes('tableCell')) {\n      value = value.replace(/\\|/g, '\\\\$&')\n    }\n\n    return value\n  }\n}\n","/**\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('../types.js').Map} Map\n * @typedef {import('../types.js').Parent} Parent\n * @typedef {import('../types.js').State} State\n * @typedef {import('../types.js').Info} Info\n */\n\nimport {checkBullet} from '../util/check-bullet.js'\nimport {checkListItemIndent} from '../util/check-list-item-indent.js'\n\n/**\n * @param {ListItem} node\n * @param {Parent | undefined} parent\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function listItem(node, parent, state, info) {\n  const listItemIndent = checkListItemIndent(state)\n  let bullet = state.bulletCurrent || checkBullet(state)\n\n  // Add the marker value for ordered lists.\n  if (parent && parent.type === 'list' && parent.ordered) {\n    bullet =\n      (typeof parent.start === 'number' && parent.start > -1\n        ? parent.start\n        : 1) +\n      (state.options.incrementListMarker === false\n        ? 0\n        : parent.children.indexOf(node)) +\n      bullet\n  }\n\n  let size = bullet.length + 1\n\n  if (\n    listItemIndent === 'tab' ||\n    (listItemIndent === 'mixed' &&\n      ((parent && parent.type === 'list' && parent.spread) || node.spread))\n  ) {\n    size = Math.ceil(size / 4) * 4\n  }\n\n  const tracker = state.createTracker(info)\n  tracker.move(bullet + ' '.repeat(size - bullet.length))\n  tracker.shift(size)\n  const exit = state.enter('listItem')\n  const value = state.indentLines(\n    state.containerFlow(node, tracker.current()),\n    map\n  )\n  exit()\n\n  return value\n\n  /** @type {Map} */\n  function map(line, index, blank) {\n    if (index) {\n      return (blank ? '' : ' '.repeat(size)) + line\n    }\n\n    return (blank ? bullet : bullet + ' '.repeat(size - bullet.length)) + line\n  }\n}\n","/**\n * @typedef {import('../types.js').State} State\n * @typedef {import('../types.js').Options} Options\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['listItemIndent'], null | undefined>}\n */\nexport function checkListItemIndent(state) {\n  const style = state.options.listItemIndent || 'tab'\n\n  // To do: remove in a major.\n  // @ts-expect-error: deprecated.\n  if (style === 1 || style === '1') {\n    return 'one'\n  }\n\n  if (style !== 'tab' && style !== 'one' && style !== 'mixed') {\n    throw new Error(\n      'Cannot serialize items with `' +\n        style +\n        '` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`'\n    )\n  }\n\n  return style\n}\n","/**\n * @typedef {import('../types.js').State} State\n * @typedef {import('../types.js').Options} Options\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['bullet'], null | undefined>}\n */\nexport function checkBullet(state) {\n  const marker = state.options.bullet || '*'\n\n  if (marker !== '*' && marker !== '+' && marker !== '-') {\n    throw new Error(\n      'Cannot serialize items with `' +\n        marker +\n        '` for `options.bullet`, expected `*`, `+`, or `-`'\n    )\n  }\n\n  return marker\n}\n","/**\n * @typedef {import('mdast').Content} Content\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('mdast').Parent} Parent\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n */\n\n/**\n * @typedef {Extract<Root | Content, Parent>} Parents\n */\n\nimport {listItem} from 'mdast-util-to-markdown/lib/handle/list-item.js'\nimport {track} from 'mdast-util-to-markdown/lib/util/track.js'\n\n// To do: next major: rename `context` -> `state`, `safeOptions` -> `info`, use\n// `track` from `state`.\n// To do: next major: replace exports with functions.\n// To do: next major: use `defaulthandlers.listItem`.\n\n/**\n * Extension for `mdast-util-from-markdown` to enable GFM task list items.\n *\n * @type {FromMarkdownExtension}\n */\nexport const gfmTaskListItemFromMarkdown = {\n  exit: {\n    taskListCheckValueChecked: exitCheck,\n    taskListCheckValueUnchecked: exitCheck,\n    paragraph: exitParagraphWithTaskListItem\n  }\n}\n\n/**\n * Extension for `mdast-util-to-markdown` to enable GFM task list items.\n *\n * @type {ToMarkdownExtension}\n */\nexport const gfmTaskListItemToMarkdown = {\n  unsafe: [{atBreak: true, character: '-', after: '[:|-]'}],\n  handlers: {listItem: listItemWithTaskListItem}\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitCheck(token) {\n  const node = /** @type {ListItem} */ (this.stack[this.stack.length - 2])\n  // We’re always in a paragraph, in a list item.\n  node.checked = token.type === 'taskListCheckValueChecked'\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitParagraphWithTaskListItem(token) {\n  const parent = /** @type {Parents} */ (this.stack[this.stack.length - 2])\n\n  if (\n    parent &&\n    parent.type === 'listItem' &&\n    typeof parent.checked === 'boolean'\n  ) {\n    const node = /** @type {Paragraph} */ (this.stack[this.stack.length - 1])\n    const head = node.children[0]\n\n    if (head && head.type === 'text') {\n      const siblings = parent.children\n      let index = -1\n      /** @type {Paragraph | undefined} */\n      let firstParaghraph\n\n      while (++index < siblings.length) {\n        const sibling = siblings[index]\n        if (sibling.type === 'paragraph') {\n          firstParaghraph = sibling\n          break\n        }\n      }\n\n      if (firstParaghraph === node) {\n        // Must start with a space or a tab.\n        head.value = head.value.slice(1)\n\n        if (head.value.length === 0) {\n          node.children.shift()\n        } else if (\n          node.position &&\n          head.position &&\n          typeof head.position.start.offset === 'number'\n        ) {\n          head.position.start.column++\n          head.position.start.offset++\n          node.position.start = Object.assign({}, head.position.start)\n        }\n      }\n    }\n  }\n\n  this.exit(token)\n}\n\n/**\n * @type {ToMarkdownHandle}\n * @param {ListItem} node\n */\nfunction listItemWithTaskListItem(node, parent, context, safeOptions) {\n  const head = node.children[0]\n  const checkable =\n    typeof node.checked === 'boolean' && head && head.type === 'paragraph'\n  const checkbox = '[' + (node.checked ? 'x' : ' ') + '] '\n  const tracker = track(safeOptions)\n\n  if (checkable) {\n    tracker.move(checkbox)\n  }\n\n  let value = listItem(node, parent, context, {\n    ...safeOptions,\n    ...tracker.current()\n  })\n\n  if (checkable) {\n    value = value.replace(/^(?:[*+-]|\\d+\\.)([\\r\\n]| {1,3})/, check)\n  }\n\n  return value\n\n  /**\n   * @param {string} $0\n   * @returns {string}\n   */\n  function check($0) {\n    return $0 + checkbox\n  }\n}\n","/**\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n */\n\n/**\n * @typedef {import('mdast-util-gfm-table').Options} Options\n *   Configuration.\n */\n\nimport {\n  gfmAutolinkLiteralFromMarkdown,\n  gfmAutolinkLiteralToMarkdown\n} from 'mdast-util-gfm-autolink-literal'\nimport {\n  gfmFootnoteFromMarkdown,\n  gfmFootnoteToMarkdown\n} from 'mdast-util-gfm-footnote'\nimport {\n  gfmStrikethroughFromMarkdown,\n  gfmStrikethroughToMarkdown\n} from 'mdast-util-gfm-strikethrough'\nimport {gfmTableFromMarkdown, gfmTableToMarkdown} from 'mdast-util-gfm-table'\nimport {\n  gfmTaskListItemFromMarkdown,\n  gfmTaskListItemToMarkdown\n} from 'mdast-util-gfm-task-list-item'\n\n/**\n * Create an extension for `mdast-util-from-markdown` to enable GFM (autolink\n * literals, footnotes, strikethrough, tables, tasklists).\n *\n * @returns {Array<FromMarkdownExtension>}\n *   Extension for `mdast-util-from-markdown` to enable GFM (autolink literals,\n *   footnotes, strikethrough, tables, tasklists).\n */\nexport function gfmFromMarkdown() {\n  return [\n    gfmAutolinkLiteralFromMarkdown,\n    gfmFootnoteFromMarkdown(),\n    gfmStrikethroughFromMarkdown,\n    gfmTableFromMarkdown,\n    gfmTaskListItemFromMarkdown\n  ]\n}\n\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM (autolink\n * literals, footnotes, strikethrough, tables, tasklists).\n *\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM (autolink literals,\n *   footnotes, strikethrough, tables, tasklists).\n */\nexport function gfmToMarkdown(options) {\n  return {\n    extensions: [\n      gfmAutolinkLiteralToMarkdown,\n      gfmFootnoteToMarkdown(),\n      gfmStrikethroughToMarkdown,\n      gfmTableToMarkdown(options),\n      gfmTaskListItemToMarkdown\n    ]\n  }\n}\n","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('micromark-extension-gfm').Options & import('mdast-util-gfm').Options} Options\n */\n\nimport {gfm} from 'micromark-extension-gfm'\nimport {gfmFromMarkdown, gfmToMarkdown} from 'mdast-util-gfm'\n\n/**\n * Plugin to support GFM (autolink literals, footnotes, strikethrough, tables, tasklists).\n *\n * @type {import('unified').Plugin<[Options?]|void[], Root>}\n */\nexport default function remarkGfm(options = {}) {\n  const data = this.data()\n\n  add('micromarkExtensions', gfm(options))\n  add('fromMarkdownExtensions', gfmFromMarkdown())\n  add('toMarkdownExtensions', gfmToMarkdown(options))\n\n  /**\n   * @param {string} field\n   * @param {unknown} value\n   */\n  function add(field, value) {\n    const list = /** @type {unknown[]} */ (\n      // Other extensions\n      /* c8 ignore next 2 */\n      data[field] ? data[field] : (data[field] = [])\n    )\n\n    list.push(value)\n  }\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n */\n\n/**\n * @typedef {Record<string, unknown>} Props\n * @typedef {null | undefined | string | Props | TestFunctionAnything | Array<string | Props | TestFunctionAnything>} Test\n *   Check for an arbitrary node, unaware of TypeScript inferral.\n *\n * @callback TestFunctionAnything\n *   Check if a node passes a test, unaware of TypeScript inferral.\n * @param {unknown} this\n *   The given context.\n * @param {Node} node\n *   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 | void}\n *   Whether this node passes the test.\n */\n\n/**\n * @template {Node} Kind\n *   Node type.\n * @typedef {Kind['type'] | Partial<Kind> | TestFunctionPredicate<Kind> | Array<Kind['type'] | Partial<Kind> | TestFunctionPredicate<Kind>>} PredicateTest\n *   Check for a node that can be inferred by TypeScript.\n */\n\n/**\n * Check if a node passes a certain test.\n *\n * @template {Node} Kind\n *   Node type.\n * @callback TestFunctionPredicate\n *   Complex test function for a node that can be inferred by TypeScript.\n * @param {Node} node\n *   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 {node is Kind}\n *   Whether this node passes the test.\n */\n\n/**\n * @callback AssertAnything\n *   Check that an arbitrary value is a node, unaware of TypeScript inferral.\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\n/**\n * Check if a node is a node and passes a certain node test.\n *\n * @template {Node} Kind\n *   Node type.\n * @callback AssertPredicate\n *   Check that an arbitrary value is a specific node, aware of TypeScript.\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 {node is Kind}\n *   Whether this is a node and passes a test.\n */\n\n/**\n * Check if `node` is a `Node` and whether it passes the given test.\n *\n * @param node\n *   Thing to check, typically `Node`.\n * @param test\n *   A check for a specific node.\n * @param index\n *   The node’s position in its parent.\n * @param parent\n *   The node’s parent.\n * @returns\n *   Whether `node` is a node and passes a test.\n */\nexport const is =\n  /**\n   * @type {(\n   *   (() => false) &\n   *   (<Kind extends Node = Node>(node: unknown, test: PredicateTest<Kind>, index: number, parent: Parent, context?: unknown) => node is Kind) &\n   *   (<Kind extends Node = Node>(node: unknown, test: PredicateTest<Kind>, index?: null | undefined, parent?: null | undefined, context?: unknown) => node is Kind) &\n   *   ((node: unknown, test: Test, index: number, parent: Parent, context?: unknown) => boolean) &\n   *   ((node: unknown, test?: Test, index?: null | undefined, 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 is(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      // @ts-expect-error Looks like a node.\n      return node && node.type && typeof node.type === 'string'\n        ? Boolean(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\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\n *   An assertion.\n */\nexport const convert =\n  /**\n   * @type {(\n   *   (<Kind extends Node>(test: PredicateTest<Kind>) => AssertPredicate<Kind>) &\n   *   ((test?: Test) => AssertAnything)\n   * )}\n   */\n  (\n    /**\n     * @param {Test} [test]\n     * @returns {AssertAnything}\n     */\n    function (test) {\n      if (test === undefined || test === null) {\n        return ok\n      }\n\n      if (typeof test === 'string') {\n        return typeFactory(test)\n      }\n\n      if (typeof test === 'object') {\n        return Array.isArray(test) ? anyFactory(test) : propsFactory(test)\n      }\n\n      if (typeof test === 'function') {\n        return castFactory(test)\n      }\n\n      throw new Error('Expected function, string, or object as test')\n    }\n  )\n\n/**\n * @param {Array<string | Props | TestFunctionAnything>} tests\n * @returns {AssertAnything}\n */\nfunction anyFactory(tests) {\n  /** @type {Array<AssertAnything>} */\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   * @param {Array<unknown>} parameters\n   * @returns {boolean}\n   */\n  function any(...parameters) {\n    let index = -1\n\n    while (++index < checks.length) {\n      if (checks[index].call(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 {AssertAnything}\n */\nfunction propsFactory(check) {\n  return castFactory(all)\n\n  /**\n   * @param {Node} node\n   * @returns {boolean}\n   */\n  function all(node) {\n    /** @type {string} */\n    let key\n\n    for (key in check) {\n      // @ts-expect-error: hush, it sure works as an index.\n      if (node[key] !== check[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 {AssertAnything}\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 {TestFunctionAnything} check\n * @returns {AssertAnything}\n */\nfunction castFactory(check) {\n  return assertion\n\n  /**\n   * @this {unknown}\n   * @param {unknown} node\n   * @param {Array<unknown>} parameters\n   * @returns {boolean}\n   */\n  function assertion(node, ...parameters) {\n    return Boolean(\n      node &&\n        typeof node === 'object' &&\n        'type' in node &&\n        // @ts-expect-error: fine.\n        Boolean(check.call(this, node, ...parameters))\n    )\n  }\n}\n\nfunction ok() {\n  return true\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist-util-is').Test} Test\n */\n\n/**\n * @typedef {boolean | 'skip'} 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 * @template {Node} [Visited=Node]\n *   Visited node type.\n * @template {Parent} [Ancestor=Parent]\n *   Ancestor type.\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<Ancestor>} 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 */\n\n/**\n * @template {Node} [Tree=Node]\n *   Tree type.\n * @template {Test} [Check=string]\n *   Test type.\n * @typedef {Visitor<import('./complex-types.js').Matches<import('./complex-types.js').InclusiveDescendant<Tree>, Check>, Extract<import('./complex-types.js').InclusiveDescendant<Tree>, Parent>>} 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 */\n\nimport {convert} from 'unist-util-is'\nimport {color} from './color.js'\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 * @param tree\n *   Tree to traverse.\n * @param test\n *   `unist-util-is`-compatible test\n * @param visitor\n *   Handle each node.\n * @param reverse\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns\n *   Nothing.\n */\nexport const visitParents =\n  /**\n   * @type {(\n   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: BuildVisitor<Tree, Check>, reverse?: boolean | null | undefined) => void) &\n   *   (<Tree extends Node>(tree: Tree, visitor: BuildVisitor<Tree>, reverse?: boolean | null | undefined) => void)\n   * )}\n   */\n  (\n    /**\n     * @param {Node} tree\n     * @param {Test} test\n     * @param {Visitor<Node>} visitor\n     * @param {boolean | null | undefined} [reverse]\n     * @returns {void}\n     */\n    function (tree, test, visitor, reverse) {\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        test = null\n      }\n\n      const is = convert(test)\n      const step = reverse ? -1 : 1\n\n      factory(tree, undefined, [])()\n\n      /**\n       * @param {Node} node\n       * @param {number | undefined} index\n       * @param {Array<Parent>} parents\n       */\n      function factory(node, index, parents) {\n        /** @type {Record<string, unknown>} */\n        // @ts-expect-error: hush\n        const value = node && typeof node === 'object' ? node : {}\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 {ActionTuple} */\n          let result = []\n          /** @type {ActionTuple} */\n          let subresult\n          /** @type {number} */\n          let offset\n          /** @type {Array<Parent>} */\n          let grandparents\n\n          if (!test || is(node, index, parents[parents.length - 1] || null)) {\n            result = toResult(visitor(node, parents))\n\n            if (result[0] === EXIT) {\n              return result\n            }\n          }\n\n          // @ts-expect-error looks like a parent.\n          if (node.children && result[0] !== SKIP) {\n            // @ts-expect-error looks like a parent.\n            offset = (reverse ? node.children.length : -1) + step\n            // @ts-expect-error looks like a parent.\n            grandparents = parents.concat(node)\n\n            // @ts-expect-error looks like a parent.\n            while (offset > -1 && offset < node.children.length) {\n              // @ts-expect-error looks like a parent.\n              subresult = factory(node.children[offset], 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          return result\n        }\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 {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]\n}\n"],"names":["hasOwn","hasOwnProperty","classNames","classes","i","arguments","length","arg","argType","push","Array","isArray","inner","apply","toString","Object","prototype","includes","key","call","join","module","exports","default","toStr","defineProperty","gOPD","getOwnPropertyDescriptor","arr","isPlainObject","obj","hasOwnConstructor","hasIsPrototypeOf","constructor","setProperty","target","options","name","enumerable","configurable","value","newValue","writable","getProperty","extend","src","copy","copyIsArray","clone","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","re","m","exec","slice","comments","rules","c","comment","pos","charAt","type","declaration","prop","val","ret","property","decl","decls","declarations","isBuffer","u","b","Symbol","for","d","e","f","g","h","k","l","n","p","q","t","v","a","r","$$typeof","ContextConsumer","ContextProvider","Element","ForwardRef","Fragment","Lazy","Memo","Portal","Profiler","StrictMode","Suspense","SuspenseList","isAsyncMode","isConcurrentMode","isContextConsumer","isContextProvider","isElement","isForwardRef","isFragment","isLazy","isMemo","isPortal","isProfiler","isStrictMode","isSuspense","isSuspenseList","isValidElementType","getModuleId","typeOf","parse","require","iterator","output","hasIterator","len","element","document","createElement","decodeNamedCharacterReference","characterReference","innerHTML","char","textContent","charCodeAt","blankLine","tokenize","effects","ok","nok","code","markdownSpace","factorySpace","after","markdownLineEnding","partial","max","limit","Number","POSITIVE_INFINITY","size","enter","prefix","consume","exit","asciiAlpha","regexCheck","asciiAlphanumeric","asciiAtext","asciiControl","asciiDigit","asciiHexDigit","asciiPunctuation","markdownLineEndingOrSpace","unicodePunctuation","unicodeWhitespace","regex","test","String","fromCharCode","splice","list","remove","items","parameters","chunkStart","from","unshift","classifyCharacter","combineExtensions","extensions","all","index","syntaxExtension","extension","hook","left","undefined","right","constructs","existing","before","add","decodeNumericCharacterReference","base","parseInt","characterEscapeOrReference","decodeString","decode","$0","$1","$2","head","hex","normalizeIdentifier","toLowerCase","toUpperCase","resolveAll","events","context","called","resolve","stringifyPosition","point","VFileMessage","place","origin","parts","indexOf","message","stack","fatal","ruleId","file","actual","expected","url","note","path","basename","ext","assertPath","seenNonSlash","firstNonSlashEnd","extIndex","dirname","unmatchedSlash","extname","startPart","startDot","preDotState","joined","segments","normalize","sep","absolute","allowAboveRoot","lastSlashIndex","result","lastSegmentLength","lastSlash","dots","normalizeString","JSON","stringify","proc","cwd","isUrl","fileUrlOrPath","href","urlToPath","URL","protocol","hostname","pathname","third","decodeURIComponent","getPathFromURLPosix","order","VFile","bufferLike","buffer","data","messages","history","stored","map","assertNonEmpty","assertPart","stem","encoding","part","_toArray","arrayWithHoles","iterableToArray","unsupportedIterableToArray","nonIterableRest","bail","getPrototypeOf","toStringTag","wrap","middleware","callback","fnExpectsCallback","done","exception","then","unified","frozen","transformers","fns","pipeline","run","values","middlewareIndex","pop","next","fn","use","middelware","trough","attachers","namespace","freezeIndex","processor","assertUnfrozen","own","Parser","Compiler","freeze","attacher","transformer","settings","addPlugin","addList","addPreset","assign","plugin","plugins","entry","isPlainObj","doc","vfile","assertParser","newable","assertCompiler","assertNode","compile","Promise","executor","reject","tree","runSync","complete","assertDone","process","processSync","destination","keys","asyncName","Boolean","looksLikeAVFile","emptyOptions","one","includeImageAlt","includeHtml","alt","children","previous","contentStart","attempt","parser","contentInitial","lineStart","token","contentType","childFlow","childToken","lineStartOffset","self","continued","item","containerState","continuation","documentContinue","checkNewContainers","_closeFlow","closeFlow","indexBeforeExits","indexBeforeFlow","exitContainers","documentContinued","currentConstruct","concrete","flowStart","interrupt","_gfmTableDynamicInterruptHack","check","containerConstruct","thereIsANewContainer","thereIsNoNewContainer","lazy","now","offset","containerContinue","flow","_tokenizer","flowContinue","writeToChild","eof","stream","sliceStream","defineSkip","write","seen","disable","null","subtokenize","event","lineIndex","otherIndex","otherEvent","subevents","more","jumps","_isInFirstContentOfListItem","subcontent","_container","eventIndex","startPosition","startPositions","tokenizer","childEvents","gaps","current","adjust","breaks","_gfmTasklistFirstContentOfListItem","chunkInside","contentEnd","continuationConstruct","contentContinue","prefixed","tail","sliceSerialize","initial","flowInitial","afterConstruct","resolver","createResolver","string","initializeFactory","text","field","notText","atBreak","resolveAllLineSuffixes","extraResolver","chunks","bufferIndex","tabs","chunk","_index","_bufferIndex","createTokenizer","initialize","columnStart","resolveAllConstructs","accountForPotentialSkip","fields","constructFactory","construct","info","addResult","onsuccessfulcheck","expandTabs","atTab","serializeChunks","main","state","view","startIndex","startBufferIndex","endIndex","endBufferIndex","shift","sliceChunks","chunkIndex","go","_","restore","onreturn","returnState","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","def","handleMapOfConstructs","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","store","create","resolveTo","thematicBreak","marker","sequence","initialSize","kind","atMarker","inside","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","furtherBlankLines","notInCurrentItem","indentConstruct","blockQuote","open","contBefore","factoryDestination","literalType","literalMarkerType","rawType","stringType","balance","enclosedBefore","raw","enclosed","enclosedEscape","rawEscape","factoryLabel","markerType","labelInside","labelEscape","factoryTitle","begin","escape","factoryWhitespace","definition","identifier","labelAfter","markerAfter","destinationBefore","destinationAfter","titleBefore","afterWhitespace","defined","beforeMarker","titleAfter","titleAfterOptionalWhitespace","codeIndented","afterPrefix","furtherStart","headingAtx","sequenceOpen","sequenceFurther","setextUnderline","paragraph","heading","htmlBlockNames","htmlRawNames","htmlFlow","closingTag","markerB","declarationOpen","tagCloseStart","continuationDeclarationInside","tagName","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","numeric","characterEscape","lineEnding","labelEnd","labelStart","_balanced","_inactive","labelEndNok","resourceConstruct","labelEndOk","referenceFullConstruct","referenceNotFull","referenceCollapsedConstruct","close","media","group","label","insideSpan","resourceBefore","resourceOpen","resourceEnd","resourceDestinationAfter","resourceDestinationMissing","resourceBetween","resourceTitleAfter","referenceFullAfter","referenceFullMissing","referenceCollapsedOpen","labelStartImage","attention","attentionMarkers","_open","_close","openingSequence","closingSequence","nextEvents","movePoint","autolink","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","htmlText","instruction","tagOpen","commentEnd","commentClose","lineEndingBefore","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","lineEndingAfter","lineEndingAfterPrefix","labelStartLink","hardBreakEscape","codeText","between","tailExitIndex","headEnterIndex","resolveText","search","fromMarkdown","config","transforms","canContainEols","opener","link","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","codeFlow","codeFencedFenceInfo","codeFencedFenceMeta","codeTextData","codeFlowValue","definitionDestinationString","definitionLabelString","definitionTitleString","emphasis","hardBreak","hardBreakTrailing","html","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","onexitcodefenced","codeFencedFence","onexitcodefencedfence","onexitcodefencedfenceinfo","onexitcodefencedfencemeta","onexitcodeindented","onexitcodetext","onexitdefinitiondestinationstring","onexitdefinitionlabelstring","onexitdefinitiontitlestring","onexithardbreak","onexithtmlflow","onexithtmltext","onexitimage","onexitlabel","labelText","onexitlabeltext","onexitlineending","onexitlink","onexitreferencestring","onexitresourcedestinationstring","onexitresourcetitlestring","resource","onexitresource","onexitsetextheading","setextHeadingLineSequence","onexitsetextheadinglinesequence","setextHeadingText","onexitsetextheadingtext","configure","mdastExtensions","tokenStack","resume","setData","getData","listStack","prepareList","handler","defaultOnError","firstBlankLineIndex","containerBalance","listSpread","tailIndex","tailEvent","_spread","and","errorHandler","onExitError","lang","title","depth","referenceType","ancestor","fragment","ordered","spread","checked","compiler","postprocess","defaultConstructs","atCarriageReturn","endPosition","lastIndex","Math","ceil","preprocess","combined","remarkParse","normalizeUri","skip","encodeURIComponent","visit","visitor","reverse","visitParents","parents","parent","pointStart","pointEnd","clean","footnoteReference","counter","id","safeId","footnoteOrder","footnoteCounts","reuseCounter","properties","clobberPrefix","dataFootnoteRef","ariaDescribedBy","patch","sup","applyData","revert","subtype","suffix","contents","listItemLoose","trimLines","last","trimLine","codePointAt","handlers","blockquote","break","className","delete","footnote","footnoteById","no","dangerous","imageReference","inlineCode","linkReference","results","loose","listLoose","disabled","child","root","table","rows","firstRow","tableContent","body","tableCell","tableRow","siblings","align","cellIndex","cells","cell","alignValue","toml","ignore","yaml","footnoteDefinition","createState","allowDangerousHtml","footnoteLabel","footnoteLabelTagName","footnoteLabelProperties","footnoteBackLabel","unknownHandler","passThrough","cache","definitions","augment","hName","hProperties","hChildren","ctx","generated","props","to","defaultUnknownHandler","nodes","toHast","foot","listItems","referenceIndex","backReferences","backReference","dataFootnoteBackref","ariaLabel","tailTail","dataFootnotes","footer","bridge","mutate","Schema","normal","space","merge","Info","attribute","boolean","booleanish","overloadedBoolean","number","commaSeparated","spaceSeparated","commaOrSpaceSeparated","mustUseProperty","powers","increment","checks","types","DefinedInfo","mask","mark","transform","attributes","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","ariaDetails","ariaDisabled","ariaDropEffect","ariaErrorMessage","ariaExpanded","ariaFlowTo","ariaGrabbed","ariaHasPopup","ariaHidden","ariaInvalid","ariaKeyShortcuts","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","acceptcharset","classname","htmlfor","httpequiv","abbr","accept","acceptCharset","accessKey","action","allow","allowFullScreen","allowPaymentRequest","allowUserMedia","as","async","autoCapitalize","autoComplete","autoFocus","autoPlay","blocking","capture","charSet","cite","cols","colSpan","contentEditable","controls","controlsList","coords","crossOrigin","dateTime","decoding","defer","dir","dirName","download","draggable","encType","enterKeyHint","fetchPriority","form","formAction","formEncType","formMethod","formNoValidate","formTarget","headers","height","hidden","high","hrefLang","htmlFor","httpEquiv","imageSizes","imageSrcSet","inert","inputMode","integrity","is","isMap","itemId","itemProp","itemRef","itemScope","itemType","language","loading","loop","low","manifest","maxLength","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","optimum","pattern","ping","placeholder","playsInline","popover","popoverTarget","popoverTargetAction","poster","preload","readOnly","referrerPolicy","rel","required","reversed","rowSpan","sandbox","scope","scoped","seamless","selected","shadowRootDelegatesFocus","shadowRootMode","shape","sizes","slot","span","spellCheck","srcDoc","srcLang","srcSet","step","tabIndex","translate","typeMustMatch","useMap","width","aLink","archive","axis","background","bgColor","border","borderColor","bottomMargin","cellPadding","cellSpacing","charOff","classId","clear","codeBase","codeType","color","compact","declare","face","frame","frameBorder","hSpace","leftMargin","longDesc","lowSrc","marginHeight","marginWidth","noResize","noHref","noShade","noWrap","object","profile","prompt","rev","rightMargin","scheme","scrolling","standby","summary","topMargin","valueType","version","vAlign","vLink","vSpace","allowTransparency","autoCorrect","autoSave","disablePictureInPicture","disableRemotePlayback","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","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","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","fx","fy","g1","g2","glyphRef","gradientTransform","gradientUnits","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","opacity","operator","orient","orientation","overflow","overlay","pathLength","patternContentUnits","patternTransform","patternUnits","phase","pitch","points","pointsAtX","pointsAtY","pointsAtZ","preserveAlpha","preserveAspectRatio","primitiveUnits","propagate","radius","refX","refY","repeatCount","repeatDur","requiredExtensions","requiredFeatures","requiredFonts","requiredFormats","restart","rotate","rx","ry","scale","seed","side","slope","snapshotTime","specularConstant","specularExponent","spreadMethod","spacing","startOffset","stdDeviation","stemh","stemv","stitchTiles","stroke","surfaceScale","syncBehavior","syncBehaviorDefault","syncMaster","syncTolerance","syncToleranceDefault","systemLanguage","tableValues","targetX","targetY","textLength","transformBehavior","u1","u2","unicode","viewBox","viewTarget","visibility","widths","x","x1","x2","xChannelSelector","y","y1","y2","yChannelSelector","z","zoomAndPan","htmlBase","svgBase","rehypeFilter","allowedElements","disallowedElements","allowElement","parent_","unwrapDisallowed","protocols","thing","valid","dash","cap","kebab","camelcase","hastToReact","tableElements","Set","childrenToReact","childIndex","toReact","has","skipHtml","parentSchema","schema","addProperty","listDepth","component","components","basic","React","ReactIs","linkTarget","transformLinkUri","inline","level","transformImageUri","input","getInputElement","getElementsBeforeCount","textAlign","isHeader","sourcePos","rawSourcePos","sourcePosition","includeElementIndex","siblingCount","count","Type","rest","dashes","find","padRight","padLeft","commas","styleReplacer","parseStyle","deprecated","renderers","astPlugins","escapeHtml","allowNode","allowedTypes","disallowedTypes","includeNodeIndex","ReactMarkdown","deprecation","console","warn","remarkPlugins","remarkRehype","remarkRehypeOptions","rehypePlugins","hastNode","defaultProps","uri","first","colon","propTypes","PropTypes","wwwPrefix","wwwPrefixInside","wwwPrefixAfter","domain","underscoreInLastSegment","underscoreInLastLastSegment","domainInside","trail","domainAfter","domainAtPunctuation","sizeClose","pathInside","pathAtPunctuation","trailCharRefStart","trailBracketAfter","trailCharRefInside","emailDomainDotTrail","wwwAutolink","previousWww","previousUnbalanced","wwwAfter","protocolAutolink","previousProtocol","fromCodePoint","protocolPrefixInside","protocolSlashesInside","afterProtocol","protocolAfter","emailAutolink","dot","gfmAtext","previousEmail","atext","emailDomain","emailDomainAfter","emailDomainDot","gfmAutolinkLiteral","_gfmAutolinkLiteralWalkedInto","indent","gfmFootnote","tokenizeDefinitionStart","tokenizeDefinitionContinuation","gfmFootnoteDefinitionEnd","tokenizeGfmFootnoteCall","tokenizePotentialGfmFootnoteCall","resolveToPotentialGfmFootnoteCall","gfmFootnotes","replacement","callStart","callData","callEscape","labelAtMarker","whitespaceAfter","gfmStrikethrough","single","singleTilde","strikethrough","EditMap","editMap","at","addImpl","sort","vecs","gfmTableAlign","inDelimiterRow","alignIndex","gfmTable","sizeB","bodyRowStart","headRowBefore","headRowBreak","headRowStart","headDelimiterStart","headRowData","headRowEscape","headDelimiterBefore","headDelimiterValueBefore","headDelimiterCellBefore","headDelimiterNok","headDelimiterLeftAlignmentAfter","headDelimiterCellAfter","headDelimiterFiller","headDelimiterRightAlignmentAfter","bodyRowBreak","bodyRowData","bodyRowEscape","currentTable","currentBody","currentCell","inFirstCellAwaitingPipe","rowKind","lastCell","afterHeadAwaitingFirstBodyRow","lastTableEnd","flushTableEnd","flushCell","_align","range","rowEnd","previousCell","groupName","getPoint","relatedStart","relatedEnd","valueToken","tableBody","exits","related","tasklistCheck","spaceThenNonSpace","gfmTaskListItem","gfm","ccount","character","findAndReplace","RegExp","ignored","convert","pairs","toExpression","toFunction","toPairs","pairIndex","grandparent","change","matchObject","global","inConstruct","notInConstruct","gfmAutolinkLiteralFromMarkdown","findUrl","findEmail","literalAutolink","literalAutolinkEmail","enterLiteralAutolinkValue","literalAutolinkHttp","literalAutolinkWww","gfmAutolinkLiteralToMarkdown","unsafe","split","isCorrectDomain","trailExec","closingParenIndex","openingParens","closingParens","splitUrl","email","association","repeat","eol","patternCompile","_compiled","patternInScope","listInScope","none","safe","positions","infos","expression","numerical","escapeBackslashes","encode","whole","track","lineShift","move","enterFootnoteDefinition","enterFootnoteDefinitionLabelString","exitFootnoteDefinitionLabelString","exitFootnoteDefinition","enterFootnoteCall","enterFootnoteCallString","exitFootnoteCallString","exitFootnoteCall","safeOptions","tracker","subexit","indentLines","indexStack","createTracker","handle","bulletLastUsed","containerFlow","blank","containerPhrasing","peek","handleDelete","gfmStrikethroughFromMarkdown","gfmStrikethroughToMarkdown","serialize","defaultStringLength","toAlignment","gfmTableFromMarkdown","tableData","enterCell","tableHeader","gfmTableToMarkdown","padding","tableCellPadding","alignDelimiters","tablePipeAlign","stringLength","around","serializeData","handleTableRowAsData","handleTableAsData","handleTableCell","matrix","concat","alignments","cellMatrix","sizeMatrix","longestCellByColumn","mostCellsPerRow","rowIndex","row","columnIndex","delimiterStart","delimiterEnd","markdownTable","listItemIndent","checkListItemIndent","bullet","bulletCurrent","checkBullet","incrementListMarker","gfmTaskListItemFromMarkdown","taskListCheckValueChecked","exitCheck","taskListCheckValueUnchecked","firstParaghraph","sibling","gfmTaskListItemToMarkdown","checkable","checkbox","gfmFromMarkdown","gfmFootnoteDefinition","gfmFootnoteDefinitionLabelString","gfmFootnoteCall","gfmFootnoteCallString","gfmToMarkdown","remarkGfm","castFactory","typeFactory","anyFactory","propsFactory","tests","factory","subresult","grandparents","toResult"],"sourceRoot":""}