{"version":3,"file":"static/js/7486_bac816b0634ca90246c2.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-string@3.2.0/node_modules/mdast-util-to-string/lib/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-from-markdown@1.3.1/node_modules/mdast-util-from-markdown/lib/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-find-and-replace@2.2.2/node_modules/mdast-util-find-and-replace/lib/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-gfm-autolink-literal@1.0.3/node_modules/mdast-util-gfm-autolink-literal/lib/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-markdown@1.5.0/node_modules/mdast-util-to-markdown/lib/util/association.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-markdown@1.5.0/node_modules/mdast-util-to-markdown/lib/util/container-flow.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-markdown@1.5.0/node_modules/mdast-util-to-markdown/lib/util/indent-lines.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-markdown@1.5.0/node_modules/mdast-util-to-markdown/lib/util/pattern-compile.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-markdown@1.5.0/node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-markdown@1.5.0/node_modules/mdast-util-to-markdown/lib/util/safe.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-markdown@1.5.0/node_modules/mdast-util-to-markdown/lib/util/track.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-gfm-footnote@1.0.2/node_modules/mdast-util-gfm-footnote/lib/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-markdown@1.5.0/node_modules/mdast-util-to-markdown/lib/util/container-phrasing.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-gfm-strikethrough@1.0.3/node_modules/mdast-util-gfm-strikethrough/lib/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-markdown@1.5.0/node_modules/mdast-util-to-markdown/lib/handle/inline-code.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-gfm-table@1.0.7/node_modules/mdast-util-gfm-table/lib/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-markdown@1.5.0/node_modules/mdast-util-to-markdown/lib/handle/list-item.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-markdown@1.5.0/node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-markdown@1.5.0/node_modules/mdast-util-to-markdown/lib/util/check-bullet.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-gfm-task-list-item@1.0.2/node_modules/mdast-util-gfm-task-list-item/lib/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-gfm@2.0.2/node_modules/mdast-util-gfm/lib/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-definitions@5.1.2/node_modules/mdast-util-definitions/lib/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/revert.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/list-item.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/blockquote.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/break.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/code.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/delete.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/emphasis.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/footnote.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/heading.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/html.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/image-reference.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/image.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/inline-code.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/link-reference.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/link.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/list.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/paragraph.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/root.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/strong.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/table.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/table-cell.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/table-row.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/text.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/state.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/mdast-util-to-hast@12.3.0/node_modules/mdast-util-to-hast/lib/footer.js"],"sourcesContent":["/**\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').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('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","/**\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 {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('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","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 {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"],"names":["emptyOptions","one","value","includeImageAlt","includeHtml","Boolean","node","type","alt","children","Array","isArray","values","result","index","length","join","own","hasOwnProperty","fromMarkdown","encoding","options","undefined","config","transforms","canContainEols","enter","autolink","opener","link","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","heading","blockQuote","characterEscape","characterReference","codeFenced","codeFlow","codeFencedFenceInfo","buffer","codeFencedFenceMeta","codeIndented","codeText","codeTextData","data","codeFlowValue","definition","definitionDestinationString","definitionLabelString","definitionTitleString","emphasis","hardBreakEscape","hardBreak","hardBreakTrailing","htmlFlow","html","htmlFlowData","htmlText","htmlTextData","image","label","listItem","listItemValue","onenterlistitemvalue","listOrdered","list","onenterlistordered","listUnordered","paragraph","reference","onenterreference","referenceString","resourceDestinationString","resourceTitleString","setextHeading","strong","thematicBreak","exit","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","lineEnding","onexitlineending","onexitlink","onexitreferencestring","onexitresourcedestinationstring","onexitresourcetitlestring","resource","onexitresource","onexitsetextheading","setextHeadingLineSequence","onexitsetextheadinglinesequence","setextHeadingText","onexitsetextheadingtext","configure","mdastExtensions","compile","events","tree","context","stack","tokenStack","resume","setData","getData","listStack","push","prepareList","pop","handler","call","Object","assign","sliceSerialize","tail","defaultOnError","position","start","point","line","column","offset","end","lineIndex","firstBlankLineIndex","atMarker","containerBalance","listSpread","event","tailIndex","tailEvent","_spread","splice","key","create","and","open","token","this","errorHandler","close","onExitError","Error","settings","Number","parseInt","lang","meta","replace","identifier","toLowerCase","title","url","depth","charCodeAt","text","includes","referenceType","string","ancestor","fragment","ordered","spread","checked","compiler","postprocess","parse","document","write","preprocess","d","combined","extensions","extension","right","left","findAndReplace","find","schema","RegExp","ignored","ignore","pairs","TypeError","toExpression","toFunction","toPairs","pairIndex","visitor","parents","grandparent","parent","indexOf","change","nodes","lastIndex","match","exec","matchObject","input","slice","global","inConstruct","notInConstruct","gfmAutolinkLiteralFromMarkdown","findUrl","findEmail","literalAutolink","literalAutolinkEmail","enterLiteralAutolinkValue","literalAutolinkHttp","literalAutolinkWww","gfmAutolinkLiteralToMarkdown","unsafe","character","before","after","_","protocol","domain","path","prefix","previous","test","parts","split","isCorrectDomain","trailExec","trail","closingParenIndex","openingParens","ccount","closingParens","splitUrl","atext","email","code","association","between","state","repeat","eol","patternCompile","pattern","_compiled","atBreak","patternInScope","listInScope","none","safe","positions","infos","expression","sort","numerical","escapeBackslashes","charAt","encode","toString","toUpperCase","a","b","results","whole","track","now","lineShift","move","chunks","current","shift","enterFootnoteDefinition","enterFootnoteDefinitionLabelString","exitFootnoteDefinitionLabelString","exitFootnoteDefinition","enterFootnoteCall","enterFootnoteCallString","exitFootnoteCallString","exitFootnoteCall","footnoteReference","safeOptions","tracker","subexit","footnoteDefinition","map","indentLines","info","indexStack","createTracker","child","handle","bulletLastUsed","containerFlow","blank","containerPhrasing","handlers","peek","handleDelete","gfmStrikethroughFromMarkdown","strikethrough","gfmStrikethroughToMarkdown","delete","inlineCode","sequence","gfmTableFromMarkdown","table","align","_align","tableData","enterCell","tableHeader","tableRow","$0","$1","gfmTableToMarkdown","padding","tableCellPadding","alignDelimiters","tablePipeAlign","stringLength","around","serializeData","handleTableRowAsData","handleTableAsData","tableCell","handleTableCell","matrix","listItemIndent","style","checkListItemIndent","bullet","bulletCurrent","marker","checkBullet","incrementListMarker","size","Math","ceil","gfmTaskListItemFromMarkdown","taskListCheckValueChecked","exitCheck","taskListCheckValueUnchecked","head","siblings","firstParaghraph","sibling","gfmTaskListItemToMarkdown","checkable","checkbox","gfmFromMarkdown","gfmFootnoteDefinition","gfmFootnoteDefinitionLabelString","gfmFootnoteCall","gfmFootnoteCallString","gfmToMarkdown","clean","String","id","safeId","footnoteOrder","counter","footnoteCounts","reuseCounter","tagName","properties","href","clobberPrefix","dataFootnoteRef","ariaDescribedBy","patch","sup","applyData","revert","subtype","suffix","contents","all","unshift","listItemLoose","blockquote","wrap","break","className","footnote","footnoteById","no","dangerous","imageReference","def","src","linkReference","loose","listLoose","disabled","root","rows","firstRow","tableContent","body","cellIndex","cells","cell","alignValue","toml","yaml","createState","allowDangerousHtml","footnoteLabel","footnoteLabelTagName","footnoteLabelProperties","footnoteBackLabel","unknownHandler","passThrough","cache","definitions","augment","hName","hProperties","hChildren","ctx","props","from","to","defaultUnknownHandler","toHast","foot","listItems","content","referenceIndex","backReferences","backReference","dataFootnoteBackref","ariaLabel","tailTail","dataFootnotes","JSON","stringify","footer"],"sourceRoot":""}