{"version":3,"file":"static/js/4420_e698525007a1c76dfa23.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/memoize-one@5.2.1/node_modules/memoize-one/dist/memoize-one.esm.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/attention.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/autolink.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/blank-line.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/block-quote.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/character-escape.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/character-reference.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/code-fenced.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/code-indented.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/code-text.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/content.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/definition.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/hard-break-escape.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/heading-atx.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-util-html-tag-name@1.2.0/node_modules/micromark-util-html-tag-name/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/html-flow.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/html-text.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/label-end.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/label-start-image.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/label-start-link.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/line-ending.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/list.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/setext-underline.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-core-commonmark@1.1.0/node_modules/micromark-core-commonmark/lib/thematic-break.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-extension-gfm-autolink-literal@1.0.5/node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-extension-gfm-footnote@1.1.2/node_modules/micromark-extension-gfm-footnote/lib/syntax.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-extension-gfm-strikethrough@1.0.7/node_modules/micromark-extension-gfm-strikethrough/lib/syntax.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-extension-gfm-table@1.0.7/node_modules/micromark-extension-gfm-table/lib/edit-map.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-extension-gfm-table@1.0.7/node_modules/micromark-extension-gfm-table/lib/infer.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-extension-gfm-table@1.0.7/node_modules/micromark-extension-gfm-table/lib/syntax.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-extension-gfm-task-list-item@1.0.5/node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-extension-gfm@2.0.3/node_modules/micromark-extension-gfm/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-factory-destination@1.1.0/node_modules/micromark-factory-destination/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-factory-label@1.1.0/node_modules/micromark-factory-label/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-factory-space@1.1.0/node_modules/micromark-factory-space/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-factory-title@1.1.0/node_modules/micromark-factory-title/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-factory-whitespace@1.1.0/node_modules/micromark-factory-whitespace/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-util-character@1.2.0/node_modules/micromark-util-character/lib/unicode-punctuation-regex.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-util-character@1.2.0/node_modules/micromark-util-character/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-util-chunked@1.1.0/node_modules/micromark-util-chunked/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-util-classify-character@1.1.0/node_modules/micromark-util-classify-character/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-util-combine-extensions@1.1.0/node_modules/micromark-util-combine-extensions/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-util-decode-numeric-character-reference@1.1.0/node_modules/micromark-util-decode-numeric-character-reference/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-util-decode-string@1.1.0/node_modules/micromark-util-decode-string/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-util-normalize-identifier@1.1.0/node_modules/micromark-util-normalize-identifier/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-util-resolve-all@1.1.0/node_modules/micromark-util-resolve-all/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-util-sanitize-uri@1.2.0/node_modules/micromark-util-sanitize-uri/index.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/micromark-util-subtokenize@1.1.0/node_modules/micromark-util-subtokenize/index.js"],"sourcesContent":["var safeIsNaN = Number.isNaN ||\n    function ponyfill(value) {\n        return typeof value === 'number' && value !== value;\n    };\nfunction isEqual(first, second) {\n    if (first === second) {\n        return true;\n    }\n    if (safeIsNaN(first) && safeIsNaN(second)) {\n        return true;\n    }\n    return false;\n}\nfunction areInputsEqual(newInputs, lastInputs) {\n    if (newInputs.length !== lastInputs.length) {\n        return false;\n    }\n    for (var i = 0; i < newInputs.length; i++) {\n        if (!isEqual(newInputs[i], lastInputs[i])) {\n            return false;\n        }\n    }\n    return true;\n}\n\nfunction memoizeOne(resultFn, isEqual) {\n    if (isEqual === void 0) { isEqual = areInputsEqual; }\n    var lastThis;\n    var lastArgs = [];\n    var lastResult;\n    var calledOnce = false;\n    function memoized() {\n        var newArgs = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            newArgs[_i] = arguments[_i];\n        }\n        if (calledOnce && lastThis === this && isEqual(newArgs, lastArgs)) {\n            return lastResult;\n        }\n        lastResult = resultFn.apply(this, newArgs);\n        calledOnce = true;\n        lastThis = this;\n        lastArgs = newArgs;\n        return lastResult;\n    }\n    return memoized;\n}\n\nexport default memoizeOne;\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {push, splice} from 'micromark-util-chunked'\nimport {classifyCharacter} from 'micromark-util-classify-character'\nimport {resolveAll} from 'micromark-util-resolve-all'\n/** @type {Construct} */\nexport const attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\n}\n\n/**\n * Take all events and resolve attention to emphasis or strong.\n *\n * @type {Resolver}\n */\nfunction resolveAllAttention(events, context) {\n  let index = -1\n  /** @type {number} */\n  let open\n  /** @type {Token} */\n  let group\n  /** @type {Token} */\n  let text\n  /** @type {Token} */\n  let openingSequence\n  /** @type {Token} */\n  let closingSequence\n  /** @type {number} */\n  let use\n  /** @type {Array<Event>} */\n  let nextEvents\n  /** @type {number} */\n  let offset\n\n  // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it’s\n  // a bottleneck for malicious stuff.\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (\n      events[index][0] === 'enter' &&\n      events[index][1].type === 'attentionSequence' &&\n      events[index][1]._close\n    ) {\n      open = index\n\n      // Now walk back to find an opener.\n      while (open--) {\n        // Find a token that can open the closer.\n        if (\n          events[open][0] === 'exit' &&\n          events[open][1].type === 'attentionSequence' &&\n          events[open][1]._open &&\n          // If the markers are the same:\n          context.sliceSerialize(events[open][1]).charCodeAt(0) ===\n            context.sliceSerialize(events[index][1]).charCodeAt(0)\n        ) {\n          // If the opening can close or the closing can open,\n          // and the close size *is not* a multiple of three,\n          // but the sum of the opening and closing size *is* multiple of three,\n          // then don’t match.\n          if (\n            (events[open][1]._close || events[index][1]._open) &&\n            (events[index][1].end.offset - events[index][1].start.offset) % 3 &&\n            !(\n              (events[open][1].end.offset -\n                events[open][1].start.offset +\n                events[index][1].end.offset -\n                events[index][1].start.offset) %\n              3\n            )\n          ) {\n            continue\n          }\n\n          // Number of markers to use from the sequence.\n          use =\n            events[open][1].end.offset - events[open][1].start.offset > 1 &&\n            events[index][1].end.offset - events[index][1].start.offset > 1\n              ? 2\n              : 1\n          const start = Object.assign({}, events[open][1].end)\n          const end = Object.assign({}, events[index][1].start)\n          movePoint(start, -use)\n          movePoint(end, use)\n          openingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start,\n            end: Object.assign({}, events[open][1].end)\n          }\n          closingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: Object.assign({}, events[index][1].start),\n            end\n          }\n          text = {\n            type: use > 1 ? 'strongText' : 'emphasisText',\n            start: Object.assign({}, events[open][1].end),\n            end: Object.assign({}, events[index][1].start)\n          }\n          group = {\n            type: use > 1 ? 'strong' : 'emphasis',\n            start: Object.assign({}, openingSequence.start),\n            end: Object.assign({}, closingSequence.end)\n          }\n          events[open][1].end = Object.assign({}, openingSequence.start)\n          events[index][1].start = Object.assign({}, closingSequence.end)\n          nextEvents = []\n\n          // If there are more markers in the opening, add them before.\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = push(nextEvents, [\n              ['enter', events[open][1], context],\n              ['exit', events[open][1], context]\n            ])\n          }\n\n          // Opening.\n          nextEvents = push(nextEvents, [\n            ['enter', group, context],\n            ['enter', openingSequence, context],\n            ['exit', openingSequence, context],\n            ['enter', text, context]\n          ])\n\n          // Always populated by defaults.\n\n          // Between.\n          nextEvents = push(\n            nextEvents,\n            resolveAll(\n              context.parser.constructs.insideSpan.null,\n              events.slice(open + 1, index),\n              context\n            )\n          )\n\n          // Closing.\n          nextEvents = push(nextEvents, [\n            ['exit', text, context],\n            ['enter', closingSequence, context],\n            ['exit', closingSequence, context],\n            ['exit', group, context]\n          ])\n\n          // If there are more markers in the closing, add them after.\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2\n            nextEvents = push(nextEvents, [\n              ['enter', events[index][1], context],\n              ['exit', events[index][1], context]\n            ])\n          } else {\n            offset = 0\n          }\n          splice(events, open - 1, index - open + 3, nextEvents)\n          index = open + nextEvents.length - offset - 2\n          break\n        }\n      }\n    }\n  }\n\n  // Remove remaining sequences.\n  index = -1\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data'\n    }\n  }\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeAttention(effects, ok) {\n  const attentionMarkers = this.parser.constructs.attentionMarkers.null\n  const previous = this.previous\n  const before = classifyCharacter(previous)\n\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n\n  /**\n   * Before a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    marker = code\n    effects.enter('attentionSequence')\n    return inside(code)\n  }\n\n  /**\n   * In a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return inside\n    }\n    const token = effects.exit('attentionSequence')\n\n    // To do: next major: move this to resolver, just like `markdown-rs`.\n    const after = classifyCharacter(code)\n\n    // Always populated by defaults.\n\n    const open =\n      !after || (after === 2 && before) || attentionMarkers.includes(code)\n    const close =\n      !before || (before === 2 && after) || attentionMarkers.includes(previous)\n    token._open = Boolean(marker === 42 ? open : open && (before || !close))\n    token._close = Boolean(marker === 42 ? close : close && (after || !open))\n    return ok(code)\n  }\n}\n\n/**\n * Move a point a bit.\n *\n * Note: `move` only works inside lines! It’s not possible to move past other\n * chunks (replacement characters, tabs, or line endings).\n *\n * @param {Point} point\n * @param {number} offset\n * @returns {void}\n */\nfunction movePoint(point, offset) {\n  point.column += offset\n  point.offset += offset\n  point._bufferIndex += offset\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  asciiAtext,\n  asciiControl\n} from 'micromark-util-character'\n/** @type {Construct} */\nexport const autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeAutolink(effects, ok, nok) {\n  let size = 0\n  return start\n\n  /**\n   * Start of an autolink.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *      ^\n   * > | a<user@example.com>b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('autolink')\n    effects.enter('autolinkMarker')\n    effects.consume(code)\n    effects.exit('autolinkMarker')\n    effects.enter('autolinkProtocol')\n    return open\n  }\n\n  /**\n   * After `<`, at protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *       ^\n   * > | a<user@example.com>b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return schemeOrEmailAtext\n    }\n    return emailAtext(code)\n  }\n\n  /**\n   * At second byte of protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeOrEmailAtext(code) {\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) {\n      // Count the previous alphabetical from `open` too.\n      size = 1\n      return schemeInsideOrEmailAtext(code)\n    }\n    return emailAtext(code)\n  }\n\n  /**\n   * In ambiguous protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code)\n      size = 0\n      return urlInside\n    }\n\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if (\n      (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) &&\n      size++ < 32\n    ) {\n      effects.consume(code)\n      return schemeInsideOrEmailAtext\n    }\n    size = 0\n    return emailAtext(code)\n  }\n\n  /**\n   * After protocol, in URL.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit('autolinkProtocol')\n      effects.enter('autolinkMarker')\n      effects.consume(code)\n      effects.exit('autolinkMarker')\n      effects.exit('autolink')\n      return ok\n    }\n\n    // ASCII control, space, or `<`.\n    if (code === null || code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return urlInside\n  }\n\n  /**\n   * In email atext.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code)\n      return emailAtSignOrDot\n    }\n    if (asciiAtext(code)) {\n      effects.consume(code)\n      return emailAtext\n    }\n    return nok(code)\n  }\n\n  /**\n   * In label, after at-sign or dot.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                 ^       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code)\n  }\n\n  /**\n   * In label, where `.` and `>` are allowed.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code)\n      size = 0\n      return emailAtSignOrDot\n    }\n    if (code === 62) {\n      // Exit, then change the token type.\n      effects.exit('autolinkProtocol').type = 'autolinkEmail'\n      effects.enter('autolinkMarker')\n      effects.consume(code)\n      effects.exit('autolinkMarker')\n      effects.exit('autolink')\n      return ok\n    }\n    return emailValue(code)\n  }\n\n  /**\n   * In label, where `.` and `>` are *not* allowed.\n   *\n   * Though, this is also used in `emailLabel` to parse other values.\n   *\n   * ```markdown\n   * > | a<user.name@ex-ample.com>b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailValue(code) {\n    // ASCII alphanumeric or `-`.\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      const next = code === 45 ? emailValue : emailLabel\n      effects.consume(code)\n      return next\n    }\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nexport const blankLine = {\n  tokenize: tokenizeBlankLine,\n  partial: true\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return start\n\n  /**\n   * Start of blank line.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *     ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    return markdownSpace(code)\n      ? factorySpace(effects, after, 'linePrefix')(code)\n      : after(code)\n  }\n\n  /**\n   * At eof/eol, after optional whitespace.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *       ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nexport const blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  const self = this\n  return start\n\n  /**\n   * Start of block quote.\n   *\n   * ```markdown\n   * > | > a\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 62) {\n      const state = self.containerState\n      if (!state.open) {\n        effects.enter('blockQuote', {\n          _container: true\n        })\n        state.open = true\n      }\n      effects.enter('blockQuotePrefix')\n      effects.enter('blockQuoteMarker')\n      effects.consume(code)\n      effects.exit('blockQuoteMarker')\n      return after\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `>`, before optional whitespace.\n   *\n   * ```markdown\n   * > | > a\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter('blockQuotePrefixWhitespace')\n      effects.consume(code)\n      effects.exit('blockQuotePrefixWhitespace')\n      effects.exit('blockQuotePrefix')\n      return ok\n    }\n    effects.exit('blockQuotePrefix')\n    return ok(code)\n  }\n}\n\n/**\n * Start of block quote continuation.\n *\n * ```markdown\n *   | > a\n * > | > b\n *     ^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  const self = this\n  return contStart\n\n  /**\n   * Start of block quote continuation.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contStart(code) {\n    if (markdownSpace(code)) {\n      // Always populated by defaults.\n\n      return factorySpace(\n        effects,\n        contBefore,\n        'linePrefix',\n        self.parser.constructs.disable.null.includes('codeIndented')\n          ? undefined\n          : 4\n      )(code)\n    }\n    return contBefore(code)\n  }\n\n  /**\n   * At `>`, after optional whitespace.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contBefore(code) {\n    return effects.attempt(blockQuote, ok, nok)(code)\n  }\n}\n\n/** @type {Exiter} */\nfunction exit(effects) {\n  effects.exit('blockQuote')\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {asciiPunctuation} from 'micromark-util-character'\n/** @type {Construct} */\nexport const characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start\n\n  /**\n   * Start of character escape.\n   *\n   * ```markdown\n   * > | a\\*b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('characterEscape')\n    effects.enter('escapeMarker')\n    effects.consume(code)\n    effects.exit('escapeMarker')\n    return inside\n  }\n\n  /**\n   * After `\\`, at punctuation.\n   *\n   * ```markdown\n   * > | a\\*b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    // ASCII punctuation.\n    if (asciiPunctuation(code)) {\n      effects.enter('characterEscapeValue')\n      effects.consume(code)\n      effects.exit('characterEscapeValue')\n      effects.exit('characterEscape')\n      return ok\n    }\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {\n  asciiAlphanumeric,\n  asciiDigit,\n  asciiHexDigit\n} from 'micromark-util-character'\n/** @type {Construct} */\nexport const characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  const self = this\n  let size = 0\n  /** @type {number} */\n  let max\n  /** @type {(code: Code) => boolean} */\n  let test\n  return start\n\n  /**\n   * Start of character reference.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *      ^\n   * > | a&#123;b\n   *      ^\n   * > | a&#x9;b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('characterReference')\n    effects.enter('characterReferenceMarker')\n    effects.consume(code)\n    effects.exit('characterReferenceMarker')\n    return open\n  }\n\n  /**\n   * After `&`, at `#` for numeric references or alphanumeric for named\n   * references.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^\n   * > | a&#123;b\n   *       ^\n   * > | a&#x9;b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 35) {\n      effects.enter('characterReferenceMarkerNumeric')\n      effects.consume(code)\n      effects.exit('characterReferenceMarkerNumeric')\n      return numeric\n    }\n    effects.enter('characterReferenceValue')\n    max = 31\n    test = asciiAlphanumeric\n    return value(code)\n  }\n\n  /**\n   * After `#`, at `x` for hexadecimals or digit for decimals.\n   *\n   * ```markdown\n   * > | a&#123;b\n   *        ^\n   * > | a&#x9;b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter('characterReferenceMarkerHexadecimal')\n      effects.consume(code)\n      effects.exit('characterReferenceMarkerHexadecimal')\n      effects.enter('characterReferenceValue')\n      max = 6\n      test = asciiHexDigit\n      return value\n    }\n    effects.enter('characterReferenceValue')\n    max = 7\n    test = asciiDigit\n    return value(code)\n  }\n\n  /**\n   * After markers (`&#x`, `&#`, or `&`), in value, before `;`.\n   *\n   * The character reference kind defines what and how many characters are\n   * allowed.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^^^\n   * > | a&#123;b\n   *        ^^^\n   * > | a&#x9;b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function value(code) {\n    if (code === 59 && size) {\n      const token = effects.exit('characterReferenceValue')\n      if (\n        test === asciiAlphanumeric &&\n        !decodeNamedCharacterReference(self.sliceSerialize(token))\n      ) {\n        return nok(code)\n      }\n\n      // To do: `markdown-rs` uses a different name:\n      // `CharacterReferenceMarkerSemi`.\n      effects.enter('characterReferenceMarker')\n      effects.consume(code)\n      effects.exit('characterReferenceMarker')\n      effects.exit('characterReference')\n      return ok\n    }\n    if (test(code) && size++ < max) {\n      effects.consume(code)\n      return value\n    }\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nconst nonLazyContinuation = {\n  tokenize: tokenizeNonLazyContinuation,\n  partial: true\n}\n\n/** @type {Construct} */\nexport const codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  const self = this\n  /** @type {Construct} */\n  const closeStart = {\n    tokenize: tokenizeCloseStart,\n    partial: true\n  }\n  let initialPrefix = 0\n  let sizeOpen = 0\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n\n  /**\n   * Start of code.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse whitespace like `markdown-rs`.\n    return beforeSequenceOpen(code)\n  }\n\n  /**\n   * In opening fence, after prefix, at sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeSequenceOpen(code) {\n    const tail = self.events[self.events.length - 1]\n    initialPrefix =\n      tail && tail[1].type === 'linePrefix'\n        ? tail[2].sliceSerialize(tail[1], true).length\n        : 0\n    marker = code\n    effects.enter('codeFenced')\n    effects.enter('codeFencedFence')\n    effects.enter('codeFencedFenceSequence')\n    return sequenceOpen(code)\n  }\n\n  /**\n   * In opening fence sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *      ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === marker) {\n      sizeOpen++\n      effects.consume(code)\n      return sequenceOpen\n    }\n    if (sizeOpen < 3) {\n      return nok(code)\n    }\n    effects.exit('codeFencedFenceSequence')\n    return markdownSpace(code)\n      ? factorySpace(effects, infoBefore, 'whitespace')(code)\n      : infoBefore(code)\n  }\n\n  /**\n   * In opening fence, after the sequence (and optional whitespace), before info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function infoBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFencedFence')\n      return self.interrupt\n        ? ok(code)\n        : effects.check(nonLazyContinuation, atNonLazyBreak, after)(code)\n    }\n    effects.enter('codeFencedFenceInfo')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return info(code)\n  }\n\n  /**\n   * In info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function info(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceInfo')\n      return infoBefore(code)\n    }\n    if (markdownSpace(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceInfo')\n      return factorySpace(effects, metaBefore, 'whitespace')(code)\n    }\n    if (code === 96 && code === marker) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return info\n  }\n\n  /**\n   * In opening fence, after info and whitespace, before meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function metaBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return infoBefore(code)\n    }\n    effects.enter('codeFencedFenceMeta')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return meta(code)\n  }\n\n  /**\n   * In meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceMeta')\n      return infoBefore(code)\n    }\n    if (code === 96 && code === marker) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return meta\n  }\n\n  /**\n   * At eol/eof in code, before a non-lazy closing fence or content.\n   *\n   * ```markdown\n   * > | ~~~js\n   *          ^\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function atNonLazyBreak(code) {\n    return effects.attempt(closeStart, after, contentBefore)(code)\n  }\n\n  /**\n   * Before code content, not a closing fence, at eol.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentBefore(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return contentStart\n  }\n\n  /**\n   * Before code content, not a closing fence.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentStart(code) {\n    return initialPrefix > 0 && markdownSpace(code)\n      ? factorySpace(\n          effects,\n          beforeContentChunk,\n          'linePrefix',\n          initialPrefix + 1\n        )(code)\n      : beforeContentChunk(code)\n  }\n\n  /**\n   * Before code content, after optional prefix.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeContentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return effects.check(nonLazyContinuation, atNonLazyBreak, after)(code)\n    }\n    effects.enter('codeFlowValue')\n    return contentChunk(code)\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^^^^^^^^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return beforeContentChunk(code)\n    }\n    effects.consume(code)\n    return contentChunk\n  }\n\n  /**\n   * After code.\n   *\n   * ```markdown\n   *   | ~~~js\n   *   | alert(1)\n   * > | ~~~\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    effects.exit('codeFenced')\n    return ok(code)\n  }\n\n  /**\n   * @this {TokenizeContext}\n   * @type {Tokenizer}\n   */\n  function tokenizeCloseStart(effects, ok, nok) {\n    let size = 0\n    return startBefore\n\n    /**\n     *\n     *\n     * @type {State}\n     */\n    function startBefore(code) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return start\n    }\n\n    /**\n     * Before closing fence, at optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function start(code) {\n      // Always populated by defaults.\n\n      // To do: `enter` here or in next state?\n      effects.enter('codeFencedFence')\n      return markdownSpace(code)\n        ? factorySpace(\n            effects,\n            beforeSequenceClose,\n            'linePrefix',\n            self.parser.constructs.disable.null.includes('codeIndented')\n              ? undefined\n              : 4\n          )(code)\n        : beforeSequenceClose(code)\n    }\n\n    /**\n     * In closing fence, after optional whitespace, at sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function beforeSequenceClose(code) {\n      if (code === marker) {\n        effects.enter('codeFencedFenceSequence')\n        return sequenceClose(code)\n      }\n      return nok(code)\n    }\n\n    /**\n     * In closing fence sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceClose(code) {\n      if (code === marker) {\n        size++\n        effects.consume(code)\n        return sequenceClose\n      }\n      if (size >= sizeOpen) {\n        effects.exit('codeFencedFenceSequence')\n        return markdownSpace(code)\n          ? factorySpace(effects, sequenceCloseAfter, 'whitespace')(code)\n          : sequenceCloseAfter(code)\n      }\n      return nok(code)\n    }\n\n    /**\n     * After closing fence sequence, after optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *        ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceCloseAfter(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit('codeFencedFence')\n        return ok(code)\n      }\n      return nok(code)\n    }\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuation(effects, ok, nok) {\n  const self = this\n  return start\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === null) {\n      return nok(code)\n    }\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return lineStart\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function lineStart(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nexport const codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented\n}\n\n/** @type {Construct} */\nconst furtherStart = {\n  tokenize: tokenizeFurtherStart,\n  partial: true\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  const self = this\n  return start\n\n  /**\n   * Start of code (indented).\n   *\n   * > **Parsing note**: it is not needed to check if this first line is a\n   * > filled line (that it has a non-whitespace character), because blank lines\n   * > are parsed already, so we never run into that.\n   *\n   * ```markdown\n   * > |     aaa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: manually check if interrupting like `markdown-rs`.\n\n    effects.enter('codeIndented')\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)(code)\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n      ? atBreak(code)\n      : nok(code)\n  }\n\n  /**\n   * At a break.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === null) {\n      return after(code)\n    }\n    if (markdownLineEnding(code)) {\n      return effects.attempt(furtherStart, atBreak, after)(code)\n    }\n    effects.enter('codeFlowValue')\n    return inside(code)\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return atBreak(code)\n    }\n    effects.consume(code)\n    return inside\n  }\n\n  /** @type {State} */\n  function after(code) {\n    effects.exit('codeIndented')\n    // To do: allow interrupting like `markdown-rs`.\n    // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    return ok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeFurtherStart(effects, ok, nok) {\n  const self = this\n  return furtherStart\n\n  /**\n   * At eol, trying to parse another indent.\n   *\n   * ```markdown\n   * > |     aaa\n   *            ^\n   *   |     bbb\n   * ```\n   *\n   * @type {State}\n   */\n  function furtherStart(code) {\n    // To do: improve `lazy` / `pierce` handling.\n    // If this is a lazy line, it can’t be code.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code)\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return furtherStart\n    }\n\n    // To do: the code here in `micromark-js` is a bit different from\n    // `markdown-rs` because there it can attempt spaces.\n    // We can’t yet.\n    //\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)(code)\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n      ? ok(code)\n      : markdownLineEnding(code)\n      ? furtherStart(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Previous} Previous\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {markdownLineEnding} from 'micromark-util-character'\n/** @type {Construct} */\nexport const codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous\n}\n\n// To do: next major: don’t resolve, like `markdown-rs`.\n/** @type {Resolver} */\nfunction resolveCodeText(events) {\n  let tailExitIndex = events.length - 4\n  let headEnterIndex = 3\n  /** @type {number} */\n  let index\n  /** @type {number | undefined} */\n  let enter\n\n  // If we start and end with an EOL or a space.\n  if (\n    (events[headEnterIndex][1].type === 'lineEnding' ||\n      events[headEnterIndex][1].type === 'space') &&\n    (events[tailExitIndex][1].type === 'lineEnding' ||\n      events[tailExitIndex][1].type === 'space')\n  ) {\n    index = headEnterIndex\n\n    // And we have data.\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === 'codeTextData') {\n        // Then we have padding.\n        events[headEnterIndex][1].type = 'codeTextPadding'\n        events[tailExitIndex][1].type = 'codeTextPadding'\n        headEnterIndex += 2\n        tailExitIndex -= 2\n        break\n      }\n    }\n  }\n\n  // Merge adjacent spaces and data.\n  index = headEnterIndex - 1\n  tailExitIndex++\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== 'lineEnding') {\n        enter = index\n      }\n    } else if (\n      index === tailExitIndex ||\n      events[index][1].type === 'lineEnding'\n    ) {\n      events[enter][1].type = 'codeTextData'\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end\n        events.splice(enter + 2, index - enter - 2)\n        tailExitIndex -= index - enter - 2\n        index = enter + 2\n      }\n      enter = undefined\n    }\n  }\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Previous}\n */\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return (\n    code !== 96 ||\n    this.events[this.events.length - 1][1].type === 'characterEscape'\n  )\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCodeText(effects, ok, nok) {\n  const self = this\n  let sizeOpen = 0\n  /** @type {number} */\n  let size\n  /** @type {Token} */\n  let token\n  return start\n\n  /**\n   * Start of code (text).\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * > | \\`a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('codeText')\n    effects.enter('codeTextSequence')\n    return sequenceOpen(code)\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 96) {\n      effects.consume(code)\n      sizeOpen++\n      return sequenceOpen\n    }\n    effects.exit('codeTextSequence')\n    return between(code)\n  }\n\n  /**\n   * Between something and something else.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function between(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code)\n    }\n\n    // To do: next major: don’t do spaces in resolve, but when compiling,\n    // like `markdown-rs`.\n    // Tabs don’t work, and virtual spaces don’t make sense.\n    if (code === 32) {\n      effects.enter('space')\n      effects.consume(code)\n      effects.exit('space')\n      return between\n    }\n\n    // Closing fence? Could also be data.\n    if (code === 96) {\n      token = effects.enter('codeTextSequence')\n      size = 0\n      return sequenceClose(code)\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return between\n    }\n\n    // Data.\n    effects.enter('codeTextData')\n    return data(code)\n  }\n\n  /**\n   * In data.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (\n      code === null ||\n      code === 32 ||\n      code === 96 ||\n      markdownLineEnding(code)\n    ) {\n      effects.exit('codeTextData')\n      return between(code)\n    }\n    effects.consume(code)\n    return data\n  }\n\n  /**\n   * In closing sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceClose(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code)\n      size++\n      return sequenceClose\n    }\n\n    // Done!\n    if (size === sizeOpen) {\n      effects.exit('codeTextSequence')\n      effects.exit('codeText')\n      return ok(code)\n    }\n\n    // More or less accents: mark as data.\n    token.type = 'codeTextData'\n    return data(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {subtokenize} from 'micromark-util-subtokenize'\n/**\n * No name because it must not be turned off.\n * @type {Construct}\n */\nexport const content = {\n  tokenize: tokenizeContent,\n  resolve: resolveContent\n}\n\n/** @type {Construct} */\nconst continuationConstruct = {\n  tokenize: tokenizeContinuation,\n  partial: true\n}\n\n/**\n * Content is transparent: it’s parsed right now. That way, definitions are also\n * parsed right now: before text in paragraphs (specifically, media) are parsed.\n *\n * @type {Resolver}\n */\nfunction resolveContent(events) {\n  subtokenize(events)\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeContent(effects, ok) {\n  /** @type {Token | undefined} */\n  let previous\n  return chunkStart\n\n  /**\n   * Before a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkStart(code) {\n    effects.enter('content')\n    previous = effects.enter('chunkContent', {\n      contentType: 'content'\n    })\n    return chunkInside(code)\n  }\n\n  /**\n   * In a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkInside(code) {\n    if (code === null) {\n      return contentEnd(code)\n    }\n\n    // To do: in `markdown-rs`, each line is parsed on its own, and everything\n    // is stitched together resolving.\n    if (markdownLineEnding(code)) {\n      return effects.check(\n        continuationConstruct,\n        contentContinue,\n        contentEnd\n      )(code)\n    }\n\n    // Data.\n    effects.consume(code)\n    return chunkInside\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentEnd(code) {\n    effects.exit('chunkContent')\n    effects.exit('content')\n    return ok(code)\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentContinue(code) {\n    effects.consume(code)\n    effects.exit('chunkContent')\n    previous.next = effects.enter('chunkContent', {\n      contentType: 'content',\n      previous\n    })\n    previous = previous.next\n    return chunkInside\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeContinuation(effects, ok, nok) {\n  const self = this\n  return startLookahead\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function startLookahead(code) {\n    effects.exit('chunkContent')\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, prefixed, 'linePrefix')\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    // Always populated by defaults.\n\n    const tail = self.events[self.events.length - 1]\n    if (\n      !self.parser.constructs.disable.null.includes('codeIndented') &&\n      tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n    ) {\n      return ok(code)\n    }\n    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factoryDestination} from 'micromark-factory-destination'\nimport {factoryLabel} from 'micromark-factory-label'\nimport {factorySpace} from 'micromark-factory-space'\nimport {factoryTitle} from 'micromark-factory-title'\nimport {factoryWhitespace} from 'micromark-factory-whitespace'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\n/** @type {Construct} */\nexport const definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n}\n\n/** @type {Construct} */\nconst titleBefore = {\n  tokenize: tokenizeTitleBefore,\n  partial: true\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinition(effects, ok, nok) {\n  const self = this\n  /** @type {string} */\n  let identifier\n  return start\n\n  /**\n   * At start of a definition.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // Do not interrupt paragraphs (but do follow definitions).\n    // To do: do `interrupt` the way `markdown-rs` does.\n    // To do: parse whitespace the way `markdown-rs` does.\n    effects.enter('definition')\n    return before(code)\n  }\n\n  /**\n   * After optional whitespace, at `[`.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    // To do: parse whitespace the way `markdown-rs` does.\n\n    return factoryLabel.call(\n      self,\n      effects,\n      labelAfter,\n      // Note: we don’t need to reset the way `markdown-rs` does.\n      nok,\n      'definitionLabel',\n      'definitionLabelMarker',\n      'definitionLabelString'\n    )(code)\n  }\n\n  /**\n   * After label.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(\n      self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n    )\n    if (code === 58) {\n      effects.enter('definitionMarker')\n      effects.consume(code)\n      effects.exit('definitionMarker')\n      return markerAfter\n    }\n    return nok(code)\n  }\n\n  /**\n   * After marker.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function markerAfter(code) {\n    // Note: whitespace is optional.\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, destinationBefore)(code)\n      : destinationBefore(code)\n  }\n\n  /**\n   * Before destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationBefore(code) {\n    return factoryDestination(\n      effects,\n      destinationAfter,\n      // Note: we don’t need to reset the way `markdown-rs` does.\n      nok,\n      'definitionDestination',\n      'definitionDestinationLiteral',\n      'definitionDestinationLiteralMarker',\n      'definitionDestinationRaw',\n      'definitionDestinationString'\n    )(code)\n  }\n\n  /**\n   * After destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationAfter(code) {\n    return effects.attempt(titleBefore, after, after)(code)\n  }\n\n  /**\n   * After definition.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return markdownSpace(code)\n      ? factorySpace(effects, afterWhitespace, 'whitespace')(code)\n      : afterWhitespace(code)\n  }\n\n  /**\n   * After definition, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterWhitespace(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('definition')\n\n      // Note: we don’t care about uniqueness.\n      // It’s likely that that doesn’t happen very frequently.\n      // It is more likely that it wastes precious time.\n      self.parser.defined.push(identifier)\n\n      // To do: `markdown-rs` interrupt.\n      // // You’d be interrupting.\n      // tokenizer.interrupt = true\n      return ok(code)\n    }\n    return nok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTitleBefore(effects, ok, nok) {\n  return titleBefore\n\n  /**\n   * After destination, at whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleBefore(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, beforeMarker)(code)\n      : nok(code)\n  }\n\n  /**\n   * At title.\n   *\n   * ```markdown\n   *   | [a]: b\n   * > | \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeMarker(code) {\n    return factoryTitle(\n      effects,\n      titleAfter,\n      nok,\n      'definitionTitle',\n      'definitionTitleMarker',\n      'definitionTitleString'\n    )(code)\n  }\n\n  /**\n   * After title.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfter(code) {\n    return markdownSpace(code)\n      ? factorySpace(effects, titleAfterOptionalWhitespace, 'whitespace')(code)\n      : titleAfterOptionalWhitespace(code)\n  }\n\n  /**\n   * After title, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfterOptionalWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {markdownLineEnding} from 'micromark-util-character'\n/** @type {Construct} */\nexport const hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start\n\n  /**\n   * Start of a hard break (escape).\n   *\n   * ```markdown\n   * > | a\\\n   *      ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('hardBreakEscape')\n    effects.consume(code)\n    return after\n  }\n\n  /**\n   * After `\\`, at eol.\n   *\n   * ```markdown\n   * > | a\\\n   *       ^\n   *   | b\n   * ```\n   *\n   *  @type {State}\n   */\n  function after(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit('hardBreakEscape')\n      return ok(code)\n    }\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {splice} from 'micromark-util-chunked'\n/** @type {Construct} */\nexport const headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\n}\n\n/** @type {Resolver} */\nfunction resolveHeadingAtx(events, context) {\n  let contentEnd = events.length - 2\n  let contentStart = 3\n  /** @type {Token} */\n  let content\n  /** @type {Token} */\n  let text\n\n  // Prefix whitespace, part of the opening.\n  if (events[contentStart][1].type === 'whitespace') {\n    contentStart += 2\n  }\n\n  // Suffix whitespace, part of the closing.\n  if (\n    contentEnd - 2 > contentStart &&\n    events[contentEnd][1].type === 'whitespace'\n  ) {\n    contentEnd -= 2\n  }\n  if (\n    events[contentEnd][1].type === 'atxHeadingSequence' &&\n    (contentStart === contentEnd - 1 ||\n      (contentEnd - 4 > contentStart &&\n        events[contentEnd - 2][1].type === 'whitespace'))\n  ) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4\n  }\n  if (contentEnd > contentStart) {\n    content = {\n      type: 'atxHeadingText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end\n    }\n    text = {\n      type: 'chunkText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end,\n      contentType: 'text'\n    }\n    splice(events, contentStart, contentEnd - contentStart + 1, [\n      ['enter', content, context],\n      ['enter', text, context],\n      ['exit', text, context],\n      ['exit', content, context]\n    ])\n  }\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  let size = 0\n  return start\n\n  /**\n   * Start of a heading (atx).\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    effects.enter('atxHeading')\n    return before(code)\n  }\n\n  /**\n   * After optional whitespace, at `#`.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter('atxHeadingSequence')\n    return sequenceOpen(code)\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code)\n      return sequenceOpen\n    }\n\n    // Always at least one `#`.\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingSequence')\n      return atBreak(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ## aa\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === 35) {\n      effects.enter('atxHeadingSequence')\n      return sequenceFurther(code)\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('atxHeading')\n      // To do: interrupt like `markdown-rs`.\n      // // Feel free to interrupt.\n      // tokenizer.interrupt = false\n      return ok(code)\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, 'whitespace')(code)\n    }\n\n    // To do: generate `data` tokens, add the `text` token later.\n    // Needs edit map, see: `markdown.rs`.\n    effects.enter('atxHeadingText')\n    return data(code)\n  }\n\n  /**\n   * In further sequence (after whitespace).\n   *\n   * Could be normal “visible” hashes in the heading or a final sequence.\n   *\n   * ```markdown\n   * > | ## aa ##\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceFurther(code) {\n    if (code === 35) {\n      effects.consume(code)\n      return sequenceFurther\n    }\n    effects.exit('atxHeadingSequence')\n    return atBreak(code)\n  }\n\n  /**\n   * In text.\n   *\n   * ```markdown\n   * > | ## aa\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingText')\n      return atBreak(code)\n    }\n    effects.consume(code)\n    return data\n  }\n}\n","/**\n * List of lowercase HTML “block” tag names.\n *\n * The list, when parsing HTML (flow), results in more relaxed rules (condition\n * 6).\n * Because they are known blocks, the HTML-like syntax doesn’t have to be\n * strictly parsed.\n * For tag names not in this list, a more strict algorithm (condition 7) is used\n * to detect whether the HTML-like syntax is seen as HTML (flow) or not.\n *\n * This is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `search` was added in `CommonMark@0.31`.\n */\nexport const htmlBlockNames = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'search',\n  'section',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n]\n\n/**\n * List of lowercase HTML “raw” tag names.\n *\n * The list, when parsing HTML (flow), results in HTML that can include lines\n * without exiting, until a closing tag also in this list is found (condition\n * 1).\n *\n * This module is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `textarea` was added in `CommonMark@0.30`.\n */\nexport const htmlRawNames = ['pre', 'script', 'style', 'textarea']\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {htmlBlockNames, htmlRawNames} from 'micromark-util-html-tag-name'\nimport {blankLine} from './blank-line.js'\n\n/** @type {Construct} */\nexport const htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n}\n\n/** @type {Construct} */\nconst blankLineBefore = {\n  tokenize: tokenizeBlankLineBefore,\n  partial: true\n}\nconst nonLazyContinuationStart = {\n  tokenize: tokenizeNonLazyContinuationStart,\n  partial: true\n}\n\n/** @type {Resolver} */\nfunction resolveToHtmlFlow(events) {\n  let index = events.length\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {\n      break\n    }\n  }\n  if (index > 1 && events[index - 2][1].type === 'linePrefix') {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start\n    // Add the prefix start to the HTML line token.\n    events[index + 1][1].start = events[index - 2][1].start\n    // Remove the line prefix.\n    events.splice(index - 2, 2)\n  }\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  const self = this\n  /** @type {number} */\n  let marker\n  /** @type {boolean} */\n  let closingTag\n  /** @type {string} */\n  let buffer\n  /** @type {number} */\n  let index\n  /** @type {Code} */\n  let markerB\n  return start\n\n  /**\n   * Start of HTML (flow).\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    return before(code)\n  }\n\n  /**\n   * At `<`, after optional whitespace.\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter('htmlFlow')\n    effects.enter('htmlFlowData')\n    effects.consume(code)\n    return open\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | <x />\n   *      ^\n   * > | <!doctype>\n   *      ^\n   * > | <!--xxx-->\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationOpen\n    }\n    if (code === 47) {\n      effects.consume(code)\n      closingTag = true\n      return tagCloseStart\n    }\n    if (code === 63) {\n      effects.consume(code)\n      marker = 3\n      // To do:\n      // tokenizer.concrete = true\n      // To do: use `markdown-rs` style interrupt.\n      // While we’re in an instruction instead of a declaration, we’re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      // @ts-expect-error: not null.\n      buffer = String.fromCharCode(code)\n      return tagName\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *       ^\n   * > | <!--xxx-->\n   *       ^\n   * > | <![CDATA[>&<]]>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      marker = 2\n      return commentOpenInside\n    }\n    if (code === 91) {\n      effects.consume(code)\n      marker = 5\n      index = 0\n      return cdataOpenInside\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      marker = 4\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `<!-`, inside a comment, at another `-`.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `<![`, inside CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *        ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = 'CDATA['\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code)\n      if (index === value.length) {\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok : continuation\n      }\n      return cdataOpenInside\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | </x>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      // @ts-expect-error: not null.\n      buffer = String.fromCharCode(code)\n      return tagName\n    }\n    return nok(code)\n  }\n\n  /**\n   * In tag name.\n   *\n   * ```markdown\n   * > | <ab>\n   *      ^^\n   * > | </ab>\n   *       ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagName(code) {\n    if (\n      code === null ||\n      code === 47 ||\n      code === 62 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      const slash = code === 47\n      const name = buffer.toLowerCase()\n      if (!slash && !closingTag && htmlRawNames.includes(name)) {\n        marker = 1\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n      if (htmlBlockNames.includes(buffer.toLowerCase())) {\n        marker = 6\n        if (slash) {\n          effects.consume(code)\n          return basicSelfClosing\n        }\n\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n      marker = 7\n      // Do not support complete HTML when interrupting.\n      return self.interrupt && !self.parser.lazy[self.now().line]\n        ? nok(code)\n        : closingTag\n        ? completeClosingTagAfter(code)\n        : completeAttributeNameBefore(code)\n    }\n\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      buffer += String.fromCharCode(code)\n      return tagName\n    }\n    return nok(code)\n  }\n\n  /**\n   * After closing slash of a basic tag name.\n   *\n   * ```markdown\n   * > | <div/>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code)\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuation\n    }\n    return nok(code)\n  }\n\n  /**\n   * After closing slash of a complete tag name.\n   *\n   * ```markdown\n   * > | <x/>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeClosingTagAfter\n    }\n    return completeEnd(code)\n  }\n\n  /**\n   * At an attribute name.\n   *\n   * At first, this state is used after a complete tag name, after whitespace,\n   * where it expects optional attributes or the end of the tag.\n   * It is also reused after attributes, when expecting more optional\n   * attributes.\n   *\n   * ```markdown\n   * > | <a />\n   *        ^\n   * > | <a :b>\n   *        ^\n   * > | <a _b>\n   *        ^\n   * > | <a b>\n   *        ^\n   * > | <a >\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return completeEnd\n    }\n\n    // ASCII alphanumerical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameBefore\n    }\n    return completeEnd(code)\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | <a :b>\n   *         ^\n   * > | <a _b>\n   *         ^\n   * > | <a b>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeName(code) {\n    // ASCII alphanumerical and `-`, `.`, `:`, and `_`.\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n    return completeAttributeNameAfter(code)\n  }\n\n  /**\n   * After attribute name, at an optional initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b>\n   *         ^\n   * > | <a b=c>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameAfter\n    }\n    return completeAttributeNameBefore(code)\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * > | <a b=\"c\">\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      markerB = code\n      return completeAttributeValueQuoted\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n    return completeAttributeValueUnquoted(code)\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *           ^\n   * > | <a b='c'>\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuoted(code) {\n    if (code === markerB) {\n      effects.consume(code)\n      markerB = null\n      return completeAttributeValueQuotedAfter\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return completeAttributeValueQuoted\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 47 ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      return completeAttributeNameAfter(code)\n    }\n    effects.consume(code)\n    return completeAttributeValueUnquoted\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the\n   * end of the tag.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * In certain circumstances of a complete tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return completeAfter\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `>` in a complete tag.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return continuation(code)\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAfter\n    }\n    return nok(code)\n  }\n\n  /**\n   * In continuation of any HTML kind.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuation(code) {\n    if (code === 45 && marker === 2) {\n      effects.consume(code)\n      return continuationCommentInside\n    }\n    if (code === 60 && marker === 1) {\n      effects.consume(code)\n      return continuationRawTagOpen\n    }\n    if (code === 62 && marker === 4) {\n      effects.consume(code)\n      return continuationClose\n    }\n    if (code === 63 && marker === 3) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n    if (code === 93 && marker === 5) {\n      effects.consume(code)\n      return continuationCdataInside\n    }\n    if (markdownLineEnding(code) && (marker === 6 || marker === 7)) {\n      effects.exit('htmlFlowData')\n      return effects.check(\n        blankLineBefore,\n        continuationAfter,\n        continuationStart\n      )(code)\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData')\n      return continuationStart(code)\n    }\n    effects.consume(code)\n    return continuation\n  }\n\n  /**\n   * In continuation, at eol.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStart(code) {\n    return effects.check(\n      nonLazyContinuationStart,\n      continuationStartNonLazy,\n      continuationAfter\n    )(code)\n  }\n\n  /**\n   * In continuation, at eol, before non-lazy content.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStartNonLazy(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return continuationBefore\n  }\n\n  /**\n   * In continuation, before non-lazy content.\n   *\n   * ```markdown\n   *   | <x>\n   * > | asd\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return continuationStart(code)\n    }\n    effects.enter('htmlFlowData')\n    return continuation(code)\n  }\n\n  /**\n   * In comment continuation, after one `-`, expecting another.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n    return continuation(code)\n  }\n\n  /**\n   * In raw continuation, after `<`, at `/`.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code)\n      buffer = ''\n      return continuationRawEndTag\n    }\n    return continuation(code)\n  }\n\n  /**\n   * In raw continuation, after `</`, in a raw tag name.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                             ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawEndTag(code) {\n    if (code === 62) {\n      const name = buffer.toLowerCase()\n      if (htmlRawNames.includes(name)) {\n        effects.consume(code)\n        return continuationClose\n      }\n      return continuation(code)\n    }\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code)\n      // @ts-expect-error: not null.\n      buffer += String.fromCharCode(code)\n      return continuationRawEndTag\n    }\n    return continuation(code)\n  }\n\n  /**\n   * In cdata continuation, after `]`, expecting `]>`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *                  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCdataInside(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n    return continuation(code)\n  }\n\n  /**\n   * In declaration or instruction continuation, at `>`.\n   *\n   * ```markdown\n   * > | <!-->\n   *         ^\n   * > | <?>\n   *       ^\n   * > | <!q>\n   *        ^\n   * > | <!--ab-->\n   *             ^\n   * > | <![CDATA[>&<]]>\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    // More dashes.\n    if (code === 45 && marker === 2) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n    return continuation(code)\n  }\n\n  /**\n   * In closed continuation: everything we get until the eol/eof is part of it.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData')\n      return continuationAfter(code)\n    }\n    effects.consume(code)\n    return continuationClose\n  }\n\n  /**\n   * Done.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationAfter(code) {\n    effects.exit('htmlFlow')\n    // // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    // // No longer concrete.\n    // tokenizer.concrete = false\n    return ok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuationStart(effects, ok, nok) {\n  const self = this\n  return start\n\n  /**\n   * At eol, before continuation.\n   *\n   * ```markdown\n   * > | * ```js\n   *            ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return after\n    }\n    return nok(code)\n  }\n\n  /**\n   * A continuation.\n   *\n   * ```markdown\n   *   | * ```js\n   * > | b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLineBefore(effects, ok, nok) {\n  return start\n\n  /**\n   * Before eol, expecting blank line.\n   *\n   * ```markdown\n   * > | <div>\n   *          ^\n   *   |\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return effects.attempt(blankLine, ok, nok)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\n/** @type {Construct} */\nexport const htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlText(effects, ok, nok) {\n  const self = this\n  /** @type {NonNullable<Code> | undefined} */\n  let marker\n  /** @type {number} */\n  let index\n  /** @type {State} */\n  let returnState\n  return start\n\n  /**\n   * Start of HTML (text).\n   *\n   * ```markdown\n   * > | a <b> c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('htmlText')\n    effects.enter('htmlTextData')\n    effects.consume(code)\n    return open\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | a <b> c\n   *        ^\n   * > | a <!doctype> c\n   *        ^\n   * > | a <!--b--> c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationOpen\n    }\n    if (code === 47) {\n      effects.consume(code)\n      return tagCloseStart\n    }\n    if (code === 63) {\n      effects.consume(code)\n      return instruction\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | a <!doctype> c\n   *         ^\n   * > | a <!--b--> c\n   *         ^\n   * > | a <![CDATA[>&<]]> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentOpenInside\n    }\n    if (code === 91) {\n      effects.consume(code)\n      index = 0\n      return cdataOpenInside\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return declaration\n    }\n    return nok(code)\n  }\n\n  /**\n   * In a comment, after `<!-`, at another `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentEnd\n    }\n    return nok(code)\n  }\n\n  /**\n   * In comment.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function comment(code) {\n    if (code === null) {\n      return nok(code)\n    }\n    if (code === 45) {\n      effects.consume(code)\n      return commentClose\n    }\n    if (markdownLineEnding(code)) {\n      returnState = comment\n      return lineEndingBefore(code)\n    }\n    effects.consume(code)\n    return comment\n  }\n\n  /**\n   * In comment, after `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentEnd\n    }\n    return comment(code)\n  }\n\n  /**\n   * In comment, after `--`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentEnd(code) {\n    return code === 62\n      ? end(code)\n      : code === 45\n      ? commentClose(code)\n      : comment(code)\n  }\n\n  /**\n   * After `<![`, in CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *          ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = 'CDATA['\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code)\n      return index === value.length ? cdata : cdataOpenInside\n    }\n    return nok(code)\n  }\n\n  /**\n   * In CDATA.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdata(code) {\n    if (code === null) {\n      return nok(code)\n    }\n    if (code === 93) {\n      effects.consume(code)\n      return cdataClose\n    }\n    if (markdownLineEnding(code)) {\n      returnState = cdata\n      return lineEndingBefore(code)\n    }\n    effects.consume(code)\n    return cdata\n  }\n\n  /**\n   * In CDATA, after `]`, at another `]`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n    return cdata(code)\n  }\n\n  /**\n   * In CDATA, after `]]`, at `>`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code)\n    }\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n    return cdata(code)\n  }\n\n  /**\n   * In declaration.\n   *\n   * ```markdown\n   * > | a <!b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code)\n    }\n    if (markdownLineEnding(code)) {\n      returnState = declaration\n      return lineEndingBefore(code)\n    }\n    effects.consume(code)\n    return declaration\n  }\n\n  /**\n   * In instruction.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instruction(code) {\n    if (code === null) {\n      return nok(code)\n    }\n    if (code === 63) {\n      effects.consume(code)\n      return instructionClose\n    }\n    if (markdownLineEnding(code)) {\n      returnState = instruction\n      return lineEndingBefore(code)\n    }\n    effects.consume(code)\n    return instruction\n  }\n\n  /**\n   * In instruction, after `?`, at `>`.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code)\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `</x`, in a tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagClose(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n    return tagCloseBetween(code)\n  }\n\n  /**\n   * In closing tag, after tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween\n      return lineEndingBefore(code)\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagCloseBetween\n    }\n    return end(code)\n  }\n\n  /**\n   * After `<x`, in opening tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpen(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * In opening tag, after tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return end\n    }\n\n    // ASCII alphabetical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween\n      return lineEndingBefore(code)\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenBetween\n    }\n    return end(code)\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeName(code) {\n    // ASCII alphabetical and `-`, `.`, `:`, and `_`.\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n    return tagOpenAttributeNameAfter(code)\n  }\n\n  /**\n   * After attribute name, before initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter\n      return lineEndingBefore(code)\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeNameAfter\n    }\n    return tagOpenBetween(code)\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      marker = code\n      return tagOpenAttributeValueQuoted\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore\n      return lineEndingBefore(code)\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n    effects.consume(code)\n    return tagOpenAttributeValueUnquoted\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code)\n      marker = undefined\n      return tagOpenAttributeValueQuotedAfter\n    }\n    if (code === null) {\n      return nok(code)\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted\n      return lineEndingBefore(code)\n    }\n    effects.consume(code)\n    return tagOpenAttributeValueQuoted\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 60 ||\n      code === 61 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n    effects.consume(code)\n    return tagOpenAttributeValueUnquoted\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the end\n   * of the tag.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * In certain circumstances of a tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function end(code) {\n    if (code === 62) {\n      effects.consume(code)\n      effects.exit('htmlTextData')\n      effects.exit('htmlText')\n      return ok\n    }\n    return nok(code)\n  }\n\n  /**\n   * At eol.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   * > | a <!--a\n   *            ^\n   *   | b-->\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingBefore(code) {\n    effects.exit('htmlTextData')\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return lineEndingAfter\n  }\n\n  /**\n   * After eol, at optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfter(code) {\n    // Always populated by defaults.\n\n    return markdownSpace(code)\n      ? factorySpace(\n          effects,\n          lineEndingAfterPrefix,\n          'linePrefix',\n          self.parser.constructs.disable.null.includes('codeIndented')\n            ? undefined\n            : 4\n        )(code)\n      : lineEndingAfterPrefix(code)\n  }\n\n  /**\n   * After eol, after optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfterPrefix(code) {\n    effects.enter('htmlTextData')\n    return returnState(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factoryDestination} from 'micromark-factory-destination'\nimport {factoryLabel} from 'micromark-factory-label'\nimport {factoryTitle} from 'micromark-factory-title'\nimport {factoryWhitespace} from 'micromark-factory-whitespace'\nimport {markdownLineEndingOrSpace} from 'micromark-util-character'\nimport {push, splice} from 'micromark-util-chunked'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {resolveAll} from 'micromark-util-resolve-all'\n/** @type {Construct} */\nexport const labelEnd = {\n  name: 'labelEnd',\n  tokenize: tokenizeLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  resolveAll: resolveAllLabelEnd\n}\n\n/** @type {Construct} */\nconst resourceConstruct = {\n  tokenize: tokenizeResource\n}\n/** @type {Construct} */\nconst referenceFullConstruct = {\n  tokenize: tokenizeReferenceFull\n}\n/** @type {Construct} */\nconst referenceCollapsedConstruct = {\n  tokenize: tokenizeReferenceCollapsed\n}\n\n/** @type {Resolver} */\nfunction resolveAllLabelEnd(events) {\n  let index = -1\n  while (++index < events.length) {\n    const token = events[index][1]\n    if (\n      token.type === 'labelImage' ||\n      token.type === 'labelLink' ||\n      token.type === 'labelEnd'\n    ) {\n      // Remove the marker.\n      events.splice(index + 1, token.type === 'labelImage' ? 4 : 2)\n      token.type = 'data'\n      index++\n    }\n  }\n  return events\n}\n\n/** @type {Resolver} */\nfunction resolveToLabelEnd(events, context) {\n  let index = events.length\n  let offset = 0\n  /** @type {Token} */\n  let token\n  /** @type {number | undefined} */\n  let open\n  /** @type {number | undefined} */\n  let close\n  /** @type {Array<Event>} */\n  let media\n\n  // Find an opening.\n  while (index--) {\n    token = events[index][1]\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (\n        token.type === 'link' ||\n        (token.type === 'labelLink' && token._inactive)\n      ) {\n        break\n      }\n\n      // Mark other link openings as inactive, as we can’t have links in\n      // links.\n      if (events[index][0] === 'enter' && token.type === 'labelLink') {\n        token._inactive = true\n      }\n    } else if (close) {\n      if (\n        events[index][0] === 'enter' &&\n        (token.type === 'labelImage' || token.type === 'labelLink') &&\n        !token._balanced\n      ) {\n        open = index\n        if (token.type !== 'labelLink') {\n          offset = 2\n          break\n        }\n      }\n    } else if (token.type === 'labelEnd') {\n      close = index\n    }\n  }\n  const group = {\n    type: events[open][1].type === 'labelLink' ? 'link' : 'image',\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  }\n  const label = {\n    type: 'label',\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[close][1].end)\n  }\n  const text = {\n    type: 'labelText',\n    start: Object.assign({}, events[open + offset + 2][1].end),\n    end: Object.assign({}, events[close - 2][1].start)\n  }\n  media = [\n    ['enter', group, context],\n    ['enter', label, context]\n  ]\n\n  // Opening marker.\n  media = push(media, events.slice(open + 1, open + offset + 3))\n\n  // Text open.\n  media = push(media, [['enter', text, context]])\n\n  // Always populated by defaults.\n\n  // Between.\n  media = push(\n    media,\n    resolveAll(\n      context.parser.constructs.insideSpan.null,\n      events.slice(open + offset + 4, close - 3),\n      context\n    )\n  )\n\n  // Text close, marker close, label close.\n  media = push(media, [\n    ['exit', text, context],\n    events[close - 2],\n    events[close - 1],\n    ['exit', label, context]\n  ])\n\n  // Reference, resource, or so.\n  media = push(media, events.slice(close + 1))\n\n  // Media close.\n  media = push(media, [['exit', group, context]])\n  splice(events, open, events.length, media)\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  const self = this\n  let index = self.events.length\n  /** @type {Token} */\n  let labelStart\n  /** @type {boolean} */\n  let defined\n\n  // Find an opening.\n  while (index--) {\n    if (\n      (self.events[index][1].type === 'labelImage' ||\n        self.events[index][1].type === 'labelLink') &&\n      !self.events[index][1]._balanced\n    ) {\n      labelStart = self.events[index][1]\n      break\n    }\n  }\n  return start\n\n  /**\n   * Start of label end.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // If there is not an okay opening.\n    if (!labelStart) {\n      return nok(code)\n    }\n\n    // If the corresponding label (link) start is marked as inactive,\n    // it means we’d be wrapping a link, like this:\n    //\n    // ```markdown\n    // > | a [b [c](d) e](f) g.\n    //                  ^\n    // ```\n    //\n    // We can’t have that, so it’s just balanced brackets.\n    if (labelStart._inactive) {\n      return labelEndNok(code)\n    }\n    defined = self.parser.defined.includes(\n      normalizeIdentifier(\n        self.sliceSerialize({\n          start: labelStart.end,\n          end: self.now()\n        })\n      )\n    )\n    effects.enter('labelEnd')\n    effects.enter('labelMarker')\n    effects.consume(code)\n    effects.exit('labelMarker')\n    effects.exit('labelEnd')\n    return after\n  }\n\n  /**\n   * After `]`.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // Note: `markdown-rs` also parses GFM footnotes here, which for us is in\n    // an extension.\n\n    // Resource (`[asd](fgh)`)?\n    if (code === 40) {\n      return effects.attempt(\n        resourceConstruct,\n        labelEndOk,\n        defined ? labelEndOk : labelEndNok\n      )(code)\n    }\n\n    // Full (`[asd][fgh]`) or collapsed (`[asd][]`) reference?\n    if (code === 91) {\n      return effects.attempt(\n        referenceFullConstruct,\n        labelEndOk,\n        defined ? referenceNotFull : labelEndNok\n      )(code)\n    }\n\n    // Shortcut (`[asd]`) reference?\n    return defined ? labelEndOk(code) : labelEndNok(code)\n  }\n\n  /**\n   * After `]`, at `[`, but not at a full reference.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] b\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceNotFull(code) {\n    return effects.attempt(\n      referenceCollapsedConstruct,\n      labelEndOk,\n      labelEndNok\n    )(code)\n  }\n\n  /**\n   * Done, we found something.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *           ^\n   * > | [a][b] c\n   *           ^\n   * > | [a][] b\n   *          ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndOk(code) {\n    // Note: `markdown-rs` does a bunch of stuff here.\n    return ok(code)\n  }\n\n  /**\n   * Done, it’s nothing.\n   *\n   * There was an okay opening, but we didn’t match anything.\n   *\n   * ```markdown\n   * > | [a](b c\n   *        ^\n   * > | [a][b c\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndNok(code) {\n    labelStart._balanced = true\n    return nok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeResource(effects, ok, nok) {\n  return resourceStart\n\n  /**\n   * At a resource.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceStart(code) {\n    effects.enter('resource')\n    effects.enter('resourceMarker')\n    effects.consume(code)\n    effects.exit('resourceMarker')\n    return resourceBefore\n  }\n\n  /**\n   * In resource, after `(`, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBefore(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, resourceOpen)(code)\n      : resourceOpen(code)\n  }\n\n  /**\n   * In resource, after optional whitespace, at `)` or a destination.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceOpen(code) {\n    if (code === 41) {\n      return resourceEnd(code)\n    }\n    return factoryDestination(\n      effects,\n      resourceDestinationAfter,\n      resourceDestinationMissing,\n      'resourceDestination',\n      'resourceDestinationLiteral',\n      'resourceDestinationLiteralMarker',\n      'resourceDestinationRaw',\n      'resourceDestinationString',\n      32\n    )(code)\n  }\n\n  /**\n   * In resource, after destination, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationAfter(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, resourceBetween)(code)\n      : resourceEnd(code)\n  }\n\n  /**\n   * At invalid destination.\n   *\n   * ```markdown\n   * > | [a](<<) b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationMissing(code) {\n    return nok(code)\n  }\n\n  /**\n   * In resource, after destination and whitespace, at `(` or title.\n   *\n   * ```markdown\n   * > | [a](b ) c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBetween(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(\n        effects,\n        resourceTitleAfter,\n        nok,\n        'resourceTitle',\n        'resourceTitleMarker',\n        'resourceTitleString'\n      )(code)\n    }\n    return resourceEnd(code)\n  }\n\n  /**\n   * In resource, after title, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b \"c\") d\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceTitleAfter(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, resourceEnd)(code)\n      : resourceEnd(code)\n  }\n\n  /**\n   * In resource, at `)`.\n   *\n   * ```markdown\n   * > | [a](b) d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceEnd(code) {\n    if (code === 41) {\n      effects.enter('resourceMarker')\n      effects.consume(code)\n      effects.exit('resourceMarker')\n      effects.exit('resource')\n      return ok\n    }\n    return nok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceFull(effects, ok, nok) {\n  const self = this\n  return referenceFull\n\n  /**\n   * In a reference (full), at the `[`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFull(code) {\n    return factoryLabel.call(\n      self,\n      effects,\n      referenceFullAfter,\n      referenceFullMissing,\n      'reference',\n      'referenceMarker',\n      'referenceString'\n    )(code)\n  }\n\n  /**\n   * In a reference (full), after `]`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullAfter(code) {\n    return self.parser.defined.includes(\n      normalizeIdentifier(\n        self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n      )\n    )\n      ? ok(code)\n      : nok(code)\n  }\n\n  /**\n   * In reference (full) that was missing.\n   *\n   * ```markdown\n   * > | [a][b d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullMissing(code) {\n    return nok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceCollapsed(effects, ok, nok) {\n  return referenceCollapsedStart\n\n  /**\n   * In reference (collapsed), at `[`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceCollapsedStart(code) {\n    // We only attempt a collapsed label if there’s a `[`.\n\n    effects.enter('reference')\n    effects.enter('referenceMarker')\n    effects.consume(code)\n    effects.exit('referenceMarker')\n    return referenceCollapsedOpen\n  }\n\n  /**\n   * In reference (collapsed), at `]`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *         ^\n   * ```\n   *\n   *  @type {State}\n   */\n  function referenceCollapsedOpen(code) {\n    if (code === 93) {\n      effects.enter('referenceMarker')\n      effects.consume(code)\n      effects.exit('referenceMarker')\n      effects.exit('reference')\n      return ok\n    }\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {labelEnd} from './label-end.js'\n\n/** @type {Construct} */\nexport const labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  const self = this\n  return start\n\n  /**\n   * Start of label (image) start.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('labelImage')\n    effects.enter('labelImageMarker')\n    effects.consume(code)\n    effects.exit('labelImageMarker')\n    return open\n  }\n\n  /**\n   * After `!`, at `[`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 91) {\n      effects.enter('labelMarker')\n      effects.consume(code)\n      effects.exit('labelMarker')\n      effects.exit('labelImage')\n      return after\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `![`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *         ^\n   * ```\n   *\n   * This is needed in because, when GFM footnotes are enabled, images never\n   * form when started with a `^`.\n   * Instead, links form:\n   *\n   * ```markdown\n   * ![^a](b)\n   *\n   * ![^a][b]\n   *\n   * [b]: c\n   * ```\n   *\n   * ```html\n   * <p>!<a href=\\\"b\\\">^a</a></p>\n   * <p>!<a href=\\\"c\\\">^a</a></p>\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // To do: use a new field to do this, this is still needed for\n    // `micromark-extension-gfm-footnote`, but the `label-start-link`\n    // behavior isn’t.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs\n      ? nok(code)\n      : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {labelEnd} from './label-end.js'\n\n/** @type {Construct} */\nexport const labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  const self = this\n  return start\n\n  /**\n   * Start of label (link) start.\n   *\n   * ```markdown\n   * > | a [b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('labelLink')\n    effects.enter('labelMarker')\n    effects.consume(code)\n    effects.exit('labelMarker')\n    effects.exit('labelLink')\n    return after\n  }\n\n  /** @type {State} */\n  function after(code) {\n    // To do: this isn’t needed in `micromark-extension-gfm-footnote`,\n    // remove.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs\n      ? nok(code)\n      : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n/** @type {Construct} */\nexport const lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLineEnding(effects, ok) {\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, ok, 'linePrefix')\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').ContainerState} ContainerState\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {asciiDigit, markdownSpace} from 'micromark-util-character'\nimport {blankLine} from './blank-line.js'\nimport {thematicBreak} from './thematic-break.js'\n\n/** @type {Construct} */\nexport const list = {\n  name: 'list',\n  tokenize: tokenizeListStart,\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd\n}\n\n/** @type {Construct} */\nconst listItemPrefixWhitespaceConstruct = {\n  tokenize: tokenizeListItemPrefixWhitespace,\n  partial: true\n}\n\n/** @type {Construct} */\nconst indentConstruct = {\n  tokenize: tokenizeIndent,\n  partial: true\n}\n\n// To do: `markdown-rs` parses list items on their own and later stitches them\n// together.\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeListStart(effects, ok, nok) {\n  const self = this\n  const tail = self.events[self.events.length - 1]\n  let initialSize =\n    tail && tail[1].type === 'linePrefix'\n      ? tail[2].sliceSerialize(tail[1], true).length\n      : 0\n  let size = 0\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    const kind =\n      self.containerState.type ||\n      (code === 42 || code === 43 || code === 45\n        ? 'listUnordered'\n        : 'listOrdered')\n    if (\n      kind === 'listUnordered'\n        ? !self.containerState.marker || code === self.containerState.marker\n        : asciiDigit(code)\n    ) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind\n        effects.enter(kind, {\n          _container: true\n        })\n      }\n      if (kind === 'listUnordered') {\n        effects.enter('listItemPrefix')\n        return code === 42 || code === 45\n          ? effects.check(thematicBreak, nok, atMarker)(code)\n          : atMarker(code)\n      }\n      if (!self.interrupt || code === 49) {\n        effects.enter('listItemPrefix')\n        effects.enter('listItemValue')\n        return inside(code)\n      }\n    }\n    return nok(code)\n  }\n\n  /** @type {State} */\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code)\n      return inside\n    }\n    if (\n      (!self.interrupt || size < 2) &&\n      (self.containerState.marker\n        ? code === self.containerState.marker\n        : code === 41 || code === 46)\n    ) {\n      effects.exit('listItemValue')\n      return atMarker(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * @type {State}\n   **/\n  function atMarker(code) {\n    effects.enter('listItemMarker')\n    effects.consume(code)\n    effects.exit('listItemMarker')\n    self.containerState.marker = self.containerState.marker || code\n    return effects.check(\n      blankLine,\n      // Can’t be empty when interrupting.\n      self.interrupt ? nok : onBlank,\n      effects.attempt(\n        listItemPrefixWhitespaceConstruct,\n        endOfPrefix,\n        otherPrefix\n      )\n    )\n  }\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true\n    initialSize++\n    return endOfPrefix(code)\n  }\n\n  /** @type {State} */\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter('listItemPrefixWhitespace')\n      effects.consume(code)\n      effects.exit('listItemPrefixWhitespace')\n      return endOfPrefix\n    }\n    return nok(code)\n  }\n\n  /** @type {State} */\n  function endOfPrefix(code) {\n    self.containerState.size =\n      initialSize +\n      self.sliceSerialize(effects.exit('listItemPrefix'), true).length\n    return ok(code)\n  }\n}\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeListContinuation(effects, ok, nok) {\n  const self = this\n  self.containerState._closeFlow = undefined\n  return effects.check(blankLine, onBlank, notBlank)\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.furtherBlankLines =\n      self.containerState.furtherBlankLines ||\n      self.containerState.initialBlankLine\n\n    // We have a blank line.\n    // Still, try to consume at most the items size.\n    return factorySpace(\n      effects,\n      ok,\n      'listItemIndent',\n      self.containerState.size + 1\n    )(code)\n  }\n\n  /** @type {State} */\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = undefined\n      self.containerState.initialBlankLine = undefined\n      return notInCurrentItem(code)\n    }\n    self.containerState.furtherBlankLines = undefined\n    self.containerState.initialBlankLine = undefined\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code)\n  }\n\n  /** @type {State} */\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true\n    // As we’re closing flow, we’re no longer interrupting.\n    self.interrupt = undefined\n    // Always populated by defaults.\n\n    return factorySpace(\n      effects,\n      effects.attempt(list, ok, nok),\n      'linePrefix',\n      self.parser.constructs.disable.null.includes('codeIndented')\n        ? undefined\n        : 4\n    )(code)\n  }\n}\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemIndent',\n    self.containerState.size + 1\n  )\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'listItemIndent' &&\n      tail[2].sliceSerialize(tail[1], true).length === self.containerState.size\n      ? ok(code)\n      : nok(code)\n  }\n}\n\n/**\n * @type {Exiter}\n * @this {TokenizeContext}\n */\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type)\n}\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  const self = this\n\n  // Always populated by defaults.\n\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemPrefixWhitespace',\n    self.parser.constructs.disable.null.includes('codeIndented')\n      ? undefined\n      : 4 + 1\n  )\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return !markdownSpace(code) &&\n      tail &&\n      tail[1].type === 'listItemPrefixWhitespace'\n      ? ok(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nexport const setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\n}\n\n/** @type {Resolver} */\nfunction resolveToSetextUnderline(events, context) {\n  // To do: resolve like `markdown-rs`.\n  let index = events.length\n  /** @type {number | undefined} */\n  let content\n  /** @type {number | undefined} */\n  let text\n  /** @type {number | undefined} */\n  let definition\n\n  // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === 'content') {\n        content = index\n        break\n      }\n      if (events[index][1].type === 'paragraph') {\n        text = index\n      }\n    }\n    // Exit\n    else {\n      if (events[index][1].type === 'content') {\n        // Remove the content end (if needed we’ll add it later)\n        events.splice(index, 1)\n      }\n      if (!definition && events[index][1].type === 'definition') {\n        definition = index\n      }\n    }\n  }\n  const heading = {\n    type: 'setextHeading',\n    start: Object.assign({}, events[text][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  }\n\n  // Change the paragraph to setext heading text.\n  events[text][1].type = 'setextHeadingText'\n\n  // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context])\n    events.splice(definition + 1, 0, ['exit', events[content][1], context])\n    events[content][1].end = Object.assign({}, events[definition][1].end)\n  } else {\n    events[content][1] = heading\n  }\n\n  // Add the heading exit at the end.\n  events.push(['exit', heading, context])\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  const self = this\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n\n  /**\n   * At start of heading (setext) underline.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    let index = self.events.length\n    /** @type {boolean | undefined} */\n    let paragraph\n    // Find an opening.\n    while (index--) {\n      // Skip enter/exit of line ending, line prefix, and content.\n      // We can now either have a definition or a paragraph.\n      if (\n        self.events[index][1].type !== 'lineEnding' &&\n        self.events[index][1].type !== 'linePrefix' &&\n        self.events[index][1].type !== 'content'\n      ) {\n        paragraph = self.events[index][1].type === 'paragraph'\n        break\n      }\n    }\n\n    // To do: handle lazy/pierce like `markdown-rs`.\n    // To do: parse indent like `markdown-rs`.\n    if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {\n      effects.enter('setextHeadingLine')\n      marker = code\n      return before(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * After optional whitespace, at `-` or `=`.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter('setextHeadingLineSequence')\n    return inside(code)\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return inside\n    }\n    effects.exit('setextHeadingLineSequence')\n    return markdownSpace(code)\n      ? factorySpace(effects, after, 'lineSuffix')(code)\n      : after(code)\n  }\n\n  /**\n   * After sequence, after optional whitespace.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('setextHeadingLine')\n      return ok(code)\n    }\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nexport const thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  let size = 0\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n\n  /**\n   * Start of thematic break.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('thematicBreak')\n    // To do: parse indent like `markdown-rs`.\n    return before(code)\n  }\n\n  /**\n   * After optional whitespace, at marker.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    marker = code\n    return atBreak(code)\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter('thematicBreakSequence')\n      return sequence(code)\n    }\n    if (size >= 3 && (code === null || markdownLineEnding(code))) {\n      effects.exit('thematicBreak')\n      return ok(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      size++\n      return sequence\n    }\n    effects.exit('thematicBreakSequence')\n    return markdownSpace(code)\n      ? factorySpace(effects, atBreak, 'whitespace')(code)\n      : atBreak(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Previous} Previous\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  asciiControl,\n  markdownLineEndingOrSpace,\n  unicodePunctuation,\n  unicodeWhitespace\n} from 'micromark-util-character'\nconst wwwPrefix = {\n  tokenize: tokenizeWwwPrefix,\n  partial: true\n}\nconst domain = {\n  tokenize: tokenizeDomain,\n  partial: true\n}\nconst path = {\n  tokenize: tokenizePath,\n  partial: true\n}\nconst trail = {\n  tokenize: tokenizeTrail,\n  partial: true\n}\nconst emailDomainDotTrail = {\n  tokenize: tokenizeEmailDomainDotTrail,\n  partial: true\n}\nconst wwwAutolink = {\n  tokenize: tokenizeWwwAutolink,\n  previous: previousWww\n}\nconst protocolAutolink = {\n  tokenize: tokenizeProtocolAutolink,\n  previous: previousProtocol\n}\nconst emailAutolink = {\n  tokenize: tokenizeEmailAutolink,\n  previous: previousEmail\n}\n\n/** @type {ConstructRecord} */\nconst text = {}\n\n// To do: next major: expose functions that yields extension.\n\n/**\n * Extension for `micromark` that can be passed in `extensions` to enable GFM\n * autolink literal syntax.\n *\n * @type {Extension}\n */\nexport const gfmAutolinkLiteral = {\n  text\n}\n\n/** @type {Code} */\nlet code = 48\n\n// Add alphanumerics.\nwhile (code < 123) {\n  text[code] = emailAutolink\n  code++\n  if (code === 58) code = 65\n  else if (code === 91) code = 97\n}\ntext[43] = emailAutolink\ntext[45] = emailAutolink\ntext[46] = emailAutolink\ntext[95] = emailAutolink\ntext[72] = [emailAutolink, protocolAutolink]\ntext[104] = [emailAutolink, protocolAutolink]\ntext[87] = [emailAutolink, wwwAutolink]\ntext[119] = [emailAutolink, wwwAutolink]\n\n// To do: perform email autolink literals on events, afterwards.\n// That’s where `markdown-rs` and `cmark-gfm` perform it.\n// It should look for `@`, then for atext backwards, and then for a label\n// forwards.\n// To do: `mailto:`, `xmpp:` protocol as prefix.\n\n/**\n * Email autolink literal.\n *\n * ```markdown\n * > | a contact@example.org b\n *       ^^^^^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeEmailAutolink(effects, ok, nok) {\n  const self = this\n  /** @type {boolean | undefined} */\n  let dot\n  /** @type {boolean} */\n  let data\n  return start\n\n  /**\n   * Start of email autolink literal.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (\n      !gfmAtext(code) ||\n      !previousEmail.call(self, self.previous) ||\n      previousUnbalanced(self.events)\n    ) {\n      return nok(code)\n    }\n    effects.enter('literalAutolink')\n    effects.enter('literalAutolinkEmail')\n    return atext(code)\n  }\n\n  /**\n   * In email atext.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atext(code) {\n    if (gfmAtext(code)) {\n      effects.consume(code)\n      return atext\n    }\n    if (code === 64) {\n      effects.consume(code)\n      return emailDomain\n    }\n    return nok(code)\n  }\n\n  /**\n   * In email domain.\n   *\n   * The reference code is a bit overly complex as it handles the `@`, of which\n   * there may be just one.\n   * Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L318>\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailDomain(code) {\n    // Dot followed by alphanumerical (not `-` or `_`).\n    if (code === 46) {\n      return effects.check(\n        emailDomainDotTrail,\n        emailDomainAfter,\n        emailDomainDot\n      )(code)\n    }\n\n    // Alphanumerical, `-`, and `_`.\n    if (code === 45 || code === 95 || asciiAlphanumeric(code)) {\n      data = true\n      effects.consume(code)\n      return emailDomain\n    }\n\n    // To do: `/` if xmpp.\n\n    // Note: normally we’d truncate trailing punctuation from the link.\n    // However, email autolink literals cannot contain any of those markers,\n    // except for `.`, but that can only occur if it isn’t trailing.\n    // So we can ignore truncating!\n    return emailDomainAfter(code)\n  }\n\n  /**\n   * In email domain, on dot that is not a trail.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *                      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailDomainDot(code) {\n    effects.consume(code)\n    dot = true\n    return emailDomain\n  }\n\n  /**\n   * After email domain.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *                          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailDomainAfter(code) {\n    // Domain must not be empty, must include a dot, and must end in alphabetical.\n    // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L332>.\n    if (data && dot && asciiAlpha(self.previous)) {\n      effects.exit('literalAutolinkEmail')\n      effects.exit('literalAutolink')\n      return ok(code)\n    }\n    return nok(code)\n  }\n}\n\n/**\n * `www` autolink literal.\n *\n * ```markdown\n * > | a www.example.org b\n *       ^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeWwwAutolink(effects, ok, nok) {\n  const self = this\n  return wwwStart\n\n  /**\n   * Start of www autolink literal.\n   *\n   * ```markdown\n   * > | www.example.com/a?b#c\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwStart(code) {\n    if (\n      (code !== 87 && code !== 119) ||\n      !previousWww.call(self, self.previous) ||\n      previousUnbalanced(self.events)\n    ) {\n      return nok(code)\n    }\n    effects.enter('literalAutolink')\n    effects.enter('literalAutolinkWww')\n    // Note: we *check*, so we can discard the `www.` we parsed.\n    // If it worked, we consider it as a part of the domain.\n    return effects.check(\n      wwwPrefix,\n      effects.attempt(domain, effects.attempt(path, wwwAfter), nok),\n      nok\n    )(code)\n  }\n\n  /**\n   * After a www autolink literal.\n   *\n   * ```markdown\n   * > | www.example.com/a?b#c\n   *                          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwAfter(code) {\n    effects.exit('literalAutolinkWww')\n    effects.exit('literalAutolink')\n    return ok(code)\n  }\n}\n\n/**\n * Protocol autolink literal.\n *\n * ```markdown\n * > | a https://example.org b\n *       ^^^^^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeProtocolAutolink(effects, ok, nok) {\n  const self = this\n  let buffer = ''\n  let seen = false\n  return protocolStart\n\n  /**\n   * Start of protocol autolink literal.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolStart(code) {\n    if (\n      (code === 72 || code === 104) &&\n      previousProtocol.call(self, self.previous) &&\n      !previousUnbalanced(self.events)\n    ) {\n      effects.enter('literalAutolink')\n      effects.enter('literalAutolinkHttp')\n      buffer += String.fromCodePoint(code)\n      effects.consume(code)\n      return protocolPrefixInside\n    }\n    return nok(code)\n  }\n\n  /**\n   * In protocol.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *     ^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolPrefixInside(code) {\n    // `5` is size of `https`\n    if (asciiAlpha(code) && buffer.length < 5) {\n      // @ts-expect-error: definitely number.\n      buffer += String.fromCodePoint(code)\n      effects.consume(code)\n      return protocolPrefixInside\n    }\n    if (code === 58) {\n      const protocol = buffer.toLowerCase()\n      if (protocol === 'http' || protocol === 'https') {\n        effects.consume(code)\n        return protocolSlashesInside\n      }\n    }\n    return nok(code)\n  }\n\n  /**\n   * In slashes.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *           ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolSlashesInside(code) {\n    if (code === 47) {\n      effects.consume(code)\n      if (seen) {\n        return afterProtocol\n      }\n      seen = true\n      return protocolSlashesInside\n    }\n    return nok(code)\n  }\n\n  /**\n   * After protocol, before domain.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterProtocol(code) {\n    // To do: this is different from `markdown-rs`:\n    // https://github.com/wooorm/markdown-rs/blob/b3a921c761309ae00a51fe348d8a43adbc54b518/src/construct/gfm_autolink_literal.rs#L172-L182\n    return code === null ||\n      asciiControl(code) ||\n      markdownLineEndingOrSpace(code) ||\n      unicodeWhitespace(code) ||\n      unicodePunctuation(code)\n      ? nok(code)\n      : effects.attempt(domain, effects.attempt(path, protocolAfter), nok)(code)\n  }\n\n  /**\n   * After a protocol autolink literal.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *                              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolAfter(code) {\n    effects.exit('literalAutolinkHttp')\n    effects.exit('literalAutolink')\n    return ok(code)\n  }\n}\n\n/**\n * `www` prefix.\n *\n * ```markdown\n * > | a www.example.org b\n *       ^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeWwwPrefix(effects, ok, nok) {\n  let size = 0\n  return wwwPrefixInside\n\n  /**\n   * In www prefix.\n   *\n   * ```markdown\n   * > | www.example.com\n   *     ^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwPrefixInside(code) {\n    if ((code === 87 || code === 119) && size < 3) {\n      size++\n      effects.consume(code)\n      return wwwPrefixInside\n    }\n    if (code === 46 && size === 3) {\n      effects.consume(code)\n      return wwwPrefixAfter\n    }\n    return nok(code)\n  }\n\n  /**\n   * After www prefix.\n   *\n   * ```markdown\n   * > | www.example.com\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwPrefixAfter(code) {\n    // If there is *anything*, we can link.\n    return code === null ? nok(code) : ok(code)\n  }\n}\n\n/**\n * Domain.\n *\n * ```markdown\n * > | a https://example.org b\n *               ^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDomain(effects, ok, nok) {\n  /** @type {boolean | undefined} */\n  let underscoreInLastSegment\n  /** @type {boolean | undefined} */\n  let underscoreInLastLastSegment\n  /** @type {boolean | undefined} */\n  let seen\n  return domainInside\n\n  /**\n   * In domain.\n   *\n   * ```markdown\n   * > | https://example.com/a\n   *             ^^^^^^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function domainInside(code) {\n    // Check whether this marker, which is a trailing punctuation\n    // marker, optionally followed by more trailing markers, and then\n    // followed by an end.\n    if (code === 46 || code === 95) {\n      return effects.check(trail, domainAfter, domainAtPunctuation)(code)\n    }\n\n    // GH documents that only alphanumerics (other than `-`, `.`, and `_`) can\n    // occur, which sounds like ASCII only, but they also support `www.點看.com`,\n    // so that’s Unicode.\n    // Instead of some new production for Unicode alphanumerics, markdown\n    // already has that for Unicode punctuation and whitespace, so use those.\n    // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L12>.\n    if (\n      code === null ||\n      markdownLineEndingOrSpace(code) ||\n      unicodeWhitespace(code) ||\n      (code !== 45 && unicodePunctuation(code))\n    ) {\n      return domainAfter(code)\n    }\n    seen = true\n    effects.consume(code)\n    return domainInside\n  }\n\n  /**\n   * In domain, at potential trailing punctuation, that was not trailing.\n   *\n   * ```markdown\n   * > | https://example.com\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function domainAtPunctuation(code) {\n    // There is an underscore in the last segment of the domain\n    if (code === 95) {\n      underscoreInLastSegment = true\n    }\n    // Otherwise, it’s a `.`: save the last segment underscore in the\n    // penultimate segment slot.\n    else {\n      underscoreInLastLastSegment = underscoreInLastSegment\n      underscoreInLastSegment = undefined\n    }\n    effects.consume(code)\n    return domainInside\n  }\n\n  /**\n   * After domain.\n   *\n   * ```markdown\n   * > | https://example.com/a\n   *                        ^\n   * ```\n   *\n   * @type {State} */\n  function domainAfter(code) {\n    // Note: that’s GH says a dot is needed, but it’s not true:\n    // <https://github.com/github/cmark-gfm/issues/279>\n    if (underscoreInLastLastSegment || underscoreInLastSegment || !seen) {\n      return nok(code)\n    }\n    return ok(code)\n  }\n}\n\n/**\n * Path.\n *\n * ```markdown\n * > | a https://example.org/stuff b\n *                          ^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizePath(effects, ok) {\n  let sizeOpen = 0\n  let sizeClose = 0\n  return pathInside\n\n  /**\n   * In path.\n   *\n   * ```markdown\n   * > | https://example.com/a\n   *                        ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function pathInside(code) {\n    if (code === 40) {\n      sizeOpen++\n      effects.consume(code)\n      return pathInside\n    }\n\n    // To do: `markdown-rs` also needs this.\n    // If this is a paren, and there are less closings than openings,\n    // we don’t check for a trail.\n    if (code === 41 && sizeClose < sizeOpen) {\n      return pathAtPunctuation(code)\n    }\n\n    // Check whether this trailing punctuation marker is optionally\n    // followed by more trailing markers, and then followed\n    // by an end.\n    if (\n      code === 33 ||\n      code === 34 ||\n      code === 38 ||\n      code === 39 ||\n      code === 41 ||\n      code === 42 ||\n      code === 44 ||\n      code === 46 ||\n      code === 58 ||\n      code === 59 ||\n      code === 60 ||\n      code === 63 ||\n      code === 93 ||\n      code === 95 ||\n      code === 126\n    ) {\n      return effects.check(trail, ok, pathAtPunctuation)(code)\n    }\n    if (\n      code === null ||\n      markdownLineEndingOrSpace(code) ||\n      unicodeWhitespace(code)\n    ) {\n      return ok(code)\n    }\n    effects.consume(code)\n    return pathInside\n  }\n\n  /**\n   * In path, at potential trailing punctuation, that was not trailing.\n   *\n   * ```markdown\n   * > | https://example.com/a\"b\n   *                          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function pathAtPunctuation(code) {\n    // Count closing parens.\n    if (code === 41) {\n      sizeClose++\n    }\n    effects.consume(code)\n    return pathInside\n  }\n}\n\n/**\n * Trail.\n *\n * This calls `ok` if this *is* the trail, followed by an end, which means\n * the entire trail is not part of the link.\n * It calls `nok` if this *is* part of the link.\n *\n * ```markdown\n * > | https://example.com\").\n *                        ^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTrail(effects, ok, nok) {\n  return trail\n\n  /**\n   * In trail of domain or path.\n   *\n   * ```markdown\n   * > | https://example.com\").\n   *                        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trail(code) {\n    // Regular trailing punctuation.\n    if (\n      code === 33 ||\n      code === 34 ||\n      code === 39 ||\n      code === 41 ||\n      code === 42 ||\n      code === 44 ||\n      code === 46 ||\n      code === 58 ||\n      code === 59 ||\n      code === 63 ||\n      code === 95 ||\n      code === 126\n    ) {\n      effects.consume(code)\n      return trail\n    }\n\n    // `&` followed by one or more alphabeticals and then a `;`, is\n    // as a whole considered as trailing punctuation.\n    // In all other cases, it is considered as continuation of the URL.\n    if (code === 38) {\n      effects.consume(code)\n      return trailCharRefStart\n    }\n\n    // Needed because we allow literals after `[`, as we fix:\n    // <https://github.com/github/cmark-gfm/issues/278>.\n    // Check that it is not followed by `(` or `[`.\n    if (code === 93) {\n      effects.consume(code)\n      return trailBracketAfter\n    }\n    if (\n      // `<` is an end.\n      code === 60 ||\n      // So is whitespace.\n      code === null ||\n      markdownLineEndingOrSpace(code) ||\n      unicodeWhitespace(code)\n    ) {\n      return ok(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * In trail, after `]`.\n   *\n   * > 👉 **Note**: this deviates from `cmark-gfm` to fix a bug.\n   * > See end of <https://github.com/github/cmark-gfm/issues/278> for more.\n   *\n   * ```markdown\n   * > | https://example.com](\n   *                         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trailBracketAfter(code) {\n    // Whitespace or something that could start a resource or reference is the end.\n    // Switch back to trail otherwise.\n    if (\n      code === null ||\n      code === 40 ||\n      code === 91 ||\n      markdownLineEndingOrSpace(code) ||\n      unicodeWhitespace(code)\n    ) {\n      return ok(code)\n    }\n    return trail(code)\n  }\n\n  /**\n   * In character-reference like trail, after `&`.\n   *\n   * ```markdown\n   * > | https://example.com&amp;).\n   *                         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trailCharRefStart(code) {\n    // When non-alpha, it’s not a trail.\n    return asciiAlpha(code) ? trailCharRefInside(code) : nok(code)\n  }\n\n  /**\n   * In character-reference like trail.\n   *\n   * ```markdown\n   * > | https://example.com&amp;).\n   *                         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trailCharRefInside(code) {\n    // Switch back to trail if this is well-formed.\n    if (code === 59) {\n      effects.consume(code)\n      return trail\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return trailCharRefInside\n    }\n\n    // It’s not a trail.\n    return nok(code)\n  }\n}\n\n/**\n * Dot in email domain trail.\n *\n * This calls `ok` if this *is* the trail, followed by an end, which means\n * the trail is not part of the link.\n * It calls `nok` if this *is* part of the link.\n *\n * ```markdown\n * > | contact@example.org.\n *                        ^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeEmailDomainDotTrail(effects, ok, nok) {\n  return start\n\n  /**\n   * Dot.\n   *\n   * ```markdown\n   * > | contact@example.org.\n   *                    ^   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // Must be dot.\n    effects.consume(code)\n    return after\n  }\n\n  /**\n   * After dot.\n   *\n   * ```markdown\n   * > | contact@example.org.\n   *                     ^   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // Not a trail if alphanumeric.\n    return asciiAlphanumeric(code) ? nok(code) : ok(code)\n  }\n}\n\n/**\n * See:\n * <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L156>.\n *\n * @type {Previous}\n */\nfunction previousWww(code) {\n  return (\n    code === null ||\n    code === 40 ||\n    code === 42 ||\n    code === 95 ||\n    code === 91 ||\n    code === 93 ||\n    code === 126 ||\n    markdownLineEndingOrSpace(code)\n  )\n}\n\n/**\n * See:\n * <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L214>.\n *\n * @type {Previous}\n */\nfunction previousProtocol(code) {\n  return !asciiAlpha(code)\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Previous}\n */\nfunction previousEmail(code) {\n  // Do not allow a slash “inside” atext.\n  // The reference code is a bit weird, but that’s what it results in.\n  // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L307>.\n  // Other than slash, every preceding character is allowed.\n  return !(code === 47 || gfmAtext(code))\n}\n\n/**\n * @param {Code} code\n * @returns {boolean}\n */\nfunction gfmAtext(code) {\n  return (\n    code === 43 ||\n    code === 45 ||\n    code === 46 ||\n    code === 95 ||\n    asciiAlphanumeric(code)\n  )\n}\n\n/**\n * @param {Array<Event>} events\n * @returns {boolean}\n */\nfunction previousUnbalanced(events) {\n  let index = events.length\n  let result = false\n  while (index--) {\n    const token = events[index][1]\n    if (\n      (token.type === 'labelLink' || token.type === 'labelImage') &&\n      !token._balanced\n    ) {\n      result = true\n      break\n    }\n\n    // If we’ve seen this token, and it was marked as not having any unbalanced\n    // bracket before it, we can exit.\n    if (token._gfmAutolinkLiteralWalkedInto) {\n      result = false\n      break\n    }\n  }\n  if (events.length > 0 && !result) {\n    // Mark the last token as “walked into” w/o finding\n    // anything.\n    events[events.length - 1][1]._gfmAutolinkLiteralWalkedInto = true\n  }\n  return result\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {blankLine} from 'micromark-core-commonmark'\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEndingOrSpace} from 'micromark-util-character'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nconst indent = {\n  tokenize: tokenizeIndent,\n  partial: true\n}\n\n// To do: micromark should support a `_hiddenGfmFootnoteSupport`, which only\n// affects label start (image).\n// That will let us drop `tokenizePotentialGfmFootnote*`.\n// It currently has a `_hiddenFootnoteSupport`, which affects that and more.\n// That can be removed when `micromark-extension-footnote` is archived.\n\n/**\n * Create an extension for `micromark` to enable GFM footnote syntax.\n *\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to\n *   enable GFM footnote syntax.\n */\nexport function gfmFootnote() {\n  /** @type {Extension} */\n  return {\n    document: {\n      [91]: {\n        tokenize: tokenizeDefinitionStart,\n        continuation: {\n          tokenize: tokenizeDefinitionContinuation\n        },\n        exit: gfmFootnoteDefinitionEnd\n      }\n    },\n    text: {\n      [91]: {\n        tokenize: tokenizeGfmFootnoteCall\n      },\n      [93]: {\n        add: 'after',\n        tokenize: tokenizePotentialGfmFootnoteCall,\n        resolveTo: resolveToPotentialGfmFootnoteCall\n      }\n    }\n  }\n}\n\n// To do: remove after micromark update.\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizePotentialGfmFootnoteCall(effects, ok, nok) {\n  const self = this\n  let index = self.events.length\n  /** @type {Array<string>} */\n  // @ts-expect-error It’s fine!\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = [])\n  /** @type {Token} */\n  let labelStart\n\n  // Find an opening.\n  while (index--) {\n    const token = self.events[index][1]\n    if (token.type === 'labelImage') {\n      labelStart = token\n      break\n    }\n\n    // Exit if we’ve walked far enough.\n    if (\n      token.type === 'gfmFootnoteCall' ||\n      token.type === 'labelLink' ||\n      token.type === 'label' ||\n      token.type === 'image' ||\n      token.type === 'link'\n    ) {\n      break\n    }\n  }\n  return start\n\n  /**\n   * @type {State}\n   */\n  function start(code) {\n    if (!labelStart || !labelStart._balanced) {\n      return nok(code)\n    }\n    const id = normalizeIdentifier(\n      self.sliceSerialize({\n        start: labelStart.end,\n        end: self.now()\n      })\n    )\n    if (id.codePointAt(0) !== 94 || !defined.includes(id.slice(1))) {\n      return nok(code)\n    }\n    effects.enter('gfmFootnoteCallLabelMarker')\n    effects.consume(code)\n    effects.exit('gfmFootnoteCallLabelMarker')\n    return ok(code)\n  }\n}\n\n// To do: remove after micromark update.\n/** @type {Resolver} */\nfunction resolveToPotentialGfmFootnoteCall(events, context) {\n  let index = events.length\n  /** @type {Token | undefined} */\n  let labelStart\n\n  // Find an opening.\n  while (index--) {\n    if (\n      events[index][1].type === 'labelImage' &&\n      events[index][0] === 'enter'\n    ) {\n      labelStart = events[index][1]\n      break\n    }\n  }\n  // Change the `labelImageMarker` to a `data`.\n  events[index + 1][1].type = 'data'\n  events[index + 3][1].type = 'gfmFootnoteCallLabelMarker'\n\n  // The whole (without `!`):\n  /** @type {Token} */\n  const call = {\n    type: 'gfmFootnoteCall',\n    start: Object.assign({}, events[index + 3][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  }\n  // The `^` marker\n  /** @type {Token} */\n  const marker = {\n    type: 'gfmFootnoteCallMarker',\n    start: Object.assign({}, events[index + 3][1].end),\n    end: Object.assign({}, events[index + 3][1].end)\n  }\n  // Increment the end 1 character.\n  marker.end.column++\n  marker.end.offset++\n  marker.end._bufferIndex++\n  /** @type {Token} */\n  const string = {\n    type: 'gfmFootnoteCallString',\n    start: Object.assign({}, marker.end),\n    end: Object.assign({}, events[events.length - 1][1].start)\n  }\n  /** @type {Token} */\n  const chunk = {\n    type: 'chunkString',\n    contentType: 'string',\n    start: Object.assign({}, string.start),\n    end: Object.assign({}, string.end)\n  }\n\n  /** @type {Array<Event>} */\n  const replacement = [\n    // Take the `labelImageMarker` (now `data`, the `!`)\n    events[index + 1],\n    events[index + 2],\n    ['enter', call, context],\n    // The `[`\n    events[index + 3],\n    events[index + 4],\n    // The `^`.\n    ['enter', marker, context],\n    ['exit', marker, context],\n    // Everything in between.\n    ['enter', string, context],\n    ['enter', chunk, context],\n    ['exit', chunk, context],\n    ['exit', string, context],\n    // The ending (`]`, properly parsed and labelled).\n    events[events.length - 2],\n    events[events.length - 1],\n    ['exit', call, context]\n  ]\n  events.splice(index, events.length - index + 1, ...replacement)\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeGfmFootnoteCall(effects, ok, nok) {\n  const self = this\n  /** @type {Array<string>} */\n  // @ts-expect-error It’s fine!\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = [])\n  let size = 0\n  /** @type {boolean} */\n  let data\n\n  // Note: the implementation of `markdown-rs` is different, because it houses\n  // core *and* extensions in one project.\n  // Therefore, it can include footnote logic inside `label-end`.\n  // We can’t do that, but luckily, we can parse footnotes in a simpler way than\n  // needed for labels.\n  return start\n\n  /**\n   * Start of footnote label.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('gfmFootnoteCall')\n    effects.enter('gfmFootnoteCallLabelMarker')\n    effects.consume(code)\n    effects.exit('gfmFootnoteCallLabelMarker')\n    return callStart\n  }\n\n  /**\n   * After `[`, at `^`.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function callStart(code) {\n    if (code !== 94) return nok(code)\n    effects.enter('gfmFootnoteCallMarker')\n    effects.consume(code)\n    effects.exit('gfmFootnoteCallMarker')\n    effects.enter('gfmFootnoteCallString')\n    effects.enter('chunkString').contentType = 'string'\n    return callData\n  }\n\n  /**\n   * In label.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function callData(code) {\n    if (\n      // Too long.\n      size > 999 ||\n      // Closing brace with nothing.\n      (code === 93 && !data) ||\n      // Space or tab is not supported by GFM for some reason.\n      // `\\n` and `[` not being supported makes sense.\n      code === null ||\n      code === 91 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      return nok(code)\n    }\n    if (code === 93) {\n      effects.exit('chunkString')\n      const token = effects.exit('gfmFootnoteCallString')\n      if (!defined.includes(normalizeIdentifier(self.sliceSerialize(token)))) {\n        return nok(code)\n      }\n      effects.enter('gfmFootnoteCallLabelMarker')\n      effects.consume(code)\n      effects.exit('gfmFootnoteCallLabelMarker')\n      effects.exit('gfmFootnoteCall')\n      return ok\n    }\n    if (!markdownLineEndingOrSpace(code)) {\n      data = true\n    }\n    size++\n    effects.consume(code)\n    return code === 92 ? callEscape : callData\n  }\n\n  /**\n   * On character after escape.\n   *\n   * ```markdown\n   * > | a [^b\\c] d\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function callEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code)\n      size++\n      return callData\n    }\n    return callData(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinitionStart(effects, ok, nok) {\n  const self = this\n  /** @type {Array<string>} */\n  // @ts-expect-error It’s fine!\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = [])\n  /** @type {string} */\n  let identifier\n  let size = 0\n  /** @type {boolean | undefined} */\n  let data\n  return start\n\n  /**\n   * Start of GFM footnote definition.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('gfmFootnoteDefinition')._container = true\n    effects.enter('gfmFootnoteDefinitionLabel')\n    effects.enter('gfmFootnoteDefinitionLabelMarker')\n    effects.consume(code)\n    effects.exit('gfmFootnoteDefinitionLabelMarker')\n    return labelAtMarker\n  }\n\n  /**\n   * In label, at caret.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAtMarker(code) {\n    if (code === 94) {\n      effects.enter('gfmFootnoteDefinitionMarker')\n      effects.consume(code)\n      effects.exit('gfmFootnoteDefinitionMarker')\n      effects.enter('gfmFootnoteDefinitionLabelString')\n      effects.enter('chunkString').contentType = 'string'\n      return labelInside\n    }\n    return nok(code)\n  }\n\n  /**\n   * In label.\n   *\n   * > 👉 **Note**: `cmark-gfm` prevents whitespace from occurring in footnote\n   * > definition labels.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelInside(code) {\n    if (\n      // Too long.\n      size > 999 ||\n      // Closing brace with nothing.\n      (code === 93 && !data) ||\n      // Space or tab is not supported by GFM for some reason.\n      // `\\n` and `[` not being supported makes sense.\n      code === null ||\n      code === 91 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      return nok(code)\n    }\n    if (code === 93) {\n      effects.exit('chunkString')\n      const token = effects.exit('gfmFootnoteDefinitionLabelString')\n      identifier = normalizeIdentifier(self.sliceSerialize(token))\n      effects.enter('gfmFootnoteDefinitionLabelMarker')\n      effects.consume(code)\n      effects.exit('gfmFootnoteDefinitionLabelMarker')\n      effects.exit('gfmFootnoteDefinitionLabel')\n      return labelAfter\n    }\n    if (!markdownLineEndingOrSpace(code)) {\n      data = true\n    }\n    size++\n    effects.consume(code)\n    return code === 92 ? labelEscape : labelInside\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * > 👉 **Note**: `cmark-gfm` currently does not support escaped brackets:\n   * > <https://github.com/github/cmark-gfm/issues/240>\n   *\n   * ```markdown\n   * > | [^a\\*b]: c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code)\n      size++\n      return labelInside\n    }\n    return labelInside(code)\n  }\n\n  /**\n   * After definition label.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAfter(code) {\n    if (code === 58) {\n      effects.enter('definitionMarker')\n      effects.consume(code)\n      effects.exit('definitionMarker')\n      if (!defined.includes(identifier)) {\n        defined.push(identifier)\n      }\n\n      // Any whitespace after the marker is eaten, forming indented code\n      // is not possible.\n      // No space is also fine, just like a block quote marker.\n      return factorySpace(\n        effects,\n        whitespaceAfter,\n        'gfmFootnoteDefinitionWhitespace'\n      )\n    }\n    return nok(code)\n  }\n\n  /**\n   * After definition prefix.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function whitespaceAfter(code) {\n    // `markdown-rs` has a wrapping token for the prefix that is closed here.\n    return ok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinitionContinuation(effects, ok, nok) {\n  /// Start of footnote definition continuation.\n  ///\n  /// ```markdown\n  ///   | [^a]: b\n  /// > |     c\n  ///     ^\n  /// ```\n  //\n  // Either a blank line, which is okay, or an indented thing.\n  return effects.check(blankLine, ok, effects.attempt(indent, ok, nok))\n}\n\n/** @type {Exiter} */\nfunction gfmFootnoteDefinitionEnd(effects) {\n  effects.exit('gfmFootnoteDefinition')\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'gfmFootnoteDefinitionIndent',\n    4 + 1\n  )\n\n  /**\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'gfmFootnoteDefinitionIndent' &&\n      tail[2].sliceSerialize(tail[1], true).length === 4\n      ? ok(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean} [singleTilde=true]\n *   Whether to support strikethrough with a single tilde.\n *\n *   Single tildes work on github.com, but are technically prohibited by the\n *   GFM spec.\n */\n\nimport {splice} from 'micromark-util-chunked'\nimport {classifyCharacter} from 'micromark-util-classify-character'\nimport {resolveAll} from 'micromark-util-resolve-all'\n/**\n * Create an extension for `micromark` to enable GFM strikethrough syntax.\n *\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions`, to\n *   enable GFM strikethrough syntax.\n */\nexport function gfmStrikethrough(options) {\n  const options_ = options || {}\n  let single = options_.singleTilde\n  const tokenizer = {\n    tokenize: tokenizeStrikethrough,\n    resolveAll: resolveAllStrikethrough\n  }\n  if (single === null || single === undefined) {\n    single = true\n  }\n  return {\n    text: {\n      [126]: tokenizer\n    },\n    insideSpan: {\n      null: [tokenizer]\n    },\n    attentionMarkers: {\n      null: [126]\n    }\n  }\n\n  /**\n   * Take events and resolve strikethrough.\n   *\n   * @type {Resolver}\n   */\n  function resolveAllStrikethrough(events, context) {\n    let index = -1\n\n    // Walk through all events.\n    while (++index < events.length) {\n      // Find a token that can close.\n      if (\n        events[index][0] === 'enter' &&\n        events[index][1].type === 'strikethroughSequenceTemporary' &&\n        events[index][1]._close\n      ) {\n        let open = index\n\n        // Now walk back to find an opener.\n        while (open--) {\n          // Find a token that can open the closer.\n          if (\n            events[open][0] === 'exit' &&\n            events[open][1].type === 'strikethroughSequenceTemporary' &&\n            events[open][1]._open &&\n            // If the sizes are the same:\n            events[index][1].end.offset - events[index][1].start.offset ===\n              events[open][1].end.offset - events[open][1].start.offset\n          ) {\n            events[index][1].type = 'strikethroughSequence'\n            events[open][1].type = 'strikethroughSequence'\n\n            /** @type {Token} */\n            const strikethrough = {\n              type: 'strikethrough',\n              start: Object.assign({}, events[open][1].start),\n              end: Object.assign({}, events[index][1].end)\n            }\n\n            /** @type {Token} */\n            const text = {\n              type: 'strikethroughText',\n              start: Object.assign({}, events[open][1].end),\n              end: Object.assign({}, events[index][1].start)\n            }\n\n            // Opening.\n            /** @type {Array<Event>} */\n            const nextEvents = [\n              ['enter', strikethrough, context],\n              ['enter', events[open][1], context],\n              ['exit', events[open][1], context],\n              ['enter', text, context]\n            ]\n            const insideSpan = context.parser.constructs.insideSpan.null\n            if (insideSpan) {\n              // Between.\n              splice(\n                nextEvents,\n                nextEvents.length,\n                0,\n                resolveAll(insideSpan, events.slice(open + 1, index), context)\n              )\n            }\n\n            // Closing.\n            splice(nextEvents, nextEvents.length, 0, [\n              ['exit', text, context],\n              ['enter', events[index][1], context],\n              ['exit', events[index][1], context],\n              ['exit', strikethrough, context]\n            ])\n            splice(events, open - 1, index - open + 3, nextEvents)\n            index = open + nextEvents.length - 2\n            break\n          }\n        }\n      }\n    }\n    index = -1\n    while (++index < events.length) {\n      if (events[index][1].type === 'strikethroughSequenceTemporary') {\n        events[index][1].type = 'data'\n      }\n    }\n    return events\n  }\n\n  /**\n   * @this {TokenizeContext}\n   * @type {Tokenizer}\n   */\n  function tokenizeStrikethrough(effects, ok, nok) {\n    const previous = this.previous\n    const events = this.events\n    let size = 0\n    return start\n\n    /** @type {State} */\n    function start(code) {\n      if (\n        previous === 126 &&\n        events[events.length - 1][1].type !== 'characterEscape'\n      ) {\n        return nok(code)\n      }\n      effects.enter('strikethroughSequenceTemporary')\n      return more(code)\n    }\n\n    /** @type {State} */\n    function more(code) {\n      const before = classifyCharacter(previous)\n      if (code === 126) {\n        // If this is the third marker, exit.\n        if (size > 1) return nok(code)\n        effects.consume(code)\n        size++\n        return more\n      }\n      if (size < 2 && !single) return nok(code)\n      const token = effects.exit('strikethroughSequenceTemporary')\n      const after = classifyCharacter(code)\n      token._open = !after || (after === 2 && Boolean(before))\n      token._close = !before || (before === 2 && Boolean(after))\n      return ok(code)\n    }\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n */\n\n// Port of `edit_map.rs` from `markdown-rs`.\n// This should move to `markdown-js` later.\n\n// Deal with several changes in events, batching them together.\n//\n// Preferably, changes should be kept to a minimum.\n// Sometimes, it’s needed to change the list of events, because parsing can be\n// messy, and it helps to expose a cleaner interface of events to the compiler\n// and other users.\n// It can also help to merge many adjacent similar events.\n// And, in other cases, it’s needed to parse subcontent: pass some events\n// through another tokenizer and inject the result.\n\n/**\n * @typedef {[number, number, Array<Event>]} Change\n * @typedef {[number, number, number]} Jump\n */\n\n/**\n * Tracks a bunch of edits.\n */\nexport class EditMap {\n  /**\n   * Create a new edit map.\n   */\n  constructor() {\n    /**\n     * Record of changes.\n     *\n     * @type {Array<Change>}\n     */\n    this.map = []\n  }\n\n  /**\n   * Create an edit: a remove and/or add at a certain place.\n   *\n   * @param {number} index\n   * @param {number} remove\n   * @param {Array<Event>} add\n   * @returns {void}\n   */\n  add(index, remove, add) {\n    addImpl(this, index, remove, add)\n  }\n\n  // To do: not used here.\n  // /**\n  //  * Create an edit: but insert `add` before existing additions.\n  //  *\n  //  * @param {number} index\n  //  * @param {number} remove\n  //  * @param {Array<Event>} add\n  //  * @returns {void}\n  //  */\n  // addBefore(index, remove, add) {\n  //   addImpl(this, index, remove, add, true)\n  // }\n\n  /**\n   * Done, change the events.\n   *\n   * @param {Array<Event>} events\n   * @returns {void}\n   */\n  consume(events) {\n    this.map.sort((a, b) => a[0] - b[0])\n\n    /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */\n    if (this.map.length === 0) {\n      return\n    }\n\n    // To do: if links are added in events, like they are in `markdown-rs`,\n    // this is needed.\n    // // Calculate jumps: where items in the current list move to.\n    // /** @type {Array<Jump>} */\n    // const jumps = []\n    // let index = 0\n    // let addAcc = 0\n    // let removeAcc = 0\n    // while (index < this.map.length) {\n    //   const [at, remove, add] = this.map[index]\n    //   removeAcc += remove\n    //   addAcc += add.length\n    //   jumps.push([at, removeAcc, addAcc])\n    //   index += 1\n    // }\n    //\n    // . shiftLinks(events, jumps)\n\n    let index = this.map.length\n    /** @type {Array<Array<Event>>} */\n    const vecs = []\n    while (index > 0) {\n      index -= 1\n      vecs.push(events.slice(this.map[index][0] + this.map[index][1]))\n      // eslint-disable-next-line unicorn/no-array-push-push\n      vecs.push(this.map[index][2])\n\n      // Truncate rest.\n      events.length = this.map[index][0]\n    }\n    vecs.push([...events])\n    events.length = 0\n    let slice = vecs.pop()\n    while (slice) {\n      events.push(...slice)\n      slice = vecs.pop()\n    }\n\n    // Truncate everything.\n    this.map.length = 0\n  }\n}\n\n/**\n * Create an edit.\n *\n * @param {EditMap} editMap\n * @param {number} at\n * @param {number} remove\n * @param {Array<Event>} add\n * @returns {void}\n */\nfunction addImpl(editMap, at, remove, add) {\n  let index = 0\n\n  /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */\n  if (remove === 0 && add.length === 0) {\n    return\n  }\n  while (index < editMap.map.length) {\n    if (editMap.map[index][0] === at) {\n      editMap.map[index][1] += remove\n\n      // To do: before not used.\n      // if (before) {\n      //   add.push(...editMap.map[index][2])\n      //   editMap.map[index][2] = add\n      // } else {\n      editMap.map[index][2].push(...add)\n      // }\n\n      return\n    }\n    index += 1\n  }\n  editMap.map.push([at, remove, add])\n}\n\n// /**\n//  * Shift `previous` and `next` links according to `jumps`.\n//  *\n//  * This fixes links in case there are events removed or added between them.\n//  *\n//  * @param {Array<Event>} events\n//  * @param {Array<Jump>} jumps\n//  */\n// function shiftLinks(events, jumps) {\n//   let jumpIndex = 0\n//   let index = 0\n//   let add = 0\n//   let rm = 0\n\n//   while (index < events.length) {\n//     const rmCurr = rm\n\n//     while (jumpIndex < jumps.length && jumps[jumpIndex][0] <= index) {\n//       add = jumps[jumpIndex][2]\n//       rm = jumps[jumpIndex][1]\n//       jumpIndex += 1\n//     }\n\n//     // Ignore items that will be removed.\n//     if (rm > rmCurr) {\n//       index += rm - rmCurr\n//     } else {\n//       console.log('to do: links?', add, rmCurr)\n//       // ?\n//       // if let Some(link) = &events[index].link {\n//       //     if let Some(next) = link.next {\n//       //         events[next].link.as_mut().unwrap().previous = Some(index + add - rm);\n//       //         while jumpIndex < jumps.len() && jumps[jumpIndex].0 <= next {\n//       //             add = jumps[jumpIndex].2;\n//       //             rm = jumps[jumpIndex].1;\n//       //             jumpIndex += 1;\n//       //         }\n//       //         events[index].link.as_mut().unwrap().next = Some(next + add - rm);\n//       //         index = next;\n//       //         continue;\n//       //     }\n//       // }\n//       index += 1\n//     }\n//   }\n// }\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n */\n\n/**\n * @typedef {'left' | 'center' | 'right' | 'none'} Align\n */\n\n/**\n * Figure out the alignment of a GFM table.\n *\n * @param {Array<Event>} events\n * @param {number} index\n * @returns {Array<Align>}\n */\nexport function gfmTableAlign(events, index) {\n  let inDelimiterRow = false\n  /** @type {Array<Align>} */\n  const align = []\n  while (index < events.length) {\n    const event = events[index]\n    if (inDelimiterRow) {\n      if (event[0] === 'enter') {\n        // Start of alignment value: set a new column.\n        // To do: `markdown-rs` uses `tableDelimiterCellValue`.\n        if (event[1].type === 'tableContent') {\n          align.push(\n            events[index + 1][1].type === 'tableDelimiterMarker'\n              ? 'left'\n              : 'none'\n          )\n        }\n      }\n      // Exits:\n      // End of alignment value: change the column.\n      // To do: `markdown-rs` uses `tableDelimiterCellValue`.\n      else if (event[1].type === 'tableContent') {\n        if (events[index - 1][1].type === 'tableDelimiterMarker') {\n          const alignIndex = align.length - 1\n          align[alignIndex] = align[alignIndex] === 'left' ? 'center' : 'right'\n        }\n      }\n      // Done!\n      else if (event[1].type === 'tableDelimiterRow') {\n        break\n      }\n    } else if (event[0] === 'enter' && event[1].type === 'tableDelimiterRow') {\n      inDelimiterRow = true\n    }\n    index += 1\n  }\n  return align\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\n/**\n * @typedef {[number, number, number, number]} Range\n *   Cell info.\n *\n * @typedef {0 | 1 | 2 | 3} RowKind\n *   Where we are: `1` for head row, `2` for delimiter row, `3` for body row.\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {EditMap} from './edit-map.js'\nimport {gfmTableAlign} from './infer.js'\n\n// To do: next major: expose functions.\n\n/**\n * Extension for `micromark` that can be passed in `extensions` to enable GFM\n * table syntax.\n *\n * @type {Extension}\n */\nexport const gfmTable = {\n  flow: {\n    null: {\n      tokenize: tokenizeTable,\n      resolveAll: resolveTable\n    }\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTable(effects, ok, nok) {\n  const self = this\n  let size = 0\n  let sizeB = 0\n  /** @type {boolean | undefined} */\n  let seen\n  return start\n\n  /**\n   * Start of a GFM table.\n   *\n   * If there is a valid table row or table head before, then we try to parse\n   * another row.\n   * Otherwise, we try to parse a head.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *   | | - |\n   * > | | b |\n   *     ^\n   * ```\n   * @type {State}\n   */\n  function start(code) {\n    let index = self.events.length - 1\n    while (index > -1) {\n      const type = self.events[index][1].type\n      if (\n        type === 'lineEnding' ||\n        // Note: markdown-rs uses `whitespace` instead of `linePrefix`\n        type === 'linePrefix'\n      )\n        index--\n      else break\n    }\n    const tail = index > -1 ? self.events[index][1].type : null\n    const next =\n      tail === 'tableHead' || tail === 'tableRow' ? bodyRowStart : headRowBefore\n\n    // Don’t allow lazy body rows.\n    if (next === bodyRowStart && self.parser.lazy[self.now().line]) {\n      return nok(code)\n    }\n    return next(code)\n  }\n\n  /**\n   * Before table head row.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowBefore(code) {\n    effects.enter('tableHead')\n    effects.enter('tableRow')\n    return headRowStart(code)\n  }\n\n  /**\n   * Before table head row, after whitespace.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowStart(code) {\n    if (code === 124) {\n      return headRowBreak(code)\n    }\n\n    // To do: micromark-js should let us parse our own whitespace in extensions,\n    // like `markdown-rs`:\n    //\n    // ```js\n    // // 4+ spaces.\n    // if (markdownSpace(code)) {\n    //   return nok(code)\n    // }\n    // ```\n\n    seen = true\n    // Count the first character, that isn’t a pipe, double.\n    sizeB += 1\n    return headRowBreak(code)\n  }\n\n  /**\n   * At break in table head row.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *       ^\n   *         ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowBreak(code) {\n    if (code === null) {\n      // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.\n      return nok(code)\n    }\n    if (markdownLineEnding(code)) {\n      // If anything other than one pipe (ignoring whitespace) was used, it’s fine.\n      if (sizeB > 1) {\n        sizeB = 0\n        // To do: check if this works.\n        // Feel free to interrupt:\n        self.interrupt = true\n        effects.exit('tableRow')\n        effects.enter('lineEnding')\n        effects.consume(code)\n        effects.exit('lineEnding')\n        return headDelimiterStart\n      }\n\n      // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.\n      return nok(code)\n    }\n    if (markdownSpace(code)) {\n      // To do: check if this is fine.\n      // effects.attempt(State::Next(StateName::GfmTableHeadRowBreak), State::Nok)\n      // State::Retry(space_or_tab(tokenizer))\n      return factorySpace(effects, headRowBreak, 'whitespace')(code)\n    }\n    sizeB += 1\n    if (seen) {\n      seen = false\n      // Header cell count.\n      size += 1\n    }\n    if (code === 124) {\n      effects.enter('tableCellDivider')\n      effects.consume(code)\n      effects.exit('tableCellDivider')\n      // Whether a delimiter was seen.\n      seen = true\n      return headRowBreak\n    }\n\n    // Anything else is cell data.\n    effects.enter('data')\n    return headRowData(code)\n  }\n\n  /**\n   * In table head row data.\n   *\n   * ```markdown\n   * > | | a |\n   *       ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowData(code) {\n    if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {\n      effects.exit('data')\n      return headRowBreak(code)\n    }\n    effects.consume(code)\n    return code === 92 ? headRowEscape : headRowData\n  }\n\n  /**\n   * In table head row escape.\n   *\n   * ```markdown\n   * > | | a\\-b |\n   *         ^\n   *   | | ---- |\n   *   | | c    |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowEscape(code) {\n    if (code === 92 || code === 124) {\n      effects.consume(code)\n      return headRowData\n    }\n    return headRowData(code)\n  }\n\n  /**\n   * Before delimiter row.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *     ^\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterStart(code) {\n    // Reset `interrupt`.\n    self.interrupt = false\n\n    // Note: in `markdown-rs`, we need to handle piercing here too.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code)\n    }\n    effects.enter('tableDelimiterRow')\n    // Track if we’ve seen a `:` or `|`.\n    seen = false\n    if (markdownSpace(code)) {\n      return factorySpace(\n        effects,\n        headDelimiterBefore,\n        'linePrefix',\n        self.parser.constructs.disable.null.includes('codeIndented')\n          ? undefined\n          : 4\n      )(code)\n    }\n    return headDelimiterBefore(code)\n  }\n\n  /**\n   * Before delimiter row, after optional whitespace.\n   *\n   * Reused when a `|` is found later, to parse another cell.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *     ^\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterBefore(code) {\n    if (code === 45 || code === 58) {\n      return headDelimiterValueBefore(code)\n    }\n    if (code === 124) {\n      seen = true\n      // If we start with a pipe, we open a cell marker.\n      effects.enter('tableCellDivider')\n      effects.consume(code)\n      effects.exit('tableCellDivider')\n      return headDelimiterCellBefore\n    }\n\n    // More whitespace / empty row not allowed at start.\n    return headDelimiterNok(code)\n  }\n\n  /**\n   * After `|`, before delimiter cell.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterCellBefore(code) {\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headDelimiterValueBefore, 'whitespace')(code)\n    }\n    return headDelimiterValueBefore(code)\n  }\n\n  /**\n   * Before delimiter cell value.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterValueBefore(code) {\n    // Align: left.\n    if (code === 58) {\n      sizeB += 1\n      seen = true\n      effects.enter('tableDelimiterMarker')\n      effects.consume(code)\n      effects.exit('tableDelimiterMarker')\n      return headDelimiterLeftAlignmentAfter\n    }\n\n    // Align: none.\n    if (code === 45) {\n      sizeB += 1\n      // To do: seems weird that this *isn’t* left aligned, but that state is used?\n      return headDelimiterLeftAlignmentAfter(code)\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return headDelimiterCellAfter(code)\n    }\n    return headDelimiterNok(code)\n  }\n\n  /**\n   * After delimiter cell left alignment marker.\n   *\n   * ```markdown\n   *   | | a  |\n   * > | | :- |\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterLeftAlignmentAfter(code) {\n    if (code === 45) {\n      effects.enter('tableDelimiterFiller')\n      return headDelimiterFiller(code)\n    }\n\n    // Anything else is not ok after the left-align colon.\n    return headDelimiterNok(code)\n  }\n\n  /**\n   * In delimiter cell filler.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterFiller(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return headDelimiterFiller\n    }\n\n    // Align is `center` if it was `left`, `right` otherwise.\n    if (code === 58) {\n      seen = true\n      effects.exit('tableDelimiterFiller')\n      effects.enter('tableDelimiterMarker')\n      effects.consume(code)\n      effects.exit('tableDelimiterMarker')\n      return headDelimiterRightAlignmentAfter\n    }\n    effects.exit('tableDelimiterFiller')\n    return headDelimiterRightAlignmentAfter(code)\n  }\n\n  /**\n   * After delimiter cell right alignment marker.\n   *\n   * ```markdown\n   *   | |  a |\n   * > | | -: |\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterRightAlignmentAfter(code) {\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headDelimiterCellAfter, 'whitespace')(code)\n    }\n    return headDelimiterCellAfter(code)\n  }\n\n  /**\n   * After delimiter cell.\n   *\n   * ```markdown\n   *   | |  a |\n   * > | | -: |\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterCellAfter(code) {\n    if (code === 124) {\n      return headDelimiterBefore(code)\n    }\n    if (code === null || markdownLineEnding(code)) {\n      // Exit when:\n      // * there was no `:` or `|` at all (it’s a thematic break or setext\n      //   underline instead)\n      // * the header cell count is not the delimiter cell count\n      if (!seen || size !== sizeB) {\n        return headDelimiterNok(code)\n      }\n\n      // Note: in markdown-rs`, a reset is needed here.\n      effects.exit('tableDelimiterRow')\n      effects.exit('tableHead')\n      // To do: in `markdown-rs`, resolvers need to be registered manually.\n      // effects.register_resolver(ResolveName::GfmTable)\n      return ok(code)\n    }\n    return headDelimiterNok(code)\n  }\n\n  /**\n   * In delimiter row, at a disallowed byte.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | x |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterNok(code) {\n    // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.\n    return nok(code)\n  }\n\n  /**\n   * Before table body row.\n   *\n   * ```markdown\n   *   | | a |\n   *   | | - |\n   * > | | b |\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowStart(code) {\n    // Note: in `markdown-rs` we need to manually take care of a prefix,\n    // but in `micromark-js` that is done for us, so if we’re here, we’re\n    // never at whitespace.\n    effects.enter('tableRow')\n    return bodyRowBreak(code)\n  }\n\n  /**\n   * At break in table body row.\n   *\n   * ```markdown\n   *   | | a |\n   *   | | - |\n   * > | | b |\n   *     ^\n   *       ^\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowBreak(code) {\n    if (code === 124) {\n      effects.enter('tableCellDivider')\n      effects.consume(code)\n      effects.exit('tableCellDivider')\n      return bodyRowBreak\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('tableRow')\n      return ok(code)\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, bodyRowBreak, 'whitespace')(code)\n    }\n\n    // Anything else is cell content.\n    effects.enter('data')\n    return bodyRowData(code)\n  }\n\n  /**\n   * In table body row data.\n   *\n   * ```markdown\n   *   | | a |\n   *   | | - |\n   * > | | b |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowData(code) {\n    if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {\n      effects.exit('data')\n      return bodyRowBreak(code)\n    }\n    effects.consume(code)\n    return code === 92 ? bodyRowEscape : bodyRowData\n  }\n\n  /**\n   * In table body row escape.\n   *\n   * ```markdown\n   *   | | a    |\n   *   | | ---- |\n   * > | | b\\-c |\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowEscape(code) {\n    if (code === 92 || code === 124) {\n      effects.consume(code)\n      return bodyRowData\n    }\n    return bodyRowData(code)\n  }\n}\n\n/** @type {Resolver} */\n// eslint-disable-next-line complexity\nfunction resolveTable(events, context) {\n  let index = -1\n  let inFirstCellAwaitingPipe = true\n  /** @type {RowKind} */\n  let rowKind = 0\n  /** @type {Range} */\n  let lastCell = [0, 0, 0, 0]\n  /** @type {Range} */\n  let cell = [0, 0, 0, 0]\n  let afterHeadAwaitingFirstBodyRow = false\n  let lastTableEnd = 0\n  /** @type {Token | undefined} */\n  let currentTable\n  /** @type {Token | undefined} */\n  let currentBody\n  /** @type {Token | undefined} */\n  let currentCell\n  const map = new EditMap()\n  while (++index < events.length) {\n    const event = events[index]\n    const token = event[1]\n    if (event[0] === 'enter') {\n      // Start of head.\n      if (token.type === 'tableHead') {\n        afterHeadAwaitingFirstBodyRow = false\n\n        // Inject previous (body end and) table end.\n        if (lastTableEnd !== 0) {\n          flushTableEnd(map, context, lastTableEnd, currentTable, currentBody)\n          currentBody = undefined\n          lastTableEnd = 0\n        }\n\n        // Inject table start.\n        currentTable = {\n          type: 'table',\n          start: Object.assign({}, token.start),\n          // Note: correct end is set later.\n          end: Object.assign({}, token.end)\n        }\n        map.add(index, 0, [['enter', currentTable, context]])\n      } else if (\n        token.type === 'tableRow' ||\n        token.type === 'tableDelimiterRow'\n      ) {\n        inFirstCellAwaitingPipe = true\n        currentCell = undefined\n        lastCell = [0, 0, 0, 0]\n        cell = [0, index + 1, 0, 0]\n\n        // Inject table body start.\n        if (afterHeadAwaitingFirstBodyRow) {\n          afterHeadAwaitingFirstBodyRow = false\n          currentBody = {\n            type: 'tableBody',\n            start: Object.assign({}, token.start),\n            // Note: correct end is set later.\n            end: Object.assign({}, token.end)\n          }\n          map.add(index, 0, [['enter', currentBody, context]])\n        }\n        rowKind = token.type === 'tableDelimiterRow' ? 2 : currentBody ? 3 : 1\n      }\n      // Cell data.\n      else if (\n        rowKind &&\n        (token.type === 'data' ||\n          token.type === 'tableDelimiterMarker' ||\n          token.type === 'tableDelimiterFiller')\n      ) {\n        inFirstCellAwaitingPipe = false\n\n        // First value in cell.\n        if (cell[2] === 0) {\n          if (lastCell[1] !== 0) {\n            cell[0] = cell[1]\n            currentCell = flushCell(\n              map,\n              context,\n              lastCell,\n              rowKind,\n              undefined,\n              currentCell\n            )\n            lastCell = [0, 0, 0, 0]\n          }\n          cell[2] = index\n        }\n      } else if (token.type === 'tableCellDivider') {\n        if (inFirstCellAwaitingPipe) {\n          inFirstCellAwaitingPipe = false\n        } else {\n          if (lastCell[1] !== 0) {\n            cell[0] = cell[1]\n            currentCell = flushCell(\n              map,\n              context,\n              lastCell,\n              rowKind,\n              undefined,\n              currentCell\n            )\n          }\n          lastCell = cell\n          cell = [lastCell[1], index, 0, 0]\n        }\n      }\n    }\n    // Exit events.\n    else if (token.type === 'tableHead') {\n      afterHeadAwaitingFirstBodyRow = true\n      lastTableEnd = index\n    } else if (\n      token.type === 'tableRow' ||\n      token.type === 'tableDelimiterRow'\n    ) {\n      lastTableEnd = index\n      if (lastCell[1] !== 0) {\n        cell[0] = cell[1]\n        currentCell = flushCell(\n          map,\n          context,\n          lastCell,\n          rowKind,\n          index,\n          currentCell\n        )\n      } else if (cell[1] !== 0) {\n        currentCell = flushCell(map, context, cell, rowKind, index, currentCell)\n      }\n      rowKind = 0\n    } else if (\n      rowKind &&\n      (token.type === 'data' ||\n        token.type === 'tableDelimiterMarker' ||\n        token.type === 'tableDelimiterFiller')\n    ) {\n      cell[3] = index\n    }\n  }\n  if (lastTableEnd !== 0) {\n    flushTableEnd(map, context, lastTableEnd, currentTable, currentBody)\n  }\n  map.consume(context.events)\n\n  // To do: move this into `html`, when events are exposed there.\n  // That’s what `markdown-rs` does.\n  // That needs updates to `mdast-util-gfm-table`.\n  index = -1\n  while (++index < context.events.length) {\n    const event = context.events[index]\n    if (event[0] === 'enter' && event[1].type === 'table') {\n      event[1]._align = gfmTableAlign(context.events, index)\n    }\n  }\n  return events\n}\n\n/// Generate a cell.\n/**\n *\n * @param {EditMap} map\n * @param {TokenizeContext} context\n * @param {Range} range\n * @param {RowKind} rowKind\n * @param {number | undefined} rowEnd\n * @param {Token | undefined} previousCell\n * @returns {Token | undefined}\n */\n// eslint-disable-next-line max-params\nfunction flushCell(map, context, range, rowKind, rowEnd, previousCell) {\n  // `markdown-rs` uses:\n  // rowKind === 2 ? 'tableDelimiterCell' : 'tableCell'\n  const groupName =\n    rowKind === 1\n      ? 'tableHeader'\n      : rowKind === 2\n      ? 'tableDelimiter'\n      : 'tableData'\n  // `markdown-rs` uses:\n  // rowKind === 2 ? 'tableDelimiterCellValue' : 'tableCellText'\n  const valueName = 'tableContent'\n\n  // Insert an exit for the previous cell, if there is one.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //          ^-- exit\n  //           ^^^^-- this cell\n  // ```\n  if (range[0] !== 0) {\n    previousCell.end = Object.assign({}, getPoint(context.events, range[0]))\n    map.add(range[0], 0, [['exit', previousCell, context]])\n  }\n\n  // Insert enter of this cell.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //           ^-- enter\n  //           ^^^^-- this cell\n  // ```\n  const now = getPoint(context.events, range[1])\n  previousCell = {\n    type: groupName,\n    start: Object.assign({}, now),\n    // Note: correct end is set later.\n    end: Object.assign({}, now)\n  }\n  map.add(range[1], 0, [['enter', previousCell, context]])\n\n  // Insert text start at first data start and end at last data end, and\n  // remove events between.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //            ^-- enter\n  //             ^-- exit\n  //           ^^^^-- this cell\n  // ```\n  if (range[2] !== 0) {\n    const relatedStart = getPoint(context.events, range[2])\n    const relatedEnd = getPoint(context.events, range[3])\n    /** @type {Token} */\n    const valueToken = {\n      type: valueName,\n      start: Object.assign({}, relatedStart),\n      end: Object.assign({}, relatedEnd)\n    }\n    map.add(range[2], 0, [['enter', valueToken, context]])\n    if (rowKind !== 2) {\n      // Fix positional info on remaining events\n      const start = context.events[range[2]]\n      const end = context.events[range[3]]\n      start[1].end = Object.assign({}, end[1].end)\n      start[1].type = 'chunkText'\n      start[1].contentType = 'text'\n\n      // Remove if needed.\n      if (range[3] > range[2] + 1) {\n        const a = range[2] + 1\n        const b = range[3] - range[2] - 1\n        map.add(a, b, [])\n      }\n    }\n    map.add(range[3] + 1, 0, [['exit', valueToken, context]])\n  }\n\n  // Insert an exit for the last cell, if at the row end.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //                    ^-- exit\n  //               ^^^^^^-- this cell (the last one contains two “between” parts)\n  // ```\n  if (rowEnd !== undefined) {\n    previousCell.end = Object.assign({}, getPoint(context.events, rowEnd))\n    map.add(rowEnd, 0, [['exit', previousCell, context]])\n    previousCell = undefined\n  }\n  return previousCell\n}\n\n/**\n * Generate table end (and table body end).\n *\n * @param {EditMap} map\n * @param {TokenizeContext} context\n * @param {number} index\n * @param {Token} table\n * @param {Token | undefined} tableBody\n */\n// eslint-disable-next-line max-params\nfunction flushTableEnd(map, context, index, table, tableBody) {\n  /** @type {Array<Event>} */\n  const exits = []\n  const related = getPoint(context.events, index)\n  if (tableBody) {\n    tableBody.end = Object.assign({}, related)\n    exits.push(['exit', tableBody, context])\n  }\n  table.end = Object.assign({}, related)\n  exits.push(['exit', table, context])\n  map.add(index + 1, 0, exits)\n}\n\n/**\n * @param {Array<Event>} events\n * @param {number} index\n * @returns {readonly Point}\n */\nfunction getPoint(events, index) {\n  const event = events[index]\n  const side = event[0] === 'enter' ? 'start' : 'end'\n  return event[1][side]\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEndingOrSpace,\n  markdownLineEnding,\n  markdownSpace\n} from 'micromark-util-character'\nconst tasklistCheck = {\n  tokenize: tokenizeTasklistCheck\n}\n\n// To do: next major: expose function to make extension.\n\n/**\n * Extension for `micromark` that can be passed in `extensions`, to\n * enable GFM task list items syntax.\n *\n * @type {Extension}\n */\nexport const gfmTaskListItem = {\n  text: {\n    [91]: tasklistCheck\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTasklistCheck(effects, ok, nok) {\n  const self = this\n  return open\n\n  /**\n   * At start of task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (\n      // Exit if there’s stuff before.\n      self.previous !== null ||\n      // Exit if not in the first content that is the first child of a list\n      // item.\n      !self._gfmTasklistFirstContentOfListItem\n    ) {\n      return nok(code)\n    }\n    effects.enter('taskListCheck')\n    effects.enter('taskListCheckMarker')\n    effects.consume(code)\n    effects.exit('taskListCheckMarker')\n    return inside\n  }\n\n  /**\n   * In task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    // Currently we match how GH works in files.\n    // To match how GH works in comments, use `markdownSpace` (`[\\t ]`) instead\n    // of `markdownLineEndingOrSpace` (`[\\t\\n\\r ]`).\n    if (markdownLineEndingOrSpace(code)) {\n      effects.enter('taskListCheckValueUnchecked')\n      effects.consume(code)\n      effects.exit('taskListCheckValueUnchecked')\n      return close\n    }\n    if (code === 88 || code === 120) {\n      effects.enter('taskListCheckValueChecked')\n      effects.consume(code)\n      effects.exit('taskListCheckValueChecked')\n      return close\n    }\n    return nok(code)\n  }\n\n  /**\n   * At close of task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function close(code) {\n    if (code === 93) {\n      effects.enter('taskListCheckMarker')\n      effects.consume(code)\n      effects.exit('taskListCheckMarker')\n      effects.exit('taskListCheck')\n      return after\n    }\n    return nok(code)\n  }\n\n  /**\n   * @type {State}\n   */\n  function after(code) {\n    // EOL in paragraph means there must be something else after it.\n    if (markdownLineEnding(code)) {\n      return ok(code)\n    }\n\n    // Space or tab?\n    // Check what comes after.\n    if (markdownSpace(code)) {\n      return effects.check(\n        {\n          tokenize: spaceThenNonSpace\n        },\n        ok,\n        nok\n      )(code)\n    }\n\n    // EOF, or non-whitespace, both wrong.\n    return nok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction spaceThenNonSpace(effects, ok, nok) {\n  return factorySpace(effects, after, 'whitespace')\n\n  /**\n   * After whitespace, after task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // EOF means there was nothing, so bad.\n    // EOL means there’s content after it, so good.\n    // Impossible to have more spaces.\n    // Anything else is good.\n    return code === null ? nok(code) : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-extension-gfm-footnote').HtmlOptions} HtmlOptions\n * @typedef {import('micromark-extension-gfm-strikethrough').Options} Options\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension\n */\n\nimport {\n  combineExtensions,\n  combineHtmlExtensions\n} from 'micromark-util-combine-extensions'\nimport {\n  gfmAutolinkLiteral,\n  gfmAutolinkLiteralHtml\n} from 'micromark-extension-gfm-autolink-literal'\nimport {gfmFootnote, gfmFootnoteHtml} from 'micromark-extension-gfm-footnote'\nimport {\n  gfmStrikethrough,\n  gfmStrikethroughHtml\n} from 'micromark-extension-gfm-strikethrough'\nimport {gfmTable, gfmTableHtml} from 'micromark-extension-gfm-table'\nimport {gfmTagfilterHtml} from 'micromark-extension-gfm-tagfilter'\nimport {\n  gfmTaskListItem,\n  gfmTaskListItemHtml\n} from 'micromark-extension-gfm-task-list-item'\n\n/**\n * Create an extension for `micromark` to enable GFM syntax.\n *\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n *\n *   Passed to `micromark-extens-gfm-strikethrough`.\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to enable GFM\n *   syntax.\n */\nexport function gfm(options) {\n  return combineExtensions([\n    gfmAutolinkLiteral,\n    gfmFootnote(),\n    gfmStrikethrough(options),\n    gfmTable,\n    gfmTaskListItem\n  ])\n}\n\n/**\n * Create an extension for `micromark` to support GFM when serializing to HTML.\n *\n * @param {HtmlOptions | null | undefined} [options]\n *   Configuration.\n *\n *   Passed to `micromark-extens-gfm-footnote`.\n * @returns {HtmlExtension}\n *   Extension for `micromark` that can be passed in `htmlExtensions` to\n *   support GFM when serializing to HTML.\n */\nexport function gfmHtml(options) {\n  return combineHtmlExtensions([\n    gfmAutolinkLiteralHtml,\n    gfmFootnoteHtml(options),\n    gfmStrikethroughHtml,\n    gfmTableHtml,\n    gfmTagfilterHtml,\n    gfmTaskListItemHtml\n  ])\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {\n  asciiControl,\n  markdownLineEndingOrSpace,\n  markdownLineEnding\n} from 'micromark-util-character'\n/**\n * Parse destinations.\n *\n * ###### Examples\n *\n * ```markdown\n * <a>\n * <a\\>b>\n * <a b>\n * <a)>\n * a\n * a\\)b\n * a(b)c\n * a(b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type for whole (`<a>` or `b`).\n * @param {TokenType} literalType\n *   Type when enclosed (`<a>`).\n * @param {TokenType} literalMarkerType\n *   Type for enclosing (`<` and `>`).\n * @param {TokenType} rawType\n *   Type when not enclosed (`b`).\n * @param {TokenType} stringType\n *   Type for the value (`a` or `b`).\n * @param {number | undefined} [max=Infinity]\n *   Depth of nested parens (inclusive).\n * @returns {State}\n *   Start state.\n */ // eslint-disable-next-line max-params\nexport function factoryDestination(\n  effects,\n  ok,\n  nok,\n  type,\n  literalType,\n  literalMarkerType,\n  rawType,\n  stringType,\n  max\n) {\n  const limit = max || Number.POSITIVE_INFINITY\n  let balance = 0\n  return start\n\n  /**\n   * Start of destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *     ^\n   * > | aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type)\n      effects.enter(literalType)\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      return enclosedBefore\n    }\n\n    // ASCII control, space, closing paren.\n    if (code === null || code === 32 || code === 41 || asciiControl(code)) {\n      return nok(code)\n    }\n    effects.enter(type)\n    effects.enter(rawType)\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return raw(code)\n  }\n\n  /**\n   * After `<`, at an enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      effects.exit(literalType)\n      effects.exit(type)\n      return ok\n    }\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return enclosed(code)\n  }\n\n  /**\n   * In enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      return enclosedBefore(code)\n    }\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return code === 92 ? enclosedEscape : enclosed\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | <a\\*a>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code)\n      return enclosed\n    }\n    return enclosed(code)\n  }\n\n  /**\n   * In raw destination.\n   *\n   * ```markdown\n   * > | aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function raw(code) {\n    if (\n      !balance &&\n      (code === null || code === 41 || markdownLineEndingOrSpace(code))\n    ) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      effects.exit(rawType)\n      effects.exit(type)\n      return ok(code)\n    }\n    if (balance < limit && code === 40) {\n      effects.consume(code)\n      balance++\n      return raw\n    }\n    if (code === 41) {\n      effects.consume(code)\n      balance--\n      return raw\n    }\n\n    // ASCII control (but *not* `\\0`) and space and `(`.\n    // Note: in `markdown-rs`, `\\0` exists in codes, in `micromark-js` it\n    // doesn’t.\n    if (code === null || code === 32 || code === 40 || asciiControl(code)) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return code === 92 ? rawEscape : raw\n  }\n\n  /**\n   * After `\\`, at special character.\n   *\n   * ```markdown\n   * > | a\\*a\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function rawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code)\n      return raw\n    }\n    return raw(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/**\n * Parse labels.\n *\n * > 👉 **Note**: labels in markdown are capped at 999 characters in the string.\n *\n * ###### Examples\n *\n * ```markdown\n * [a]\n * [a\n * b]\n * [a\\]b]\n * ```\n *\n * @this {TokenizeContext}\n *   Tokenize context.\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole label (`[a]`).\n * @param {TokenType} markerType\n *   Type for the markers (`[` and `]`).\n * @param {TokenType} stringType\n *   Type for the identifier (`a`).\n * @returns {State}\n *   Start state.\n */ // eslint-disable-next-line max-params\nexport function factoryLabel(effects, ok, nok, type, markerType, stringType) {\n  const self = this\n  let size = 0\n  /** @type {boolean} */\n  let seen\n  return start\n\n  /**\n   * Start of label.\n   *\n   * ```markdown\n   * > | [a]\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(type)\n    effects.enter(markerType)\n    effects.consume(code)\n    effects.exit(markerType)\n    effects.enter(stringType)\n    return atBreak\n  }\n\n  /**\n   * In label, at something, before something else.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (\n      size > 999 ||\n      code === null ||\n      code === 91 ||\n      (code === 93 && !seen) ||\n      // To do: remove in the future once we’ve switched from\n      // `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n      // which doesn’t need this.\n      // Hidden footnotes hook.\n      /* c8 ignore next 3 */\n      (code === 94 &&\n        !size &&\n        '_hiddenFootnoteSupport' in self.parser.constructs)\n    ) {\n      return nok(code)\n    }\n    if (code === 93) {\n      effects.exit(stringType)\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n\n    // To do: indent? Link chunks and EOLs together?\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return atBreak\n    }\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return labelInside(code)\n  }\n\n  /**\n   * In label, in text.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelInside(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      code === 93 ||\n      markdownLineEnding(code) ||\n      size++ > 999\n    ) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n    effects.consume(code)\n    if (!seen) seen = !markdownSpace(code)\n    return code === 92 ? labelEscape : labelInside\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | [a\\*a]\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code)\n      size++\n      return labelInside\n    }\n    return labelInside(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {markdownSpace} from 'micromark-util-character'\n\n// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.\n\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   spaces in markdown are often optional, in which case this factory can be\n *     used and `ok` will be switched to whether spaces were found or not\n * *   one line ending or space can be detected with `markdownSpace(code)` right\n *     before using `factorySpace`\n *\n * ###### Examples\n *\n * Where `␉` represents a tab (plus how much it expands) and `␠` represents a\n * single space.\n *\n * ```markdown\n * ␉\n * ␠␠␠␠\n * ␉␠\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {TokenType} type\n *   Type (`' \\t'`).\n * @param {number | undefined} [max=Infinity]\n *   Max (exclusive).\n * @returns\n *   Start state.\n */\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Number.POSITIVE_INFINITY\n  let size = 0\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type)\n      return prefix(code)\n    }\n    return ok(code)\n  }\n\n  /** @type {State} */\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code)\n      return prefix\n    }\n    effects.exit(type)\n    return ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n/**\n * Parse titles.\n *\n * ###### Examples\n *\n * ```markdown\n * \"a\"\n * 'b'\n * (c)\n * \"a\n * b\"\n * 'a\n *     b'\n * (a\\)b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole title (`\"a\"`, `'b'`, `(c)`).\n * @param {TokenType} markerType\n *   Type for the markers (`\"`, `'`, `(`, and `)`).\n * @param {TokenType} stringType\n *   Type for the value (`a`).\n * @returns {State}\n *   Start state.\n */ // eslint-disable-next-line max-params\nexport function factoryTitle(effects, ok, nok, type, markerType, stringType) {\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n\n  /**\n   * Start of title.\n   *\n   * ```markdown\n   * > | \"a\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      effects.enter(type)\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      marker = code === 40 ? 41 : code\n      return begin\n    }\n    return nok(code)\n  }\n\n  /**\n   * After opening marker.\n   *\n   * This is also used at the closing marker.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function begin(code) {\n    if (code === marker) {\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n    effects.enter(stringType)\n    return atBreak(code)\n  }\n\n  /**\n   * At something, before something else.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType)\n      return begin(marker)\n    }\n    if (code === null) {\n      return nok(code)\n    }\n\n    // Note: blank lines can’t exist in content.\n    if (markdownLineEnding(code)) {\n      // To do: use `space_or_tab_eol_with_options`, connect.\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return factorySpace(effects, atBreak, 'linePrefix')\n    }\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return inside(code)\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n    effects.consume(code)\n    return code === 92 ? escape : inside\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | \"a\\*b\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function escape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code)\n      return inside\n    }\n    return inside(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   line endings or spaces in markdown are often optional, in which case this\n *     factory can be used and `ok` will be switched to whether spaces were found\n *     or not\n * *   one line ending or space can be detected with\n *     `markdownLineEndingOrSpace(code)` right before using `factoryWhitespace`\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @returns\n *   Start state.\n */\nexport function factoryWhitespace(effects, ok) {\n  /** @type {boolean} */\n  let seen\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      seen = true\n      return start\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(\n        effects,\n        start,\n        seen ? 'linePrefix' : 'lineSuffix'\n      )(code)\n    }\n    return ok(code)\n  }\n}\n","// This module is generated by `script/`.\n//\n// CommonMark handles attention (emphasis, strong) markers based on what comes\n// before or after them.\n// One such difference is if those characters are Unicode punctuation.\n// This script is generated from the Unicode data.\n\n/**\n * Regular expression that matches a unicode punctuation character.\n */\nexport const unicodePunctuationRegex =\n  /[!-\\/:-@\\[-`\\{-~\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061D-\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1B7D\\u1B7E\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52-\\u2E5D\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\n\nimport {unicodePunctuationRegex} from './lib/unicode-punctuation-regex.js'\n\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAlpha = regexCheck(/[A-Za-z]/)\n\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/)\n\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/)\n\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  )\n}\n\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiDigit = regexCheck(/\\d/)\n\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/)\n\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/)\n\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2\n}\n\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32)\n}\n\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32\n}\n\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodePunctuation = regexCheck(unicodePunctuationRegex)\n\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/)\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n * @returns {(code: Code) => boolean}\n */\nfunction regexCheck(regex) {\n  return check\n\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code\n   *   Character code.\n   * @returns {boolean}\n   *   Whether the character code matches the bound regex.\n   */\n  function check(code) {\n    return code !== null && regex.test(String.fromCharCode(code))\n  }\n}\n","/**\n * Like `Array#splice`, but smarter for giant arrays.\n *\n * `Array#splice` takes all items to be inserted as individual argument which\n * causes a stack overflow in V8 when trying to insert 100k items for instance.\n *\n * Otherwise, this does not return the removed items, and takes `items` as an\n * array instead of rest parameters.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {number} start\n *   Index to remove/insert at (can be negative).\n * @param {number} remove\n *   Number of items to remove.\n * @param {Array<T>} items\n *   Items to inject into `list`.\n * @returns {void}\n *   Nothing.\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length\n  let chunkStart = 0\n  /** @type {Array<unknown>} */\n  let parameters\n\n  // Make start between zero and `end` (included).\n  if (start < 0) {\n    start = -start > end ? 0 : end + start\n  } else {\n    start = start > end ? end : start\n  }\n  remove = remove > 0 ? remove : 0\n\n  // No need to chunk the items if there’s only a couple (10k) items.\n  if (items.length < 10000) {\n    parameters = Array.from(items)\n    parameters.unshift(start, remove)\n    // @ts-expect-error Hush, it’s fine.\n    list.splice(...parameters)\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) list.splice(start, remove)\n\n    // Insert the items in chunks to not cause stack overflows.\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000)\n      parameters.unshift(start, 0)\n      // @ts-expect-error Hush, it’s fine.\n      list.splice(...parameters)\n      chunkStart += 10000\n      start += 10000\n    }\n  }\n}\n\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {Array<T>} items\n *   Items to add to `list`.\n * @returns {Array<T>}\n *   Either `list` or `items`.\n */\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items)\n    return list\n  }\n  return items\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\n\nimport {\n  markdownLineEndingOrSpace,\n  unicodePunctuation,\n  unicodeWhitespace\n} from 'micromark-util-character'\n/**\n * Classify whether a code represents whitespace, punctuation, or something\n * else.\n *\n * Used for attention (emphasis, strong), whose sequences can open or close\n * based on the class of surrounding characters.\n *\n * > 👉 **Note**: eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n *   Code.\n * @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined}\n *   Group.\n */\nexport function classifyCharacter(code) {\n  if (\n    code === null ||\n    markdownLineEndingOrSpace(code) ||\n    unicodeWhitespace(code)\n  ) {\n    return 1\n  }\n  if (unicodePunctuation(code)) {\n    return 2\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Handles} Handles\n * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension\n * @typedef {import('micromark-util-types').NormalizedExtension} NormalizedExtension\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine multiple syntax extensions into one.\n *\n * @param {Array<Extension>} extensions\n *   List of syntax extensions.\n * @returns {NormalizedExtension}\n *   A single combined extension.\n */\nexport function combineExtensions(extensions) {\n  /** @type {NormalizedExtension} */\n  const all = {}\n  let index = -1\n\n  while (++index < extensions.length) {\n    syntaxExtension(all, extensions[index])\n  }\n\n  return all\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {NormalizedExtension} all\n *   Extension to merge into.\n * @param {Extension} extension\n *   Extension to merge.\n * @returns {void}\n */\nfunction syntaxExtension(all, extension) {\n  /** @type {keyof Extension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    /** @type {Record<string, unknown>} */\n    const left = maybe || (all[hook] = {})\n    /** @type {Record<string, unknown> | undefined} */\n    const right = extension[hook]\n    /** @type {string} */\n    let code\n\n    if (right) {\n      for (code in right) {\n        if (!hasOwnProperty.call(left, code)) left[code] = []\n        const value = right[code]\n        constructs(\n          // @ts-expect-error Looks like a list.\n          left[code],\n          Array.isArray(value) ? value : value ? [value] : []\n        )\n      }\n    }\n  }\n}\n\n/**\n * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {Array<unknown>} existing\n * @param {Array<unknown>} list\n * @returns {void}\n */\nfunction constructs(existing, list) {\n  let index = -1\n  /** @type {Array<unknown>} */\n  const before = []\n\n  while (++index < list.length) {\n    // @ts-expect-error Looks like an object.\n    ;(list[index].add === 'after' ? existing : before).push(list[index])\n  }\n\n  splice(existing, 0, 0, before)\n}\n\n/**\n * Combine multiple HTML extensions into one.\n *\n * @param {Array<HtmlExtension>} htmlExtensions\n *   List of HTML extensions.\n * @returns {HtmlExtension}\n *   A single combined HTML extension.\n */\nexport function combineHtmlExtensions(htmlExtensions) {\n  /** @type {HtmlExtension} */\n  const handlers = {}\n  let index = -1\n\n  while (++index < htmlExtensions.length) {\n    htmlExtension(handlers, htmlExtensions[index])\n  }\n\n  return handlers\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {HtmlExtension} all\n *   Extension to merge into.\n * @param {HtmlExtension} extension\n *   Extension to merge.\n * @returns {void}\n */\nfunction htmlExtension(all, extension) {\n  /** @type {keyof HtmlExtension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    const left = maybe || (all[hook] = {})\n    const right = extension[hook]\n    /** @type {keyof Handles} */\n    let type\n\n    if (right) {\n      for (type in right) {\n        // @ts-expect-error assume document vs regular handler are managed correctly.\n        left[type] = right[type]\n      }\n    }\n  }\n}\n","/**\n * Turn the number (in string form as either hexa- or plain decimal) coming from\n * a numeric character reference into a character.\n *\n * Sort of like `String.fromCharCode(Number.parseInt(value, base))`, but makes\n * non-characters and control characters safe.\n *\n * @param {string} value\n *   Value to decode.\n * @param {number} base\n *   Numeric base.\n * @returns {string}\n *   Character.\n */\nexport function decodeNumericCharacterReference(value, base) {\n  const code = Number.parseInt(value, base)\n  if (\n    // C0 except for HT, LF, FF, CR, space.\n    code < 9 ||\n    code === 11 ||\n    (code > 13 && code < 32) ||\n    // Control character (DEL) of C0, and C1 controls.\n    (code > 126 && code < 160) ||\n    // Lone high surrogates and low surrogates.\n    (code > 55295 && code < 57344) ||\n    // Noncharacters.\n    (code > 64975 && code < 65008) /* eslint-disable no-bitwise */ ||\n    (code & 65535) === 65535 ||\n    (code & 65535) === 65534 /* eslint-enable no-bitwise */ ||\n    // Out of range\n    code > 1114111\n  ) {\n    return '\\uFFFD'\n  }\n  return String.fromCharCode(code)\n}\n","import {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {decodeNumericCharacterReference} from 'micromark-util-decode-numeric-character-reference'\nconst characterEscapeOrReference =\n  /\\\\([!-/:-@[-`{-~])|&(#(?:\\d{1,7}|x[\\da-f]{1,6})|[\\da-z]{1,31});/gi\n\n/**\n * Decode markdown strings (which occur in places such as fenced code info\n * strings, destinations, labels, and titles).\n *\n * The “string” content type allows character escapes and -references.\n * This decodes those.\n *\n * @param {string} value\n *   Value to decode.\n * @returns {string}\n *   Decoded value.\n */\nexport function decodeString(value) {\n  return value.replace(characterEscapeOrReference, decode)\n}\n\n/**\n * @param {string} $0\n * @param {string} $1\n * @param {string} $2\n * @returns {string}\n */\nfunction decode($0, $1, $2) {\n  if ($1) {\n    // Escape.\n    return $1\n  }\n\n  // Reference.\n  const head = $2.charCodeAt(0)\n  if (head === 35) {\n    const head = $2.charCodeAt(1)\n    const hex = head === 120 || head === 88\n    return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10)\n  }\n  return decodeNamedCharacterReference($2) || $0\n}\n","/**\n * Normalize an identifier (as found in references, definitions).\n *\n * Collapses markdown whitespace, trim, and then lower- and uppercase.\n *\n * Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their\n * lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different\n * uppercase character (U+0398 (`Θ`)).\n * So, to get a canonical form, we perform both lower- and uppercase.\n *\n * Using uppercase last makes sure keys will never interact with default\n * prototypal values (such as `constructor`): nothing in the prototype of\n * `Object` is uppercase.\n *\n * @param {string} value\n *   Identifier to normalize.\n * @returns {string}\n *   Normalized identifier.\n */\nexport function normalizeIdentifier(value) {\n  return (\n    value\n      // Collapse markdown whitespace.\n      .replace(/[\\t\\n\\r ]+/g, ' ')\n      // Trim.\n      .replace(/^ | $/g, '')\n      // Some characters are considered “uppercase”, but if their lowercase\n      // counterpart is uppercased will result in a different uppercase\n      // character.\n      // Hence, to get that form, we perform both lower- and uppercase.\n      // Upper case makes sure keys will not interact with default prototypal\n      // methods: no method is uppercase.\n      .toLowerCase()\n      .toUpperCase()\n  )\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {Array<{resolveAll?: Resolver | undefined}>} constructs\n *   List of constructs, optionally with `resolveAll`s.\n * @param {Array<Event>} events\n *   List of events.\n * @param {TokenizeContext} context\n *   Context used by `tokenize`.\n * @returns {Array<Event>}\n *   Changed events.\n */\nexport function resolveAll(constructs, events, context) {\n  /** @type {Array<Resolver>} */\n  const called = []\n  let index = -1\n\n  while (++index < constructs.length) {\n    const resolve = constructs[index].resolveAll\n\n    if (resolve && !called.includes(resolve)) {\n      events = resolve(events, context)\n      called.push(resolve)\n    }\n  }\n\n  return events\n}\n","import {asciiAlphanumeric} from 'micromark-util-character'\nimport {encode} from 'micromark-util-encode'\n/**\n * Make a value safe for injection as a URL.\n *\n * This encodes unsafe characters with percent-encoding and skips already\n * encoded sequences (see `normalizeUri`).\n * Further unsafe characters are encoded as character references (see\n * `micromark-util-encode`).\n *\n * A regex of allowed protocols can be given, in which case the URL is\n * sanitized.\n * For example, `/^(https?|ircs?|mailto|xmpp)$/i` can be used for `a[href]`, or\n * `/^https?$/i` for `img[src]` (this is what `github.com` allows).\n * If the URL includes an unknown protocol (one not matched by `protocol`, such\n * as a dangerous example, `javascript:`), the value is ignored.\n *\n * @param {string | undefined} url\n *   URI to sanitize.\n * @param {RegExp | null | undefined} [protocol]\n *   Allowed protocols.\n * @returns {string}\n *   Sanitized URI.\n */\nexport function sanitizeUri(url, protocol) {\n  const value = encode(normalizeUri(url || ''))\n  if (!protocol) {\n    return value\n  }\n  const colon = value.indexOf(':')\n  const questionMark = value.indexOf('?')\n  const numberSign = value.indexOf('#')\n  const slash = value.indexOf('/')\n  if (\n    // If there is no protocol, it’s relative.\n    colon < 0 ||\n    // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.\n    (slash > -1 && colon > slash) ||\n    (questionMark > -1 && colon > questionMark) ||\n    (numberSign > -1 && colon > numberSign) ||\n    // It is a protocol, it should be allowed.\n    protocol.test(value.slice(0, colon))\n  ) {\n    return value\n  }\n  return ''\n}\n\n/**\n * Normalize a URL.\n *\n * Encode unsafe characters with percent-encoding, skipping already encoded\n * sequences.\n *\n * @param {string} value\n *   URI to normalize.\n * @returns {string}\n *   Normalized URI.\n */\nexport function normalizeUri(value) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n  let start = 0\n  let skip = 0\n  while (++index < value.length) {\n    const code = value.charCodeAt(index)\n    /** @type {string} */\n    let replace = ''\n\n    // A correct percent encoded value.\n    if (\n      code === 37 &&\n      asciiAlphanumeric(value.charCodeAt(index + 1)) &&\n      asciiAlphanumeric(value.charCodeAt(index + 2))\n    ) {\n      skip = 2\n    }\n    // ASCII.\n    else if (code < 128) {\n      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {\n        replace = String.fromCharCode(code)\n      }\n    }\n    // Astral.\n    else if (code > 55295 && code < 57344) {\n      const next = value.charCodeAt(index + 1)\n\n      // A correct surrogate pair.\n      if (code < 56320 && next > 56319 && next < 57344) {\n        replace = String.fromCharCode(code, next)\n        skip = 1\n      }\n      // Lone surrogate.\n      else {\n        replace = '\\uFFFD'\n      }\n    }\n    // Unicode.\n    else {\n      replace = String.fromCharCode(code)\n    }\n    if (replace) {\n      result.push(value.slice(start, index), encodeURIComponent(replace))\n      start = index + skip + 1\n      replace = ''\n    }\n    if (skip) {\n      index += skip\n      skip = 0\n    }\n  }\n  return result.join('') + value.slice(start)\n}\n","/**\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Token} Token\n */\n\nimport {splice} from 'micromark-util-chunked'\n/**\n * Tokenize subcontent.\n *\n * @param {Array<Event>} events\n *   List of events.\n * @returns {boolean}\n *   Whether subtokens were found.\n */\nexport function subtokenize(events) {\n  /** @type {Record<string, number>} */\n  const jumps = {}\n  let index = -1\n  /** @type {Event} */\n  let event\n  /** @type {number | undefined} */\n  let lineIndex\n  /** @type {number} */\n  let otherIndex\n  /** @type {Event} */\n  let otherEvent\n  /** @type {Array<Event>} */\n  let parameters\n  /** @type {Array<Event>} */\n  let subevents\n  /** @type {boolean | undefined} */\n  let more\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index]\n    }\n    event = events[index]\n\n    // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n    if (\n      index &&\n      event[1].type === 'chunkFlow' &&\n      events[index - 1][1].type === 'listItemPrefix'\n    ) {\n      subevents = event[1]._tokenizer.events\n      otherIndex = 0\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'lineEndingBlank'\n      ) {\n        otherIndex += 2\n      }\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'content'\n      ) {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === 'content') {\n            break\n          }\n          if (subevents[otherIndex][1].type === 'chunkText') {\n            subevents[otherIndex][1]._isInFirstContentOfListItem = true\n            otherIndex++\n          }\n        }\n      }\n    }\n\n    // Enter.\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        Object.assign(jumps, subcontent(events, index))\n        index = jumps[index]\n        more = true\n      }\n    }\n    // Exit.\n    else if (event[1]._container) {\n      otherIndex = index\n      lineIndex = undefined\n      while (otherIndex--) {\n        otherEvent = events[otherIndex]\n        if (\n          otherEvent[1].type === 'lineEnding' ||\n          otherEvent[1].type === 'lineEndingBlank'\n        ) {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events[lineIndex][1].type = 'lineEndingBlank'\n            }\n            otherEvent[1].type = 'lineEnding'\n            lineIndex = otherIndex\n          }\n        } else {\n          break\n        }\n      }\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = Object.assign({}, events[lineIndex][1].start)\n\n        // Switch container exit w/ line endings.\n        parameters = events.slice(lineIndex, index)\n        parameters.unshift(event)\n        splice(events, lineIndex, index - lineIndex + 1, parameters)\n      }\n    }\n  }\n  return !more\n}\n\n/**\n * Tokenize embedded tokens.\n *\n * @param {Array<Event>} events\n * @param {number} eventIndex\n * @returns {Record<string, number>}\n */\nfunction subcontent(events, eventIndex) {\n  const token = events[eventIndex][1]\n  const context = events[eventIndex][2]\n  let startPosition = eventIndex - 1\n  /** @type {Array<number>} */\n  const startPositions = []\n  const tokenizer =\n    token._tokenizer || context.parser[token.contentType](token.start)\n  const childEvents = tokenizer.events\n  /** @type {Array<[number, number]>} */\n  const jumps = []\n  /** @type {Record<string, number>} */\n  const gaps = {}\n  /** @type {Array<Chunk>} */\n  let stream\n  /** @type {Token | undefined} */\n  let previous\n  let index = -1\n  /** @type {Token | undefined} */\n  let current = token\n  let adjust = 0\n  let start = 0\n  const breaks = [start]\n\n  // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n  while (current) {\n    // Find the position of the event for this token.\n    while (events[++startPosition][1] !== current) {\n      // Empty.\n    }\n    startPositions.push(startPosition)\n    if (!current._tokenizer) {\n      stream = context.sliceStream(current)\n      if (!current.next) {\n        stream.push(null)\n      }\n      if (previous) {\n        tokenizer.defineSkip(current.start)\n      }\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true\n      }\n      tokenizer.write(stream)\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined\n      }\n    }\n\n    // Unravel the next token.\n    previous = current\n    current = current.next\n  }\n\n  // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n  current = token\n  while (++index < childEvents.length) {\n    if (\n      // Find a void token that includes a break.\n      childEvents[index][0] === 'exit' &&\n      childEvents[index - 1][0] === 'enter' &&\n      childEvents[index][1].type === childEvents[index - 1][1].type &&\n      childEvents[index][1].start.line !== childEvents[index][1].end.line\n    ) {\n      start = index + 1\n      breaks.push(start)\n      // Help GC.\n      current._tokenizer = undefined\n      current.previous = undefined\n      current = current.next\n    }\n  }\n\n  // Help GC.\n  tokenizer.events = []\n\n  // If there’s one more token (which is the cases for lines that end in an\n  // EOF), that’s perfect: the last point we found starts it.\n  // If there isn’t then make sure any remaining content is added to it.\n  if (current) {\n    // Help GC.\n    current._tokenizer = undefined\n    current.previous = undefined\n  } else {\n    breaks.pop()\n  }\n\n  // Now splice the events from the subtokenizer into the current events,\n  // moving back to front so that splice indices aren’t affected.\n  index = breaks.length\n  while (index--) {\n    const slice = childEvents.slice(breaks[index], breaks[index + 1])\n    const start = startPositions.pop()\n    jumps.unshift([start, start + slice.length - 1])\n    splice(events, start, 2, slice)\n  }\n  index = -1\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1]\n    adjust += jumps[index][1] - jumps[index][0] - 1\n  }\n  return gaps\n}\n"],"names":["safeIsNaN","Number","isNaN","value","areInputsEqual","newInputs","lastInputs","length","i","first","second","resultFn","isEqual","lastThis","lastResult","lastArgs","calledOnce","newArgs","_i","arguments","this","apply","attention","name","tokenize","effects","ok","attentionMarkers","parser","constructs","null","previous","before","marker","code","enter","inside","consume","token","exit","after","open","includes","close","_open","Boolean","_close","resolveAll","events","context","group","text","openingSequence","closingSequence","use","nextEvents","offset","index","type","sliceSerialize","charCodeAt","end","start","Object","assign","movePoint","insideSpan","slice","point","column","_bufferIndex","autolink","nok","size","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","next","blankLine","f","partial","blockQuote","self","state","containerState","_container","continuation","contBefore","disable","undefined","attempt","characterEscape","characterReference","max","test","numeric","nonLazyContinuation","lineStart","lazy","now","line","codeFenced","closeStart","startBefore","beforeSequenceClose","sequenceClose","sizeOpen","sequenceCloseAfter","initialPrefix","tail","sequenceOpen","beforeSequenceOpen","infoBefore","interrupt","check","atNonLazyBreak","contentType","info","metaBefore","meta","contentBefore","contentStart","beforeContentChunk","contentChunk","concrete","codeIndented","afterPrefix","atBreak","furtherStart","codeText","between","data","resolve","tailExitIndex","headEnterIndex","splice","content","chunkInside","contentEnd","continuationConstruct","contentContinue","prefixed","flow","definition","identifier","labelAfter","markerAfter","destinationBefore","destinationAfter","titleBefore","afterWhitespace","defined","push","beforeMarker","titleAfter","titleAfterOptionalWhitespace","hardBreakEscape","headingAtx","sequenceFurther","htmlBlockNames","htmlRawNames","htmlFlow","closingTag","buffer","markerB","declarationOpen","tagCloseStart","continuationDeclarationInside","String","fromCharCode","tagName","commentOpenInside","cdataOpenInside","slash","toLowerCase","basicSelfClosing","completeClosingTagAfter","completeAttributeNameBefore","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCdataInside","continuationStart","blankLineBefore","continuationAfter","nonLazyContinuationStart","continuationStartNonLazy","continuationBefore","continuationRawEndTag","resolveTo","htmlText","returnState","instruction","tagOpen","declaration","commentEnd","comment","commentClose","lineEndingBefore","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","lineEndingAfter","lineEndingAfterPrefix","labelEnd","labelStart","_balanced","_inactive","labelEndNok","resourceConstruct","labelEndOk","referenceFullConstruct","referenceNotFull","referenceCollapsedConstruct","media","label","resourceBefore","resourceOpen","resourceEnd","resourceDestinationAfter","resourceDestinationMissing","resourceBetween","resourceTitleAfter","referenceFullAfter","referenceFullMissing","referenceCollapsedOpen","labelStartImage","labelStartLink","lineEnding","list","initialSize","kind","atMarker","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","_closeFlow","furtherBlankLines","notInCurrentItem","indentConstruct","setextUnderline","paragraph","heading","thematicBreak","sequence","wwwPrefix","wwwPrefixInside","wwwPrefixAfter","domain","underscoreInLastSegment","underscoreInLastLastSegment","seen","domainInside","trail","domainAfter","domainAtPunctuation","path","sizeClose","pathInside","pathAtPunctuation","trailCharRefStart","trailBracketAfter","trailCharRefInside","emailDomainDotTrail","wwwAutolink","previousWww","call","previousUnbalanced","wwwAfter","protocolAutolink","previousProtocol","fromCodePoint","protocolPrefixInside","protocol","protocolSlashesInside","afterProtocol","protocolAfter","emailAutolink","dot","gfmAtext","previousEmail","atext","emailDomain","emailDomainAfter","emailDomainDot","gfmAutolinkLiteral","result","_gfmAutolinkLiteralWalkedInto","indent","tokenizePotentialGfmFootnoteCall","gfmFootnotes","id","codePointAt","resolveToPotentialGfmFootnoteCall","string","chunk","replacement","tokenizeGfmFootnoteCall","callStart","callData","callEscape","tokenizeDefinitionStart","labelAtMarker","labelInside","labelEscape","whitespaceAfter","tokenizeDefinitionContinuation","gfmFootnoteDefinitionEnd","gfmStrikethrough","options","single","singleTilde","tokenizer","more","strikethrough","EditMap","constructor","map","add","remove","editMap","at","addImpl","sort","a","b","vecs","pop","gfmTableAlign","inDelimiterRow","align","event","alignIndex","gfmTable","sizeB","bodyRowStart","headRowBefore","headRowBreak","headRowStart","headDelimiterStart","headRowData","headRowEscape","headDelimiterBefore","headDelimiterValueBefore","headDelimiterCellBefore","headDelimiterNok","headDelimiterLeftAlignmentAfter","headDelimiterCellAfter","headDelimiterFiller","headDelimiterRightAlignmentAfter","bodyRowBreak","bodyRowData","bodyRowEscape","currentTable","currentBody","currentCell","inFirstCellAwaitingPipe","rowKind","lastCell","cell","afterHeadAwaitingFirstBodyRow","lastTableEnd","flushTableEnd","flushCell","_align","range","rowEnd","previousCell","groupName","getPoint","relatedStart","relatedEnd","valueToken","table","tableBody","exits","related","side","tasklistCheck","_gfmTasklistFirstContentOfListItem","spaceThenNonSpace","gfmTaskListItem","gfm","document","factoryDestination","literalType","literalMarkerType","rawType","stringType","limit","POSITIVE_INFINITY","balance","enclosedBefore","raw","enclosed","enclosedEscape","rawEscape","factoryLabel","markerType","factorySpace","prefix","factoryTitle","begin","escape","factoryWhitespace","asciiAlpha","regexCheck","asciiAlphanumeric","asciiAtext","asciiControl","asciiDigit","asciiHexDigit","asciiPunctuation","markdownLineEnding","markdownLineEndingOrSpace","markdownSpace","unicodePunctuation","unicodeWhitespace","regex","items","parameters","chunkStart","Array","from","unshift","classifyCharacter","hasOwnProperty","combineExtensions","extensions","all","syntaxExtension","extension","hook","left","right","isArray","existing","decodeNumericCharacterReference","base","parseInt","characterEscapeOrReference","decodeString","replace","decode","$0","$1","$2","head","hex","normalizeIdentifier","toUpperCase","called","normalizeUri","skip","encodeURIComponent","join","subtokenize","jumps","lineIndex","otherIndex","otherEvent","subevents","_tokenizer","_isInFirstContentOfListItem","subcontent","eventIndex","startPosition","startPositions","childEvents","gaps","stream","current","adjust","breaks","sliceStream","defineSkip","write"],"sourceRoot":""}