{"version":3,"file":"js/2717-b4e0b644dcdf431f464c.js","mappings":"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","sources":["webpack://artfully-walls/./node_modules/mdast-util-to-string/lib/index.js","webpack://artfully-walls/./node_modules/mdast-util-from-markdown/lib/index.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/footer.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/revert.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/list-item.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/index.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/blockquote.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/break.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/code.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/delete.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/emphasis.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/heading.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/html.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/image-reference.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/image.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/inline-code.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/link-reference.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/link.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/list.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/paragraph.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/root.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/strong.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/table.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/table-cell.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/table-row.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/text.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/state.js","webpack://artfully-walls/./node_modules/mdast-util-to-hast/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('mdast').Nodes} Nodes\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [includeImageAlt=true]\n *   Whether to use `alt` for `image`s (default: `true`).\n * @property {boolean | null | undefined} [includeHtml=true]\n *   Whether to use `value` of HTML (default: `true`).\n */\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Get the text content of a node or list of nodes.\n *\n * Prefers the node’s plain-text fields, otherwise serializes its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} [value]\n *   Thing to serialize, typically `Node`.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {string}\n *   Serialized `value`.\n */\nexport function toString(value, options) {\n  const settings = options || emptyOptions\n  const includeImageAlt =\n    typeof settings.includeImageAlt === 'boolean'\n      ? settings.includeImageAlt\n      : true\n  const includeHtml =\n    typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true\n\n  return one(value, includeImageAlt, includeHtml)\n}\n\n/**\n * One node or several nodes.\n *\n * @param {unknown} value\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized node.\n */\nfunction one(value, includeImageAlt, includeHtml) {\n  if (node(value)) {\n    if ('value' in value) {\n      return value.type === 'html' && !includeHtml ? '' : value.value\n    }\n\n    if (includeImageAlt && 'alt' in value && value.alt) {\n      return value.alt\n    }\n\n    if ('children' in value) {\n      return all(value.children, includeImageAlt, includeHtml)\n    }\n  }\n\n  if (Array.isArray(value)) {\n    return all(value, includeImageAlt, includeHtml)\n  }\n\n  return ''\n}\n\n/**\n * Serialize a list of nodes.\n *\n * @param {Array<unknown>} values\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized nodes.\n */\nfunction all(values, includeImageAlt, includeHtml) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n\n  while (++index < values.length) {\n    result[index] = one(values[index], includeImageAlt, includeHtml)\n  }\n\n  return result.join('')\n}\n\n/**\n * Check if `value` looks like a node.\n *\n * @param {unknown} value\n *   Thing.\n * @returns {value is Nodes}\n *   Whether `value` is a node.\n */\nfunction node(value) {\n  return Boolean(value && typeof value === 'object')\n}\n","/**\n * @import {\n *   Break,\n *   Blockquote,\n *   Code,\n *   Definition,\n *   Emphasis,\n *   Heading,\n *   Html,\n *   Image,\n *   InlineCode,\n *   Link,\n *   ListItem,\n *   List,\n *   Nodes,\n *   Paragraph,\n *   PhrasingContent,\n *   ReferenceType,\n *   Root,\n *   Strong,\n *   Text,\n *   ThematicBreak\n * } from 'mdast'\n * @import {\n *   Encoding,\n *   Event,\n *   Token,\n *   Value\n * } from 'micromark-util-types'\n * @import {Point} from 'unist'\n * @import {\n *   CompileContext,\n *   CompileData,\n *   Config,\n *   Extension,\n *   Handle,\n *   OnEnterError,\n *   Options\n * } from './types.js'\n */\n\nimport { toString } from 'mdast-util-to-string';\nimport { parse, postprocess, preprocess } from 'micromark';\nimport { decodeNumericCharacterReference } from 'micromark-util-decode-numeric-character-reference';\nimport { decodeString } from 'micromark-util-decode-string';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nimport { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { stringifyPosition } from 'unist-util-stringify-position';\nconst own = {}.hasOwnProperty;\n\n/**\n * Turn markdown into a syntax tree.\n *\n * @overload\n * @param {Value} value\n * @param {Encoding | null | undefined} [encoding]\n * @param {Options | null | undefined} [options]\n * @returns {Root}\n *\n * @overload\n * @param {Value} value\n * @param {Options | null | undefined} [options]\n * @returns {Root}\n *\n * @param {Value} value\n *   Markdown to parse.\n * @param {Encoding | Options | null | undefined} [encoding]\n *   Character encoding for when `value` is `Buffer`.\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {Root}\n *   mdast tree.\n */\nexport function fromMarkdown(value, encoding, options) {\n  if (typeof encoding !== 'string') {\n    options = encoding;\n    encoding = undefined;\n  }\n  return compiler(options)(postprocess(parse(options).document().write(preprocess()(value, encoding, true))));\n}\n\n/**\n * Note this compiler only understand complete buffering, not streaming.\n *\n * @param {Options | null | undefined} [options]\n */\nfunction compiler(options) {\n  /** @type {Config} */\n  const config = {\n    transforms: [],\n    canContainEols: ['emphasis', 'fragment', 'heading', 'paragraph', 'strong'],\n    enter: {\n      autolink: opener(link),\n      autolinkProtocol: onenterdata,\n      autolinkEmail: onenterdata,\n      atxHeading: opener(heading),\n      blockQuote: opener(blockQuote),\n      characterEscape: onenterdata,\n      characterReference: onenterdata,\n      codeFenced: opener(codeFlow),\n      codeFencedFenceInfo: buffer,\n      codeFencedFenceMeta: buffer,\n      codeIndented: opener(codeFlow, buffer),\n      codeText: opener(codeText, buffer),\n      codeTextData: onenterdata,\n      data: onenterdata,\n      codeFlowValue: onenterdata,\n      definition: opener(definition),\n      definitionDestinationString: buffer,\n      definitionLabelString: buffer,\n      definitionTitleString: buffer,\n      emphasis: opener(emphasis),\n      hardBreakEscape: opener(hardBreak),\n      hardBreakTrailing: opener(hardBreak),\n      htmlFlow: opener(html, buffer),\n      htmlFlowData: onenterdata,\n      htmlText: opener(html, buffer),\n      htmlTextData: onenterdata,\n      image: opener(image),\n      label: buffer,\n      link: opener(link),\n      listItem: opener(listItem),\n      listItemValue: onenterlistitemvalue,\n      listOrdered: opener(list, onenterlistordered),\n      listUnordered: opener(list),\n      paragraph: opener(paragraph),\n      reference: onenterreference,\n      referenceString: buffer,\n      resourceDestinationString: buffer,\n      resourceTitleString: buffer,\n      setextHeading: opener(heading),\n      strong: opener(strong),\n      thematicBreak: opener(thematicBreak)\n    },\n    exit: {\n      atxHeading: closer(),\n      atxHeadingSequence: onexitatxheadingsequence,\n      autolink: closer(),\n      autolinkEmail: onexitautolinkemail,\n      autolinkProtocol: onexitautolinkprotocol,\n      blockQuote: closer(),\n      characterEscapeValue: onexitdata,\n      characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,\n      characterReferenceMarkerNumeric: onexitcharacterreferencemarker,\n      characterReferenceValue: onexitcharacterreferencevalue,\n      characterReference: onexitcharacterreference,\n      codeFenced: closer(onexitcodefenced),\n      codeFencedFence: onexitcodefencedfence,\n      codeFencedFenceInfo: onexitcodefencedfenceinfo,\n      codeFencedFenceMeta: onexitcodefencedfencemeta,\n      codeFlowValue: onexitdata,\n      codeIndented: closer(onexitcodeindented),\n      codeText: closer(onexitcodetext),\n      codeTextData: onexitdata,\n      data: onexitdata,\n      definition: closer(),\n      definitionDestinationString: onexitdefinitiondestinationstring,\n      definitionLabelString: onexitdefinitionlabelstring,\n      definitionTitleString: onexitdefinitiontitlestring,\n      emphasis: closer(),\n      hardBreakEscape: closer(onexithardbreak),\n      hardBreakTrailing: closer(onexithardbreak),\n      htmlFlow: closer(onexithtmlflow),\n      htmlFlowData: onexitdata,\n      htmlText: closer(onexithtmltext),\n      htmlTextData: onexitdata,\n      image: closer(onexitimage),\n      label: onexitlabel,\n      labelText: onexitlabeltext,\n      lineEnding: onexitlineending,\n      link: closer(onexitlink),\n      listItem: closer(),\n      listOrdered: closer(),\n      listUnordered: closer(),\n      paragraph: closer(),\n      referenceString: onexitreferencestring,\n      resourceDestinationString: onexitresourcedestinationstring,\n      resourceTitleString: onexitresourcetitlestring,\n      resource: onexitresource,\n      setextHeading: closer(onexitsetextheading),\n      setextHeadingLineSequence: onexitsetextheadinglinesequence,\n      setextHeadingText: onexitsetextheadingtext,\n      strong: closer(),\n      thematicBreak: closer()\n    }\n  };\n  configure(config, (options || {}).mdastExtensions || []);\n\n  /** @type {CompileData} */\n  const data = {};\n  return compile;\n\n  /**\n   * Turn micromark events into an mdast tree.\n   *\n   * @param {Array<Event>} events\n   *   Events.\n   * @returns {Root}\n   *   mdast tree.\n   */\n  function compile(events) {\n    /** @type {Root} */\n    let tree = {\n      type: 'root',\n      children: []\n    };\n    /** @type {Omit<CompileContext, 'sliceSerialize'>} */\n    const context = {\n      stack: [tree],\n      tokenStack: [],\n      config,\n      enter,\n      exit,\n      buffer,\n      resume,\n      data\n    };\n    /** @type {Array<number>} */\n    const listStack = [];\n    let index = -1;\n    while (++index < events.length) {\n      // We preprocess lists to add `listItem` tokens, and to infer whether\n      // items the list itself are spread out.\n      if (events[index][1].type === \"listOrdered\" || events[index][1].type === \"listUnordered\") {\n        if (events[index][0] === 'enter') {\n          listStack.push(index);\n        } else {\n          const tail = listStack.pop();\n          index = prepareList(events, tail, index);\n        }\n      }\n    }\n    index = -1;\n    while (++index < events.length) {\n      const handler = config[events[index][0]];\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(Object.assign({\n          sliceSerialize: events[index][2].sliceSerialize\n        }, context), events[index][1]);\n      }\n    }\n\n    // Handle tokens still being open.\n    if (context.tokenStack.length > 0) {\n      const tail = context.tokenStack[context.tokenStack.length - 1];\n      const handler = tail[1] || defaultOnError;\n      handler.call(context, undefined, tail[0]);\n    }\n\n    // Figure out `root` position.\n    tree.position = {\n      start: point(events.length > 0 ? events[0][1].start : {\n        line: 1,\n        column: 1,\n        offset: 0\n      }),\n      end: point(events.length > 0 ? events[events.length - 2][1].end : {\n        line: 1,\n        column: 1,\n        offset: 0\n      })\n    };\n\n    // Call transforms.\n    index = -1;\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree;\n    }\n    return tree;\n  }\n\n  /**\n   * @param {Array<Event>} events\n   * @param {number} start\n   * @param {number} length\n   * @returns {number}\n   */\n  function prepareList(events, start, length) {\n    let index = start - 1;\n    let containerBalance = -1;\n    let listSpread = false;\n    /** @type {Token | undefined} */\n    let listItem;\n    /** @type {number | undefined} */\n    let lineIndex;\n    /** @type {number | undefined} */\n    let firstBlankLineIndex;\n    /** @type {boolean | undefined} */\n    let atMarker;\n    while (++index <= length) {\n      const event = events[index];\n      switch (event[1].type) {\n        case \"listUnordered\":\n        case \"listOrdered\":\n        case \"blockQuote\":\n          {\n            if (event[0] === 'enter') {\n              containerBalance++;\n            } else {\n              containerBalance--;\n            }\n            atMarker = undefined;\n            break;\n          }\n        case \"lineEndingBlank\":\n          {\n            if (event[0] === 'enter') {\n              if (listItem && !atMarker && !containerBalance && !firstBlankLineIndex) {\n                firstBlankLineIndex = index;\n              }\n              atMarker = undefined;\n            }\n            break;\n          }\n        case \"linePrefix\":\n        case \"listItemValue\":\n        case \"listItemMarker\":\n        case \"listItemPrefix\":\n        case \"listItemPrefixWhitespace\":\n          {\n            // Empty.\n\n            break;\n          }\n        default:\n          {\n            atMarker = undefined;\n          }\n      }\n      if (!containerBalance && event[0] === 'enter' && event[1].type === \"listItemPrefix\" || containerBalance === -1 && event[0] === 'exit' && (event[1].type === \"listUnordered\" || event[1].type === \"listOrdered\")) {\n        if (listItem) {\n          let tailIndex = index;\n          lineIndex = undefined;\n          while (tailIndex--) {\n            const tailEvent = events[tailIndex];\n            if (tailEvent[1].type === \"lineEnding\" || tailEvent[1].type === \"lineEndingBlank\") {\n              if (tailEvent[0] === 'exit') continue;\n              if (lineIndex) {\n                events[lineIndex][1].type = \"lineEndingBlank\";\n                listSpread = true;\n              }\n              tailEvent[1].type = \"lineEnding\";\n              lineIndex = tailIndex;\n            } else if (tailEvent[1].type === \"linePrefix\" || tailEvent[1].type === \"blockQuotePrefix\" || tailEvent[1].type === \"blockQuotePrefixWhitespace\" || tailEvent[1].type === \"blockQuoteMarker\" || tailEvent[1].type === \"listItemIndent\") {\n              // Empty\n            } else {\n              break;\n            }\n          }\n          if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) {\n            listItem._spread = true;\n          }\n\n          // Fix position.\n          listItem.end = Object.assign({}, lineIndex ? events[lineIndex][1].start : event[1].end);\n          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]]);\n          index++;\n          length++;\n        }\n\n        // Create a new list item.\n        if (event[1].type === \"listItemPrefix\") {\n          /** @type {Token} */\n          const item = {\n            type: 'listItem',\n            _spread: false,\n            start: Object.assign({}, event[1].start),\n            // @ts-expect-error: we’ll add `end` in a second.\n            end: undefined\n          };\n          listItem = item;\n          events.splice(index, 0, ['enter', item, event[2]]);\n          index++;\n          length++;\n          firstBlankLineIndex = undefined;\n          atMarker = true;\n        }\n      }\n    }\n    events[start][1]._spread = listSpread;\n    return length;\n  }\n\n  /**\n   * Create an opener handle.\n   *\n   * @param {(token: Token) => Nodes} create\n   *   Create a node.\n   * @param {Handle | undefined} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function opener(create, and) {\n    return open;\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {undefined}\n     */\n    function open(token) {\n      enter.call(this, create(token), token);\n      if (and) and.call(this, token);\n    }\n  }\n\n  /**\n   * @type {CompileContext['buffer']}\n   */\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    });\n  }\n\n  /**\n   * @type {CompileContext['enter']}\n   */\n  function enter(node, token, errorHandler) {\n    const parent = this.stack[this.stack.length - 1];\n    /** @type {Array<Nodes>} */\n    const siblings = parent.children;\n    siblings.push(node);\n    this.stack.push(node);\n    this.tokenStack.push([token, errorHandler || undefined]);\n    node.position = {\n      start: point(token.start),\n      // @ts-expect-error: `end` will be patched later.\n      end: undefined\n    };\n  }\n\n  /**\n   * Create a closer handle.\n   *\n   * @param {Handle | undefined} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function closer(and) {\n    return close;\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {undefined}\n     */\n    function close(token) {\n      if (and) and.call(this, token);\n      exit.call(this, token);\n    }\n  }\n\n  /**\n   * @type {CompileContext['exit']}\n   */\n  function exit(token, onExitError) {\n    const node = this.stack.pop();\n    const open = this.tokenStack.pop();\n    if (!open) {\n      throw new Error('Cannot close `' + token.type + '` (' + stringifyPosition({\n        start: token.start,\n        end: token.end\n      }) + '): it’s not open');\n    } else if (open[0].type !== token.type) {\n      if (onExitError) {\n        onExitError.call(this, token, open[0]);\n      } else {\n        const handler = open[1] || defaultOnError;\n        handler.call(this, token, open[0]);\n      }\n    }\n    node.position.end = point(token.end);\n  }\n\n  /**\n   * @type {CompileContext['resume']}\n   */\n  function resume() {\n    return toString(this.stack.pop());\n  }\n\n  //\n  // Handlers.\n  //\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistordered() {\n    this.data.expectingFirstListItemValue = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistitemvalue(token) {\n    if (this.data.expectingFirstListItemValue) {\n      const ancestor = this.stack[this.stack.length - 2];\n      ancestor.start = Number.parseInt(this.sliceSerialize(token), 10);\n      this.data.expectingFirstListItemValue = undefined;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfenceinfo() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.lang = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfencemeta() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.meta = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (this.data.flowCodeInside) return;\n    this.buffer();\n    this.data.flowCodeInside = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefenced() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '');\n    this.data.flowCodeInside = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodeindented() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data.replace(/(\\r?\\n|\\r)$/g, '');\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitionlabelstring(token) {\n    const label = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.label = label;\n    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiontitlestring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.title = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiondestinationstring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.url = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitatxheadingsequence(token) {\n    const node = this.stack[this.stack.length - 1];\n    if (!node.depth) {\n      const depth = this.sliceSerialize(token).length;\n      node.depth = depth;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadingtext() {\n    this.data.setextHeadingSlurpLineEnding = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadinglinesequence(token) {\n    const node = this.stack[this.stack.length - 1];\n    node.depth = this.sliceSerialize(token).codePointAt(0) === 61 ? 1 : 2;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheading() {\n    this.data.setextHeadingSlurpLineEnding = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterdata(token) {\n    const node = this.stack[this.stack.length - 1];\n    /** @type {Array<Nodes>} */\n    const siblings = node.children;\n    let tail = siblings[siblings.length - 1];\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text();\n      tail.position = {\n        start: point(token.start),\n        // @ts-expect-error: we’ll add `end` later.\n        end: undefined\n      };\n      siblings.push(tail);\n    }\n    this.stack.push(tail);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitdata(token) {\n    const tail = this.stack.pop();\n    tail.value += this.sliceSerialize(token);\n    tail.position.end = point(token.end);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlineending(token) {\n    const context = this.stack[this.stack.length - 1];\n    // If we’re at a hard break, include the line ending in there.\n    if (this.data.atHardBreak) {\n      const tail = context.children[context.children.length - 1];\n      tail.position.end = point(token.end);\n      this.data.atHardBreak = undefined;\n      return;\n    }\n    if (!this.data.setextHeadingSlurpLineEnding && config.canContainEols.includes(context.type)) {\n      onenterdata.call(this, token);\n      onexitdata.call(this, token);\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithardbreak() {\n    this.data.atHardBreak = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmlflow() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmltext() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcodetext() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlink() {\n    const node = this.stack[this.stack.length - 1];\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n\n    // To do: clean.\n    if (this.data.inReference) {\n      /** @type {ReferenceType} */\n      const referenceType = this.data.referenceType || 'shortcut';\n      node.type += 'Reference';\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType;\n      // @ts-expect-error: mutate.\n      delete node.url;\n      delete node.title;\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier;\n      // @ts-expect-error: mutate.\n      delete node.label;\n    }\n    this.data.referenceType = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitimage() {\n    const node = this.stack[this.stack.length - 1];\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n\n    // To do: clean.\n    if (this.data.inReference) {\n      /** @type {ReferenceType} */\n      const referenceType = this.data.referenceType || 'shortcut';\n      node.type += 'Reference';\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType;\n      // @ts-expect-error: mutate.\n      delete node.url;\n      delete node.title;\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier;\n      // @ts-expect-error: mutate.\n      delete node.label;\n    }\n    this.data.referenceType = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabeltext(token) {\n    const string = this.sliceSerialize(token);\n    const ancestor = this.stack[this.stack.length - 2];\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    ancestor.label = decodeString(string);\n    // @ts-expect-error: same as above.\n    ancestor.identifier = normalizeIdentifier(string).toLowerCase();\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabel() {\n    const fragment = this.stack[this.stack.length - 1];\n    const value = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    // Assume a reference.\n    this.data.inReference = true;\n    if (node.type === 'link') {\n      /** @type {Array<PhrasingContent>} */\n      const children = fragment.children;\n      node.children = children;\n    } else {\n      node.alt = value;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcedestinationstring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.url = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcetitlestring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.title = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresource() {\n    this.data.inReference = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterreference() {\n    this.data.referenceType = 'collapsed';\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitreferencestring(token) {\n    const label = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    node.label = label;\n    // @ts-expect-error: same as above.\n    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n    this.data.referenceType = 'full';\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcharacterreferencemarker(token) {\n    this.data.characterReferenceType = token.type;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcharacterreferencevalue(token) {\n    const data = this.sliceSerialize(token);\n    const type = this.data.characterReferenceType;\n    /** @type {string} */\n    let value;\n    if (type) {\n      value = decodeNumericCharacterReference(data, type === \"characterReferenceMarkerNumeric\" ? 10 : 16);\n      this.data.characterReferenceType = undefined;\n    } else {\n      const result = decodeNamedCharacterReference(data);\n      value = result;\n    }\n    const tail = this.stack[this.stack.length - 1];\n    tail.value += value;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcharacterreference(token) {\n    const tail = this.stack.pop();\n    tail.position.end = point(token.end);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token);\n    const node = this.stack[this.stack.length - 1];\n    node.url = this.sliceSerialize(token);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token);\n    const node = this.stack[this.stack.length - 1];\n    node.url = 'mailto:' + this.sliceSerialize(token);\n  }\n\n  //\n  // Creaters.\n  //\n\n  /** @returns {Blockquote} */\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    };\n  }\n\n  /** @returns {Code} */\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    };\n  }\n\n  /** @returns {InlineCode} */\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    };\n  }\n\n  /** @returns {Definition} */\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    };\n  }\n\n  /** @returns {Emphasis} */\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    };\n  }\n\n  /** @returns {Heading} */\n  function heading() {\n    return {\n      type: 'heading',\n      // @ts-expect-error `depth` will be set later.\n      depth: 0,\n      children: []\n    };\n  }\n\n  /** @returns {Break} */\n  function hardBreak() {\n    return {\n      type: 'break'\n    };\n  }\n\n  /** @returns {Html} */\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    };\n  }\n\n  /** @returns {Image} */\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    };\n  }\n\n  /** @returns {Link} */\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      children: []\n    };\n  }\n\n  /**\n   * @param {Token} token\n   * @returns {List}\n   */\n  function list(token) {\n    return {\n      type: 'list',\n      ordered: token.type === 'listOrdered',\n      start: null,\n      spread: token._spread,\n      children: []\n    };\n  }\n\n  /**\n   * @param {Token} token\n   * @returns {ListItem}\n   */\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      spread: token._spread,\n      checked: null,\n      children: []\n    };\n  }\n\n  /** @returns {Paragraph} */\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    };\n  }\n\n  /** @returns {Strong} */\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    };\n  }\n\n  /** @returns {Text} */\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    };\n  }\n\n  /** @returns {ThematicBreak} */\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    };\n  }\n}\n\n/**\n * Copy a point-like value.\n *\n * @param {Point} d\n *   Point-like value.\n * @returns {Point}\n *   unist point.\n */\nfunction point(d) {\n  return {\n    line: d.line,\n    column: d.column,\n    offset: d.offset\n  };\n}\n\n/**\n * @param {Config} combined\n * @param {Array<Array<Extension> | Extension>} extensions\n * @returns {undefined}\n */\nfunction configure(combined, extensions) {\n  let index = -1;\n  while (++index < extensions.length) {\n    const value = extensions[index];\n    if (Array.isArray(value)) {\n      configure(combined, value);\n    } else {\n      extension(combined, value);\n    }\n  }\n}\n\n/**\n * @param {Config} combined\n * @param {Extension} extension\n * @returns {undefined}\n */\nfunction extension(combined, extension) {\n  /** @type {keyof Extension} */\n  let key;\n  for (key in extension) {\n    if (own.call(extension, key)) {\n      switch (key) {\n        case 'canContainEols':\n          {\n            const right = extension[key];\n            if (right) {\n              combined[key].push(...right);\n            }\n            break;\n          }\n        case 'transforms':\n          {\n            const right = extension[key];\n            if (right) {\n              combined[key].push(...right);\n            }\n            break;\n          }\n        case 'enter':\n        case 'exit':\n          {\n            const right = extension[key];\n            if (right) {\n              Object.assign(combined[key], right);\n            }\n            break;\n          }\n        // No default\n      }\n    }\n  }\n}\n\n/** @type {OnEnterError} */\nfunction defaultOnError(left, right) {\n  if (left) {\n    throw new Error('Cannot close `' + left.type + '` (' + stringifyPosition({\n      start: left.start,\n      end: left.end\n    }) + '): a different token (`' + right.type + '`, ' + stringifyPosition({\n      start: right.start,\n      end: right.end\n    }) + ') is open');\n  } else {\n    throw new Error('Cannot close document, a token (`' + right.type + '`, ' + stringifyPosition({\n      start: right.start,\n      end: right.end\n    }) + ') is still open');\n  }\n}","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n *\n * @typedef {import('./state.js').State} State\n */\n\n/**\n * @callback FootnoteBackContentTemplate\n *   Generate content for the backreference dynamically.\n *\n *   For the following markdown:\n *\n *   ```markdown\n *   Alpha[^micromark], bravo[^micromark], and charlie[^remark].\n *\n *   [^remark]: things about remark\n *   [^micromark]: things about micromark\n *   ```\n *\n *   This function will be called with:\n *\n *   *  `0` and `0` for the backreference from `things about micromark` to\n *      `alpha`, as it is the first used definition, and the first call to it\n *   *  `0` and `1` for the backreference from `things about micromark` to\n *      `bravo`, as it is the first used definition, and the second call to it\n *   *  `1` and `0` for the backreference from `things about remark` to\n *      `charlie`, as it is the second used definition\n * @param {number} referenceIndex\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {Array<ElementContent> | ElementContent | string}\n *   Content for the backreference when linking back from definitions to their\n *   reference.\n *\n * @callback FootnoteBackLabelTemplate\n *   Generate a back label dynamically.\n *\n *   For the following markdown:\n *\n *   ```markdown\n *   Alpha[^micromark], bravo[^micromark], and charlie[^remark].\n *\n *   [^remark]: things about remark\n *   [^micromark]: things about micromark\n *   ```\n *\n *   This function will be called with:\n *\n *   *  `0` and `0` for the backreference from `things about micromark` to\n *      `alpha`, as it is the first used definition, and the first call to it\n *   *  `0` and `1` for the backreference from `things about micromark` to\n *      `bravo`, as it is the first used definition, and the second call to it\n *   *  `1` and `0` for the backreference from `things about remark` to\n *      `charlie`, as it is the second used definition\n * @param {number} referenceIndex\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {string}\n *   Back label to use when linking back from definitions to their reference.\n */\n\nimport structuredClone from '@ungap/structured-clone'\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Generate the default content that GitHub uses on backreferences.\n *\n * @param {number} _\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {Array<ElementContent>}\n *   Content.\n */\nexport function defaultFootnoteBackContent(_, rereferenceIndex) {\n  /** @type {Array<ElementContent>} */\n  const result = [{type: 'text', value: '↩'}]\n\n  if (rereferenceIndex > 1) {\n    result.push({\n      type: 'element',\n      tagName: 'sup',\n      properties: {},\n      children: [{type: 'text', value: String(rereferenceIndex)}]\n    })\n  }\n\n  return result\n}\n\n/**\n * Generate the default label that GitHub uses on backreferences.\n *\n * @param {number} referenceIndex\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {string}\n *   Label.\n */\nexport function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {\n  return (\n    'Back to reference ' +\n    (referenceIndex + 1) +\n    (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')\n  )\n}\n\n/**\n * Generate a hast footer for called footnote definitions.\n *\n * @param {State} state\n *   Info passed around.\n * @returns {Element | undefined}\n *   `section` element or `undefined`.\n */\n// eslint-disable-next-line complexity\nexport function footer(state) {\n  const clobberPrefix =\n    typeof state.options.clobberPrefix === 'string'\n      ? state.options.clobberPrefix\n      : 'user-content-'\n  const footnoteBackContent =\n    state.options.footnoteBackContent || defaultFootnoteBackContent\n  const footnoteBackLabel =\n    state.options.footnoteBackLabel || defaultFootnoteBackLabel\n  const footnoteLabel = state.options.footnoteLabel || 'Footnotes'\n  const footnoteLabelTagName = state.options.footnoteLabelTagName || 'h2'\n  const footnoteLabelProperties = state.options.footnoteLabelProperties || {\n    className: ['sr-only']\n  }\n  /** @type {Array<ElementContent>} */\n  const listItems = []\n  let referenceIndex = -1\n\n  while (++referenceIndex < state.footnoteOrder.length) {\n    const definition = state.footnoteById.get(\n      state.footnoteOrder[referenceIndex]\n    )\n\n    if (!definition) {\n      continue\n    }\n\n    const content = state.all(definition)\n    const id = String(definition.identifier).toUpperCase()\n    const safeId = normalizeUri(id.toLowerCase())\n    let rereferenceIndex = 0\n    /** @type {Array<ElementContent>} */\n    const backReferences = []\n    const counts = state.footnoteCounts.get(id)\n\n    // eslint-disable-next-line no-unmodified-loop-condition\n    while (counts !== undefined && ++rereferenceIndex <= counts) {\n      if (backReferences.length > 0) {\n        backReferences.push({type: 'text', value: ' '})\n      }\n\n      let children =\n        typeof footnoteBackContent === 'string'\n          ? footnoteBackContent\n          : footnoteBackContent(referenceIndex, rereferenceIndex)\n\n      if (typeof children === 'string') {\n        children = {type: 'text', value: children}\n      }\n\n      backReferences.push({\n        type: 'element',\n        tagName: 'a',\n        properties: {\n          href:\n            '#' +\n            clobberPrefix +\n            'fnref-' +\n            safeId +\n            (rereferenceIndex > 1 ? '-' + rereferenceIndex : ''),\n          dataFootnoteBackref: '',\n          ariaLabel:\n            typeof footnoteBackLabel === 'string'\n              ? footnoteBackLabel\n              : footnoteBackLabel(referenceIndex, rereferenceIndex),\n          className: ['data-footnote-backref']\n        },\n        children: Array.isArray(children) ? children : [children]\n      })\n    }\n\n    const tail = content[content.length - 1]\n\n    if (tail && tail.type === 'element' && tail.tagName === 'p') {\n      const tailTail = tail.children[tail.children.length - 1]\n      if (tailTail && tailTail.type === 'text') {\n        tailTail.value += ' '\n      } else {\n        tail.children.push({type: 'text', value: ' '})\n      }\n\n      tail.children.push(...backReferences)\n    } else {\n      content.push(...backReferences)\n    }\n\n    /** @type {Element} */\n    const listItem = {\n      type: 'element',\n      tagName: 'li',\n      properties: {id: clobberPrefix + 'fn-' + safeId},\n      children: state.wrap(content, true)\n    }\n\n    state.patch(definition, listItem)\n\n    listItems.push(listItem)\n  }\n\n  if (listItems.length === 0) {\n    return\n  }\n\n  return {\n    type: 'element',\n    tagName: 'section',\n    properties: {dataFootnotes: true, className: ['footnotes']},\n    children: [\n      {\n        type: 'element',\n        tagName: footnoteLabelTagName,\n        properties: {\n          ...structuredClone(footnoteLabelProperties),\n          id: 'footnote-label'\n        },\n        children: [{type: 'text', value: footnoteLabel}]\n      },\n      {type: 'text', value: '\\n'},\n      {\n        type: 'element',\n        tagName: 'ol',\n        properties: {},\n        children: state.wrap(listItems, true)\n      },\n      {type: 'text', value: '\\n'}\n    ]\n  }\n}\n","/**\n * @typedef {import('hast').ElementContent} ElementContent\n *\n * @typedef {import('mdast').Nodes} Nodes\n * @typedef {import('mdast').Reference} Reference\n *\n * @typedef {import('./state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Return the content of a reference without definition as plain text.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Extract<Nodes, Reference>} node\n *   Reference node (image, link).\n * @returns {Array<ElementContent>}\n *   hast content.\n */\nexport function revert(state, node) {\n  const subtype = node.referenceType\n  let suffix = ']'\n\n  if (subtype === 'collapsed') {\n    suffix += '[]'\n  } else if (subtype === 'full') {\n    suffix += '[' + (node.label || node.identifier) + ']'\n  }\n\n  if (node.type === 'imageReference') {\n    return [{type: 'text', value: '![' + node.alt + suffix}]\n  }\n\n  const contents = state.all(node)\n  const head = contents[0]\n\n  if (head && head.type === 'text') {\n    head.value = '[' + head.value\n  } else {\n    contents.unshift({type: 'text', value: '['})\n  }\n\n  const tail = contents[contents.length - 1]\n\n  if (tail && tail.type === 'text') {\n    tail.value += suffix\n  } else {\n    contents.push({type: 'text', value: suffix})\n  }\n\n  return contents\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `listItem` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ListItem} node\n *   mdast node.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @returns {Element}\n *   hast node.\n */\nexport function listItem(state, node, parent) {\n  const results = state.all(node)\n  const loose = parent ? listLoose(parent) : listItemLoose(node)\n  /** @type {Properties} */\n  const properties = {}\n  /** @type {Array<ElementContent>} */\n  const children = []\n\n  if (typeof node.checked === 'boolean') {\n    const head = results[0]\n    /** @type {Element} */\n    let paragraph\n\n    if (head && head.type === 'element' && head.tagName === 'p') {\n      paragraph = head\n    } else {\n      paragraph = {type: 'element', tagName: 'p', properties: {}, children: []}\n      results.unshift(paragraph)\n    }\n\n    if (paragraph.children.length > 0) {\n      paragraph.children.unshift({type: 'text', value: ' '})\n    }\n\n    paragraph.children.unshift({\n      type: 'element',\n      tagName: 'input',\n      properties: {type: 'checkbox', checked: node.checked, disabled: true},\n      children: []\n    })\n\n    // According to github-markdown-css, this class hides bullet.\n    // See: <https://github.com/sindresorhus/github-markdown-css>.\n    properties.className = ['task-list-item']\n  }\n\n  let index = -1\n\n  while (++index < results.length) {\n    const child = results[index]\n\n    // Add eols before nodes, except if this is a loose, first paragraph.\n    if (\n      loose ||\n      index !== 0 ||\n      child.type !== 'element' ||\n      child.tagName !== 'p'\n    ) {\n      children.push({type: 'text', value: '\\n'})\n    }\n\n    if (child.type === 'element' && child.tagName === 'p' && !loose) {\n      children.push(...child.children)\n    } else {\n      children.push(child)\n    }\n  }\n\n  const tail = results[results.length - 1]\n\n  // Add a final eol.\n  if (tail && (loose || tail.type !== 'element' || tail.tagName !== 'p')) {\n    children.push({type: 'text', value: '\\n'})\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'li', properties, children}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n\n/**\n * @param {Parents} node\n * @return {Boolean}\n */\nfunction listLoose(node) {\n  let loose = false\n  if (node.type === 'list') {\n    loose = node.spread || false\n    const children = node.children\n    let index = -1\n\n    while (!loose && ++index < children.length) {\n      loose = listItemLoose(children[index])\n    }\n  }\n\n  return loose\n}\n\n/**\n * @param {ListItem} node\n * @return {Boolean}\n */\nfunction listItemLoose(node) {\n  const spread = node.spread\n\n  return spread === null || spread === undefined\n    ? node.children.length > 1\n    : spread\n}\n","import {blockquote} from './blockquote.js'\nimport {hardBreak} from './break.js'\nimport {code} from './code.js'\nimport {strikethrough} from './delete.js'\nimport {emphasis} from './emphasis.js'\nimport {footnoteReference} from './footnote-reference.js'\nimport {heading} from './heading.js'\nimport {html} from './html.js'\nimport {imageReference} from './image-reference.js'\nimport {image} from './image.js'\nimport {inlineCode} from './inline-code.js'\nimport {linkReference} from './link-reference.js'\nimport {link} from './link.js'\nimport {listItem} from './list-item.js'\nimport {list} from './list.js'\nimport {paragraph} from './paragraph.js'\nimport {root} from './root.js'\nimport {strong} from './strong.js'\nimport {table} from './table.js'\nimport {tableRow} from './table-row.js'\nimport {tableCell} from './table-cell.js'\nimport {text} from './text.js'\nimport {thematicBreak} from './thematic-break.js'\n\n/**\n * Default handlers for nodes.\n *\n * @satisfies {import('../state.js').Handlers}\n */\nexport const handlers = {\n  blockquote,\n  break: hardBreak,\n  code,\n  delete: strikethrough,\n  emphasis,\n  footnoteReference,\n  heading,\n  html,\n  imageReference,\n  image,\n  inlineCode,\n  linkReference,\n  link,\n  listItem,\n  list,\n  paragraph,\n  // @ts-expect-error: root is different, but hard to type.\n  root,\n  strong,\n  table,\n  tableCell,\n  tableRow,\n  text,\n  thematicBreak,\n  toml: ignore,\n  yaml: ignore,\n  definition: ignore,\n  footnoteDefinition: ignore\n}\n\n// Return nothing for nodes that are ignored.\nfunction ignore() {\n  return undefined\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `blockquote` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Blockquote} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function blockquote(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'blockquote',\n    properties: {},\n    children: state.wrap(state.all(node), true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('mdast').Break} Break\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `break` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Break} node\n *   mdast node.\n * @returns {Array<Element | Text>}\n *   hast element content.\n */\nexport function hardBreak(state, node) {\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'br', properties: {}, children: []}\n  state.patch(node, result)\n  return [state.applyData(node, result), {type: 'text', value: '\\n'}]\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Code} Code\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `code` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Code} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function code(state, node) {\n  const value = node.value ? node.value + '\\n' : ''\n  /** @type {Properties} */\n  const properties = {}\n\n  if (node.lang) {\n    properties.className = ['language-' + node.lang]\n  }\n\n  // Create `<code>`.\n  /** @type {Element} */\n  let result = {\n    type: 'element',\n    tagName: 'code',\n    properties,\n    children: [{type: 'text', value}]\n  }\n\n  if (node.meta) {\n    result.data = {meta: node.meta}\n  }\n\n  state.patch(node, result)\n  result = state.applyData(node, result)\n\n  // Create `<pre>`.\n  result = {type: 'element', tagName: 'pre', properties: {}, children: [result]}\n  state.patch(node, result)\n  return result\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Delete} Delete\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `delete` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Delete} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function strikethrough(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'del',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `emphasis` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Emphasis} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function emphasis(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'em',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').FootnoteReference} FootnoteReference\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `footnoteReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {FootnoteReference} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function footnoteReference(state, node) {\n  const clobberPrefix =\n    typeof state.options.clobberPrefix === 'string'\n      ? state.options.clobberPrefix\n      : 'user-content-'\n  const id = String(node.identifier).toUpperCase()\n  const safeId = normalizeUri(id.toLowerCase())\n  const index = state.footnoteOrder.indexOf(id)\n  /** @type {number} */\n  let counter\n\n  let reuseCounter = state.footnoteCounts.get(id)\n\n  if (reuseCounter === undefined) {\n    reuseCounter = 0\n    state.footnoteOrder.push(id)\n    counter = state.footnoteOrder.length\n  } else {\n    counter = index + 1\n  }\n\n  reuseCounter += 1\n  state.footnoteCounts.set(id, reuseCounter)\n\n  /** @type {Element} */\n  const link = {\n    type: 'element',\n    tagName: 'a',\n    properties: {\n      href: '#' + clobberPrefix + 'fn-' + safeId,\n      id:\n        clobberPrefix +\n        'fnref-' +\n        safeId +\n        (reuseCounter > 1 ? '-' + reuseCounter : ''),\n      dataFootnoteRef: true,\n      ariaDescribedBy: ['footnote-label']\n    },\n    children: [{type: 'text', value: String(counter)}]\n  }\n  state.patch(node, link)\n\n  /** @type {Element} */\n  const sup = {\n    type: 'element',\n    tagName: 'sup',\n    properties: {},\n    children: [link]\n  }\n  state.patch(node, sup)\n  return state.applyData(node, sup)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `heading` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Heading} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function heading(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'h' + node.depth,\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Html} Html\n * @typedef {import('../state.js').State} State\n * @typedef {import('../../index.js').Raw} Raw\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `html` node into hast (`raw` node in dangerous mode, otherwise\n * nothing).\n *\n * @param {State} state\n *   Info passed around.\n * @param {Html} node\n *   mdast node.\n * @returns {Element | Raw | undefined}\n *   hast node.\n */\nexport function html(state, node) {\n  if (state.options.allowDangerousHtml) {\n    /** @type {Raw} */\n    const result = {type: 'raw', value: node.value}\n    state.patch(node, result)\n    return state.applyData(node, result)\n  }\n\n  return undefined\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\n\n/**\n * Turn an mdast `imageReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ImageReference} node\n *   mdast node.\n * @returns {Array<ElementContent> | ElementContent}\n *   hast node.\n */\nexport function imageReference(state, node) {\n  const id = String(node.identifier).toUpperCase()\n  const definition = state.definitionById.get(id)\n\n  if (!definition) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {src: normalizeUri(definition.url || ''), alt: node.alt}\n\n  if (definition.title !== null && definition.title !== undefined) {\n    properties.title = definition.title\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'img', properties, children: []}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Image} Image\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `image` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Image} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function image(state, node) {\n  /** @type {Properties} */\n  const properties = {src: normalizeUri(node.url)}\n\n  if (node.alt !== null && node.alt !== undefined) {\n    properties.alt = node.alt\n  }\n\n  if (node.title !== null && node.title !== undefined) {\n    properties.title = node.title\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'img', properties, children: []}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `inlineCode` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {InlineCode} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function inlineCode(state, node) {\n  /** @type {Text} */\n  const text = {type: 'text', value: node.value.replace(/\\r?\\n|\\r/g, ' ')}\n  state.patch(node, text)\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'code',\n    properties: {},\n    children: [text]\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\n\n/**\n * Turn an mdast `linkReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {LinkReference} node\n *   mdast node.\n * @returns {Array<ElementContent> | ElementContent}\n *   hast node.\n */\nexport function linkReference(state, node) {\n  const id = String(node.identifier).toUpperCase()\n  const definition = state.definitionById.get(id)\n\n  if (!definition) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {href: normalizeUri(definition.url || '')}\n\n  if (definition.title !== null && definition.title !== undefined) {\n    properties.title = definition.title\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'a',\n    properties,\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Link} Link\n * @typedef {import('../state.js').State} State\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `link` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Link} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function link(state, node) {\n  /** @type {Properties} */\n  const properties = {href: normalizeUri(node.url)}\n\n  if (node.title !== null && node.title !== undefined) {\n    properties.title = node.title\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'a',\n    properties,\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').List} List\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `list` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {List} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function list(state, node) {\n  /** @type {Properties} */\n  const properties = {}\n  const results = state.all(node)\n  let index = -1\n\n  if (typeof node.start === 'number' && node.start !== 1) {\n    properties.start = node.start\n  }\n\n  // Like GitHub, add a class for custom styling.\n  while (++index < results.length) {\n    const child = results[index]\n\n    if (\n      child.type === 'element' &&\n      child.tagName === 'li' &&\n      child.properties &&\n      Array.isArray(child.properties.className) &&\n      child.properties.className.includes('task-list-item')\n    ) {\n      properties.className = ['contains-task-list']\n      break\n    }\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: node.ordered ? 'ol' : 'ul',\n    properties,\n    children: state.wrap(results, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `paragraph` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Paragraph} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function paragraph(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'p',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Parents} HastParents\n * @typedef {import('hast').Root} HastRoot\n * @typedef {import('mdast').Root} MdastRoot\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `root` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastRoot} node\n *   mdast node.\n * @returns {HastParents}\n *   hast node.\n */\nexport function root(state, node) {\n  /** @type {HastRoot} */\n  const result = {type: 'root', children: state.wrap(state.all(node))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `strong` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Strong} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function strong(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'strong',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').Table} Table\n * @typedef {import('../state.js').State} State\n */\n\nimport {pointEnd, pointStart} from 'unist-util-position'\n\n/**\n * Turn an mdast `table` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Table} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function table(state, node) {\n  const rows = state.all(node)\n  const firstRow = rows.shift()\n  /** @type {Array<Element>} */\n  const tableContent = []\n\n  if (firstRow) {\n    /** @type {Element} */\n    const head = {\n      type: 'element',\n      tagName: 'thead',\n      properties: {},\n      children: state.wrap([firstRow], true)\n    }\n    state.patch(node.children[0], head)\n    tableContent.push(head)\n  }\n\n  if (rows.length > 0) {\n    /** @type {Element} */\n    const body = {\n      type: 'element',\n      tagName: 'tbody',\n      properties: {},\n      children: state.wrap(rows, true)\n    }\n\n    const start = pointStart(node.children[1])\n    const end = pointEnd(node.children[node.children.length - 1])\n    if (start && end) body.position = {start, end}\n    tableContent.push(body)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'table',\n    properties: {},\n    children: state.wrap(tableContent, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').TableCell} TableCell\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `tableCell` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableCell} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function tableCell(state, node) {\n  // Note: this function is normally not called: see `table-row` for how rows\n  // and their cells are compiled.\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'td', // Assume body cell.\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('mdast').Parents} Parents\n * @typedef {import('mdast').TableRow} TableRow\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `tableRow` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableRow} node\n *   mdast node.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @returns {Element}\n *   hast node.\n */\nexport function tableRow(state, node, parent) {\n  const siblings = parent ? parent.children : undefined\n  // Generate a body row when without parent.\n  const rowIndex = siblings ? siblings.indexOf(node) : 1\n  const tagName = rowIndex === 0 ? 'th' : 'td'\n  // To do: option to use `style`?\n  const align = parent && parent.type === 'table' ? parent.align : undefined\n  const length = align ? align.length : node.children.length\n  let cellIndex = -1\n  /** @type {Array<ElementContent>} */\n  const cells = []\n\n  while (++cellIndex < length) {\n    // Note: can also be undefined.\n    const cell = node.children[cellIndex]\n    /** @type {Properties} */\n    const properties = {}\n    const alignValue = align ? align[cellIndex] : undefined\n\n    if (alignValue) {\n      properties.align = alignValue\n    }\n\n    /** @type {Element} */\n    let result = {type: 'element', tagName, properties, children: []}\n\n    if (cell) {\n      result.children = state.all(cell)\n      state.patch(cell, result)\n      result = state.applyData(cell, result)\n    }\n\n    cells.push(result)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'tr',\n    properties: {},\n    children: state.wrap(cells, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').Text} HastText\n * @typedef {import('mdast').Text} MdastText\n * @typedef {import('../state.js').State} State\n */\n\nimport {trimLines} from 'trim-lines'\n\n/**\n * Turn an mdast `text` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastText} node\n *   mdast node.\n * @returns {HastElement | HastText}\n *   hast node.\n */\nexport function text(state, node) {\n  /** @type {HastText} */\n  const result = {type: 'text', value: trimLines(String(node.value))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n * @typedef {import('../state.js').State} State\n */\n\n// Make VS Code show references to the above types.\n''\n\n/**\n * Turn an mdast `thematicBreak` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ThematicBreak} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function thematicBreak(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'hr',\n    properties: {},\n    children: []\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('hast').Element} HastElement\n * @typedef {import('hast').ElementContent} HastElementContent\n * @typedef {import('hast').Nodes} HastNodes\n * @typedef {import('hast').Properties} HastProperties\n * @typedef {import('hast').RootContent} HastRootContent\n * @typedef {import('hast').Text} HastText\n *\n * @typedef {import('mdast').Definition} MdastDefinition\n * @typedef {import('mdast').FootnoteDefinition} MdastFootnoteDefinition\n * @typedef {import('mdast').Nodes} MdastNodes\n * @typedef {import('mdast').Parents} MdastParents\n *\n * @typedef {import('vfile').VFile} VFile\n *\n * @typedef {import('./footer.js').FootnoteBackContentTemplate} FootnoteBackContentTemplate\n * @typedef {import('./footer.js').FootnoteBackLabelTemplate} FootnoteBackLabelTemplate\n */\n\n/**\n * @callback Handler\n *   Handle a node.\n * @param {State} state\n *   Info passed around.\n * @param {any} node\n *   mdast node to handle.\n * @param {MdastParents | undefined} parent\n *   Parent of `node`.\n * @returns {Array<HastElementContent> | HastElementContent | undefined}\n *   hast node.\n *\n * @typedef {Partial<Record<MdastNodes['type'], Handler>>} Handlers\n *   Handle nodes.\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [allowDangerousHtml=false]\n *   Whether to persist raw HTML in markdown in the hast tree (default:\n *   `false`).\n * @property {string | null | undefined} [clobberPrefix='user-content-']\n *   Prefix to use before the `id` property on footnotes to prevent them from\n *   *clobbering* (default: `'user-content-'`).\n *\n *   Pass `''` for trusted markdown and when you are careful with\n *   polyfilling.\n *   You could pass a different prefix.\n *\n *   DOM clobbering is this:\n *\n *   ```html\n *   <p id=\"x\"></p>\n *   <script>alert(x) // `x` now refers to the `p#x` DOM element</script>\n *   ```\n *\n *   The above example shows that elements are made available by browsers, by\n *   their ID, on the `window` object.\n *   This is a security risk because you might be expecting some other variable\n *   at that place.\n *   It can also break polyfills.\n *   Using a prefix solves these problems.\n * @property {VFile | null | undefined} [file]\n *   Corresponding virtual file representing the input document (optional).\n * @property {FootnoteBackContentTemplate | string | null | undefined} [footnoteBackContent]\n *   Content of the backreference back to references (default: `defaultFootnoteBackContent`).\n *\n *   The default value is:\n *\n *   ```js\n *   function defaultFootnoteBackContent(_, rereferenceIndex) {\n *     const result = [{type: 'text', value: '↩'}]\n *\n *     if (rereferenceIndex > 1) {\n *       result.push({\n *         type: 'element',\n *         tagName: 'sup',\n *         properties: {},\n *         children: [{type: 'text', value: String(rereferenceIndex)}]\n *       })\n *     }\n *\n *     return result\n *   }\n *   ```\n *\n *   This content is used in the `a` element of each backreference (the `↩`\n *   links).\n * @property {FootnoteBackLabelTemplate | string | null | undefined} [footnoteBackLabel]\n *   Label to describe the backreference back to references (default:\n *   `defaultFootnoteBackLabel`).\n *\n *   The default value is:\n *\n *   ```js\n *   function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {\n *    return (\n *      'Back to reference ' +\n *      (referenceIndex + 1) +\n *      (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')\n *    )\n *   }\n *   ```\n *\n *   Change it when the markdown is not in English.\n *\n *   This label is used in the `ariaLabel` property on each backreference\n *   (the `↩` links).\n *   It affects users of assistive technology.\n * @property {string | null | undefined} [footnoteLabel='Footnotes']\n *   Textual label to use for the footnotes section (default: `'Footnotes'`).\n *\n *   Change it when the markdown is not in English.\n *\n *   This label is typically hidden visually (assuming a `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass different properties with the `footnoteLabelProperties` option.\n * @property {HastProperties | null | undefined} [footnoteLabelProperties={className: ['sr-only']}]\n *   Properties to use on the footnote label (default: `{className:\n *   ['sr-only']}`).\n *\n *   Change it to show the label and add other properties.\n *\n *   This label is typically hidden visually (assuming an `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass an empty string.\n *   You can also add different properties.\n *\n *   > **Note**: `id: 'footnote-label'` is always added, because footnote\n *   > calls use it with `aria-describedby` to provide an accessible label.\n * @property {string | null | undefined} [footnoteLabelTagName='h2']\n *   HTML tag name to use for the footnote label element (default: `'h2'`).\n *\n *   Change it to match your document structure.\n *\n *   This label is typically hidden visually (assuming a `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass different properties with the `footnoteLabelProperties` option.\n * @property {Handlers | null | undefined} [handlers]\n *   Extra handlers for nodes (optional).\n * @property {Array<MdastNodes['type']> | null | undefined} [passThrough]\n *   List of custom mdast node types to pass through (keep) in hast (note that\n *   the node itself is passed, but eventual children are transformed)\n *   (optional).\n * @property {Handler | null | undefined} [unknownHandler]\n *   Handler for all unknown nodes (optional).\n *\n * @typedef State\n *   Info passed around.\n * @property {(node: MdastNodes) => Array<HastElementContent>} all\n *   Transform the children of an mdast parent to hast.\n * @property {<Type extends HastNodes>(from: MdastNodes, to: Type) => HastElement | Type} applyData\n *   Honor the `data` of `from`, and generate an element instead of `node`.\n * @property {Map<string, MdastDefinition>} definitionById\n *   Definitions by their identifier.\n * @property {Map<string, MdastFootnoteDefinition>} footnoteById\n *   Footnote definitions by their identifier.\n * @property {Map<string, number>} footnoteCounts\n *   Counts for how often the same footnote was called.\n * @property {Array<string>} footnoteOrder\n *   Identifiers of order when footnote calls first appear in tree order.\n * @property {Handlers} handlers\n *   Applied handlers.\n * @property {(node: MdastNodes, parent: MdastParents | undefined) => Array<HastElementContent> | HastElementContent | undefined} one\n *   Transform an mdast node to hast.\n * @property {Options} options\n *   Configuration.\n * @property {(from: MdastNodes, node: HastNodes) => undefined} patch\n *   Copy a node’s positional info.\n * @property {<Type extends HastRootContent>(nodes: Array<Type>, loose?: boolean | undefined) => Array<HastText | Type>} wrap\n *   Wrap `nodes` with line endings between each node, adds initial/final line endings when `loose`.\n */\n\nimport structuredClone from '@ungap/structured-clone'\nimport {visit} from 'unist-util-visit'\nimport {position} from 'unist-util-position'\nimport {handlers as defaultHandlers} from './handlers/index.js'\n\nconst own = {}.hasOwnProperty\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Create `state` from an mdast tree.\n *\n * @param {MdastNodes} tree\n *   mdast node to transform.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {State}\n *   `state` function.\n */\nexport function createState(tree, options) {\n  const settings = options || emptyOptions\n  /** @type {Map<string, MdastDefinition>} */\n  const definitionById = new Map()\n  /** @type {Map<string, MdastFootnoteDefinition>} */\n  const footnoteById = new Map()\n  /** @type {Map<string, number>} */\n  const footnoteCounts = new Map()\n  /** @type {Handlers} */\n  // @ts-expect-error: the root handler returns a root.\n  // Hard to type.\n  const handlers = {...defaultHandlers, ...settings.handlers}\n\n  /** @type {State} */\n  const state = {\n    all,\n    applyData,\n    definitionById,\n    footnoteById,\n    footnoteCounts,\n    footnoteOrder: [],\n    handlers,\n    one,\n    options: settings,\n    patch,\n    wrap\n  }\n\n  visit(tree, function (node) {\n    if (node.type === 'definition' || node.type === 'footnoteDefinition') {\n      const map = node.type === 'definition' ? definitionById : footnoteById\n      const id = String(node.identifier).toUpperCase()\n\n      // Mimick CM behavior of link definitions.\n      // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/9032189/lib/index.js#L20-L21>.\n      if (!map.has(id)) {\n        // @ts-expect-error: node type matches map.\n        map.set(id, node)\n      }\n    }\n  })\n\n  return state\n\n  /**\n   * Transform an mdast node into a hast node.\n   *\n   * @param {MdastNodes} node\n   *   mdast node.\n   * @param {MdastParents | undefined} [parent]\n   *   Parent of `node`.\n   * @returns {Array<HastElementContent> | HastElementContent | undefined}\n   *   Resulting hast node.\n   */\n  function one(node, parent) {\n    const type = node.type\n    const handle = state.handlers[type]\n\n    if (own.call(state.handlers, type) && handle) {\n      return handle(state, node, parent)\n    }\n\n    if (state.options.passThrough && state.options.passThrough.includes(type)) {\n      if ('children' in node) {\n        const {children, ...shallow} = node\n        const result = structuredClone(shallow)\n        // @ts-expect-error: TS doesn’t understand…\n        result.children = state.all(node)\n        // @ts-expect-error: TS doesn’t understand…\n        return result\n      }\n\n      // @ts-expect-error: it’s custom.\n      return structuredClone(node)\n    }\n\n    const unknown = state.options.unknownHandler || defaultUnknownHandler\n\n    return unknown(state, node, parent)\n  }\n\n  /**\n   * Transform the children of an mdast node into hast nodes.\n   *\n   * @param {MdastNodes} parent\n   *   mdast node to compile\n   * @returns {Array<HastElementContent>}\n   *   Resulting hast nodes.\n   */\n  function all(parent) {\n    /** @type {Array<HastElementContent>} */\n    const values = []\n\n    if ('children' in parent) {\n      const nodes = parent.children\n      let index = -1\n      while (++index < nodes.length) {\n        const result = state.one(nodes[index], parent)\n\n        // To do: see if we van clean this? Can we merge texts?\n        if (result) {\n          if (index && nodes[index - 1].type === 'break') {\n            if (!Array.isArray(result) && result.type === 'text') {\n              result.value = trimMarkdownSpaceStart(result.value)\n            }\n\n            if (!Array.isArray(result) && result.type === 'element') {\n              const head = result.children[0]\n\n              if (head && head.type === 'text') {\n                head.value = trimMarkdownSpaceStart(head.value)\n              }\n            }\n          }\n\n          if (Array.isArray(result)) {\n            values.push(...result)\n          } else {\n            values.push(result)\n          }\n        }\n      }\n    }\n\n    return values\n  }\n}\n\n/**\n * Copy a node’s positional info.\n *\n * @param {MdastNodes} from\n *   mdast node to copy from.\n * @param {HastNodes} to\n *   hast node to copy into.\n * @returns {undefined}\n *   Nothing.\n */\nfunction patch(from, to) {\n  if (from.position) to.position = position(from)\n}\n\n/**\n * Honor the `data` of `from` and maybe generate an element instead of `to`.\n *\n * @template {HastNodes} Type\n *   Node type.\n * @param {MdastNodes} from\n *   mdast node to use data from.\n * @param {Type} to\n *   hast node to change.\n * @returns {HastElement | Type}\n *   Nothing.\n */\nfunction applyData(from, to) {\n  /** @type {HastElement | Type} */\n  let result = to\n\n  // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n  if (from && from.data) {\n    const hName = from.data.hName\n    const hChildren = from.data.hChildren\n    const hProperties = from.data.hProperties\n\n    if (typeof hName === 'string') {\n      // Transforming the node resulted in an element with a different name\n      // than wanted:\n      if (result.type === 'element') {\n        result.tagName = hName\n      }\n      // Transforming the node resulted in a non-element, which happens for\n      // raw, text, and root nodes (unless custom handlers are passed).\n      // The intent of `hName` is to create an element, but likely also to keep\n      // the content around (otherwise: pass `hChildren`).\n      else {\n        /** @type {Array<HastElementContent>} */\n        // @ts-expect-error: assume no doctypes in `root`.\n        const children = 'children' in result ? result.children : [result]\n        result = {type: 'element', tagName: hName, properties: {}, children}\n      }\n    }\n\n    if (result.type === 'element' && hProperties) {\n      Object.assign(result.properties, structuredClone(hProperties))\n    }\n\n    if (\n      'children' in result &&\n      result.children &&\n      hChildren !== null &&\n      hChildren !== undefined\n    ) {\n      result.children = hChildren\n    }\n  }\n\n  return result\n}\n\n/**\n * Transform an unknown node.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastNodes} node\n *   Unknown mdast node.\n * @returns {HastElement | HastText}\n *   Resulting hast node.\n */\nfunction defaultUnknownHandler(state, node) {\n  const data = node.data || {}\n  /** @type {HastElement | HastText} */\n  const result =\n    'value' in node &&\n    !(own.call(data, 'hProperties') || own.call(data, 'hChildren'))\n      ? {type: 'text', value: node.value}\n      : {\n          type: 'element',\n          tagName: 'div',\n          properties: {},\n          children: state.all(node)\n        }\n\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n\n/**\n * Wrap `nodes` with line endings between each node.\n *\n * @template {HastRootContent} Type\n *   Node type.\n * @param {Array<Type>} nodes\n *   List of nodes to wrap.\n * @param {boolean | undefined} [loose=false]\n *   Whether to add line endings at start and end (default: `false`).\n * @returns {Array<HastText | Type>}\n *   Wrapped nodes.\n */\nexport function wrap(nodes, loose) {\n  /** @type {Array<HastText | Type>} */\n  const result = []\n  let index = -1\n\n  if (loose) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  while (++index < nodes.length) {\n    if (index) result.push({type: 'text', value: '\\n'})\n    result.push(nodes[index])\n  }\n\n  if (loose && nodes.length > 0) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  return result\n}\n\n/**\n * Trim spaces and tabs at the start of `value`.\n *\n * @param {string} value\n *   Value to trim.\n * @returns {string}\n *   Result.\n */\nfunction trimMarkdownSpaceStart(value) {\n  let index = 0\n  let code = value.charCodeAt(index)\n\n  while (code === 9 || code === 32) {\n    index++\n    code = value.charCodeAt(index)\n  }\n\n  return value.slice(index)\n}\n","/**\n * @typedef {import('hast').Nodes} HastNodes\n * @typedef {import('mdast').Nodes} MdastNodes\n * @typedef {import('./state.js').Options} Options\n */\n\nimport {ok as assert} from 'devlop'\nimport {footer} from './footer.js'\nimport {createState} from './state.js'\n\n/**\n * Transform mdast to hast.\n *\n * ##### Notes\n *\n * ###### HTML\n *\n * Raw HTML is available in mdast as `html` nodes and can be embedded in hast\n * as semistandard `raw` nodes.\n * Most utilities ignore `raw` nodes but two notable ones don’t:\n *\n * *   `hast-util-to-html` also has an option `allowDangerousHtml` which will\n *     output the raw HTML.\n *     This is typically discouraged as noted by the option name but is useful\n *     if you completely trust authors\n * *   `hast-util-raw` can handle the raw embedded HTML strings by parsing them\n *     into standard hast nodes (`element`, `text`, etc).\n *     This is a heavy task as it needs a full HTML parser, but it is the only\n *     way to support untrusted content\n *\n * ###### Footnotes\n *\n * Many options supported here relate to footnotes.\n * Footnotes are not specified by CommonMark, which we follow by default.\n * They are supported by GitHub, so footnotes can be enabled in markdown with\n * `mdast-util-gfm`.\n *\n * The options `footnoteBackLabel` and `footnoteLabel` define natural language\n * that explains footnotes, which is hidden for sighted users but shown to\n * assistive technology.\n * When your page is not in English, you must define translated values.\n *\n * Back references use ARIA attributes, but the section label itself uses a\n * heading that is hidden with an `sr-only` class.\n * To show it to sighted users, define different attributes in\n * `footnoteLabelProperties`.\n *\n * ###### Clobbering\n *\n * Footnotes introduces a problem, as it links footnote calls to footnote\n * definitions on the page through `id` attributes generated from user content,\n * which results in DOM clobbering.\n *\n * DOM clobbering is this:\n *\n * ```html\n * <p id=x></p>\n * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>\n * ```\n *\n * Elements by their ID are made available by browsers on the `window` object,\n * which is a security risk.\n * Using a prefix solves this problem.\n *\n * More information on how to handle clobbering and the prefix is explained in\n * Example: headings (DOM clobbering) in `rehype-sanitize`.\n *\n * ###### Unknown nodes\n *\n * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.\n * The default behavior for unknown nodes is:\n *\n * *   when the node has a `value` (and doesn’t have `data.hName`,\n *     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`\n *     node\n * *   otherwise, create a `<div>` element (which could be changed with\n *     `data.hName`), with its children mapped from mdast to hast as well\n *\n * This behavior can be changed by passing an `unknownHandler`.\n *\n * @param {MdastNodes} tree\n *   mdast tree.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {HastNodes}\n *   hast tree.\n */\nexport function toHast(tree, options) {\n  const state = createState(tree, options)\n  const node = state.one(tree, undefined)\n  const foot = footer(state)\n  /** @type {HastNodes} */\n  const result = Array.isArray(node)\n    ? {type: 'root', children: node}\n    : node || {type: 'root', children: []}\n\n  if (foot) {\n    // If there’s a footer, there were definitions, meaning block\n    // content.\n    // So `result` is a parent node.\n    assert('children' in result)\n    result.children.push({type: 'text', value: '\\n'}, foot)\n  }\n\n  return result\n}\n"],"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","onexitcharacterreference","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","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","item","create","and","open","token","this","errorHandler","close","onExitError","Error","settings","expectingFirstListItemValue","Number","parseInt","lang","meta","flowCodeInside","replace","identifier","toLowerCase","title","url","depth","setextHeadingSlurpLineEnding","codePointAt","siblings","text","atHardBreak","includes","inReference","referenceType","string","ancestor","fragment","characterReferenceType","ordered","spread","checked","compiler","postprocess","parse","document","write","preprocess","d","combined","extensions","extension","key","right","left","defaultFootnoteBackContent","_","rereferenceIndex","tagName","properties","String","defaultFootnoteBackLabel","referenceIndex","revert","state","subtype","suffix","contents","all","head","unshift","listItemLoose","blockquote","wrap","patch","applyData","break","code","className","delete","footnoteReference","clobberPrefix","id","toUpperCase","safeId","footnoteOrder","indexOf","counter","reuseCounter","footnoteCounts","get","set","href","dataFootnoteRef","ariaDescribedBy","sup","allowDangerousHtml","imageReference","definitionById","src","inlineCode","linkReference","parent","results","loose","listLoose","disabled","child","root","table","rows","firstRow","shift","tableContent","body","tableCell","tableRow","align","cellIndex","cells","cell","alignValue","toml","ignore","yaml","footnoteDefinition","from","to","hName","hChildren","hProperties","defaultUnknownHandler","nodes","trimMarkdownSpaceStart","charCodeAt","slice","toHast","Map","footnoteById","handlers","handle","passThrough","shallow","unknownHandler","map","has","createState","foot","footnoteBackContent","footnoteBackLabel","footnoteLabel","footnoteLabelTagName","footnoteLabelProperties","listItems","content","backReferences","counts","dataFootnoteBackref","ariaLabel","tailTail","dataFootnotes","footer"],"sourceRoot":""}