admin08077/Githubgemini

1{"version":3,"file":"micromark-core-commonmark-AH8VCgT7.js","sources":["../../node_modules/micromark-core-commonmark/lib/attention.js","../../node_modules/micromark-core-commonmark/lib/autolink.js","../../node_modules/micromark-core-commonmark/lib/blank-line.js","../../node_modules/micromark-core-commonmark/lib/block-quote.js","../../node_modules/micromark-core-commonmark/lib/character-escape.js","../../node_modules/micromark-core-commonmark/lib/character-reference.js","../../node_modules/micromark-core-commonmark/lib/code-fenced.js","../../node_modules/micromark-core-commonmark/lib/code-indented.js","../../node_modules/micromark-core-commonmark/lib/code-text.js","../../node_modules/micromark-core-commonmark/lib/content.js","../../node_modules/micromark-core-commonmark/lib/definition.js","../../node_modules/micromark-core-commonmark/lib/hard-break-escape.js","../../node_modules/micromark-core-commonmark/lib/heading-atx.js","../../node_modules/micromark-core-commonmark/lib/html-flow.js","../../node_modules/micromark-core-commonmark/lib/html-text.js","../../node_modules/micromark-core-commonmark/lib/label-end.js","../../node_modules/micromark-core-commonmark/lib/label-start-image.js","../../node_modules/micromark-core-commonmark/lib/label-start-link.js","../../node_modules/micromark-core-commonmark/lib/line-ending.js","../../node_modules/micromark-core-commonmark/lib/thematic-break.js","../../node_modules/micromark-core-commonmark/lib/list.js","../../node_modules/micromark-core-commonmark/lib/setext-underline.js"],"sourcesContent":["/**\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 * @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').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nexport const thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  let size = 0\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n\n  /**\n   * Start of thematic break.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('thematicBreak')\n    // To do: parse indent like `markdown-rs`.\n    return before(code)\n  }\n\n  /**\n   * After optional whitespace, at marker.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    marker = code\n    return atBreak(code)\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter('thematicBreakSequence')\n      return sequence(code)\n    }\n    if (size >= 3 && (code === null || markdownLineEnding(code))) {\n      effects.exit('thematicBreak')\n      return ok(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      size++\n      return sequence\n    }\n    effects.exit('thematicBreakSequence')\n    return markdownSpace(code)\n      ? factorySpace(effects, atBreak, 'whitespace')(code)\n      : atBreak(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').ContainerState} ContainerState\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {asciiDigit, markdownSpace} from 'micromark-util-character'\nimport {blankLine} from './blank-line.js'\nimport {thematicBreak} from './thematic-break.js'\n\n/** @type {Construct} */\nexport const list = {\n  name: 'list',\n  tokenize: tokenizeListStart,\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd\n}\n\n/** @type {Construct} */\nconst listItemPrefixWhitespaceConstruct = {\n  tokenize: tokenizeListItemPrefixWhitespace,\n  partial: true\n}\n\n/** @type {Construct} */\nconst indentConstruct = {\n  tokenize: tokenizeIndent,\n  partial: true\n}\n\n// To do: `markdown-rs` parses list items on their own and later stitches them\n// together.\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeListStart(effects, ok, nok) {\n  const self = this\n  const tail = self.events[self.events.length - 1]\n  let initialSize =\n    tail && tail[1].type === 'linePrefix'\n      ? tail[2].sliceSerialize(tail[1], true).length\n      : 0\n  let size = 0\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    const kind =\n      self.containerState.type ||\n      (code === 42 || code === 43 || code === 45\n        ? 'listUnordered'\n        : 'listOrdered')\n    if (\n      kind === 'listUnordered'\n        ? !self.containerState.marker || code === self.containerState.marker\n        : asciiDigit(code)\n    ) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind\n        effects.enter(kind, {\n          _container: true\n        })\n      }\n      if (kind === 'listUnordered') {\n        effects.enter('listItemPrefix')\n        return code === 42 || code === 45\n          ? effects.check(thematicBreak, nok, atMarker)(code)\n          : atMarker(code)\n      }\n      if (!self.interrupt || code === 49) {\n        effects.enter('listItemPrefix')\n        effects.enter('listItemValue')\n        return inside(code)\n      }\n    }\n    return nok(code)\n  }\n\n  /** @type {State} */\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code)\n      return inside\n    }\n    if (\n      (!self.interrupt || size < 2) &&\n      (self.containerState.marker\n        ? code === self.containerState.marker\n        : code === 41 || code === 46)\n    ) {\n      effects.exit('listItemValue')\n      return atMarker(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * @type {State}\n   **/\n  function atMarker(code) {\n    effects.enter('listItemMarker')\n    effects.consume(code)\n    effects.exit('listItemMarker')\n    self.containerState.marker = self.containerState.marker || code\n    return effects.check(\n      blankLine,\n      // Can’t be empty when interrupting.\n      self.interrupt ? nok : onBlank,\n      effects.attempt(\n        listItemPrefixWhitespaceConstruct,\n        endOfPrefix,\n        otherPrefix\n      )\n    )\n  }\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true\n    initialSize++\n    return endOfPrefix(code)\n  }\n\n  /** @type {State} */\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter('listItemPrefixWhitespace')\n      effects.consume(code)\n      effects.exit('listItemPrefixWhitespace')\n      return endOfPrefix\n    }\n    return nok(code)\n  }\n\n  /** @type {State} */\n  function endOfPrefix(code) {\n    self.containerState.size =\n      initialSize +\n      self.sliceSerialize(effects.exit('listItemPrefix'), true).length\n    return ok(code)\n  }\n}\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeListContinuation(effects, ok, nok) {\n  const self = this\n  self.containerState._closeFlow = undefined\n  return effects.check(blankLine, onBlank, notBlank)\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.furtherBlankLines =\n      self.containerState.furtherBlankLines ||\n      self.containerState.initialBlankLine\n\n    // We have a blank line.\n    // Still, try to consume at most the items size.\n    return factorySpace(\n      effects,\n      ok,\n      'listItemIndent',\n      self.containerState.size + 1\n    )(code)\n  }\n\n  /** @type {State} */\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = undefined\n      self.containerState.initialBlankLine = undefined\n      return notInCurrentItem(code)\n    }\n    self.containerState.furtherBlankLines = undefined\n    self.containerState.initialBlankLine = undefined\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code)\n  }\n\n  /** @type {State} */\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true\n    // As we’re closing flow, we’re no longer interrupting.\n    self.interrupt = undefined\n    // Always populated by defaults.\n\n    return factorySpace(\n      effects,\n      effects.attempt(list, ok, nok),\n      'linePrefix',\n      self.parser.constructs.disable.null.includes('codeIndented')\n        ? undefined\n        : 4\n    )(code)\n  }\n}\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemIndent',\n    self.containerState.size + 1\n  )\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'listItemIndent' &&\n      tail[2].sliceSerialize(tail[1], true).length === self.containerState.size\n      ? ok(code)\n      : nok(code)\n  }\n}\n\n/**\n * @type {Exiter}\n * @this {TokenizeContext}\n */\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type)\n}\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  const self = this\n\n  // Always populated by defaults.\n\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemPrefixWhitespace',\n    self.parser.constructs.disable.null.includes('codeIndented')\n      ? undefined\n      : 4 + 1\n  )\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return !markdownSpace(code) &&\n      tail &&\n      tail[1].type === 'listItemPrefixWhitespace'\n      ? ok(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').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"],"names":["attention","tokenizeAttention","resolveAllAttention","events","context","index","open","group","text","openingSequence","closingSequence","use","nextEvents","offset","start","end","movePoint","push","resolveAll","splice","effects","ok","attentionMarkers","previous","before","classifyCharacter","marker","code","inside","token","after","close","point","autolink","tokenizeAutolink","nok","size","asciiAlpha","schemeOrEmailAtext","emailAtext","asciiAlphanumeric","schemeInsideOrEmailAtext","urlInside","asciiControl","emailAtSignOrDot","asciiAtext","emailLabel","emailValue","next","blankLine","tokenizeBlankLine","markdownSpace","factorySpace","markdownLineEnding","blockQuote","tokenizeBlockQuoteStart","tokenizeBlockQuoteContinuation","exit","self","state","contStart","contBefore","characterEscape","tokenizeCharacterEscape","asciiPunctuation","characterReference","tokenizeCharacterReference","max","test","numeric","value","asciiHexDigit","asciiDigit","decodeNamedCharacterReference","nonLazyContinuation","tokenizeNonLazyContinuation","codeFenced","tokenizeCodeFenced","closeStart","tokenizeCloseStart","initialPrefix","sizeOpen","beforeSequenceOpen","tail","sequenceOpen","infoBefore","atNonLazyBreak","info","metaBefore","meta","contentBefore","contentStart","beforeContentChunk","contentChunk","startBefore","beforeSequenceClose","sequenceClose","sequenceCloseAfter","lineStart","codeIndented","tokenizeCodeIndented","furtherStart","tokenizeFurtherStart","afterPrefix","atBreak","codeText","tokenizeCodeText","resolveCodeText","tailExitIndex","headEnterIndex","enter","between","data","content","tokenizeContent","resolveContent","continuationConstruct","tokenizeContinuation","subtokenize","chunkStart","chunkInside","contentEnd","contentContinue","startLookahead","prefixed","definition","tokenizeDefinition","titleBefore","tokenizeTitleBefore","identifier","factoryLabel","labelAfter","normalizeIdentifier","markerAfter","markdownLineEndingOrSpace","factoryWhitespace","destinationBefore","factoryDestination","destinationAfter","afterWhitespace","beforeMarker","factoryTitle","titleAfter","titleAfterOptionalWhitespace","hardBreakEscape","tokenizeHardBreakEscape","headingAtx","tokenizeHeadingAtx","resolveHeadingAtx","sequenceFurther","htmlFlow","tokenizeHtmlFlow","resolveToHtmlFlow","blankLineBefore","tokenizeBlankLineBefore","nonLazyContinuationStart","tokenizeNonLazyContinuationStart","closingTag","buffer","markerB","declarationOpen","tagCloseStart","continuationDeclarationInside","tagName","commentOpenInside","cdataOpenInside","continuation","slash","name","htmlRawNames","htmlBlockNames","basicSelfClosing","completeClosingTagAfter","completeAttributeNameBefore","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCdataInside","continuationAfter","continuationStart","continuationStartNonLazy","continuationBefore","continuationRawEndTag","htmlText","tokenizeHtmlText","returnState","instruction","tagOpen","declaration","commentEnd","comment","commentClose","lineEndingBefore","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","lineEndingAfter","lineEndingAfterPrefix","labelEnd","tokenizeLabelEnd","resolveToLabelEnd","resolveAllLabelEnd","resourceConstruct","tokenizeResource","referenceFullConstruct","tokenizeReferenceFull","referenceCollapsedConstruct","tokenizeReferenceCollapsed","media","label","labelStart","defined","labelEndNok","labelEndOk","referenceNotFull","resourceStart","resourceBefore","resourceOpen","resourceEnd","resourceDestinationAfter","resourceDestinationMissing","resourceBetween","resourceTitleAfter","referenceFull","referenceFullAfter","referenceFullMissing","referenceCollapsedStart","referenceCollapsedOpen","labelStartImage","tokenizeLabelStartImage","labelStartLink","tokenizeLabelStartLink","lineEnding","tokenizeLineEnding","thematicBreak","tokenizeThematicBreak","sequence","list","tokenizeListStart","tokenizeListContinuation","tokenizeListEnd","listItemPrefixWhitespaceConstruct","tokenizeListItemPrefixWhitespace","indentConstruct","tokenizeIndent","initialSize","kind","atMarker","onBlank","endOfPrefix","otherPrefix","notBlank","notInCurrentItem","setextUnderline","tokenizeSetextUnderline","resolveToSetextUnderline","heading","paragraph"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21]}