{"version":3,"file":"react/js/vendor.micromark-core-commonmark@current.f93da21f0ce57a3eadea.js","mappings":"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","sources":["webpack:///./node_modules/micromark-core-commonmark/lib/attention.js","webpack:///./node_modules/micromark-core-commonmark/lib/autolink.js","webpack:///./node_modules/micromark-core-commonmark/lib/blank-line.js","webpack:///./node_modules/micromark-core-commonmark/lib/block-quote.js","webpack:///./node_modules/micromark-core-commonmark/lib/character-escape.js","webpack:///./node_modules/micromark-core-commonmark/lib/character-reference.js","webpack:///./node_modules/micromark-core-commonmark/lib/code-fenced.js","webpack:///./node_modules/micromark-core-commonmark/lib/code-indented.js","webpack:///./node_modules/micromark-core-commonmark/lib/code-text.js","webpack:///./node_modules/micromark-core-commonmark/lib/content.js","webpack:///./node_modules/micromark-core-commonmark/lib/definition.js","webpack:///./node_modules/micromark-core-commonmark/lib/hard-break-escape.js","webpack:///./node_modules/micromark-core-commonmark/lib/heading-atx.js","webpack:///./node_modules/micromark-core-commonmark/lib/html-flow.js","webpack:///./node_modules/micromark-core-commonmark/lib/html-text.js","webpack:///./node_modules/micromark-core-commonmark/lib/label-end.js","webpack:///./node_modules/micromark-core-commonmark/lib/label-start-image.js","webpack:///./node_modules/micromark-core-commonmark/lib/label-start-link.js","webpack:///./node_modules/micromark-core-commonmark/lib/line-ending.js","webpack:///./node_modules/micromark-core-commonmark/lib/list.js","webpack:///./node_modules/micromark-core-commonmark/lib/setext-underline.js","webpack:///./node_modules/micromark-core-commonmark/lib/thematic-break.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 */\n// eslint-disable-next-line complexity\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 (events[index][0] === 'enter' && events[index][1].type === 'attentionSequence' && events[index][1]._close) {\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 (events[open][0] === 'exit' && events[open][1].type === 'attentionSequence' && events[open][1]._open &&\n        // If the markers are the same:\n        context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {\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 ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) {\n            continue;\n          }\n\n          // Number of markers to use from the sequence.\n          use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 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, [['enter', events[open][1], context], ['exit', events[open][1], context]]);\n          }\n\n          // Opening.\n          nextEvents = push(nextEvents, [['enter', group, context], ['enter', openingSequence, context], ['exit', openingSequence, context], ['enter', text, context]]);\n\n          // Always populated by defaults.\n\n          // Between.\n          nextEvents = push(nextEvents, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context));\n\n          // Closing.\n          nextEvents = push(nextEvents, [['exit', text, context], ['enter', closingSequence, context], ['exit', closingSequence, context], ['exit', group, context]]);\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, [['enter', events[index][1], context], ['exit', events[index][1], context]]);\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 = !after || after === 2 && before || attentionMarkers.includes(code);\n    const close = !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 {undefined}\n */\nfunction movePoint(point, offset) {\n  point.column += offset;\n  point.offset += offset;\n  point._bufferIndex += offset;\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 { asciiAlpha, asciiAlphanumeric, asciiAtext, asciiControl } 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    if (code === 64) {\n      return nok(code);\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 ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) {\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 * @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) ? factorySpace(effects, after, \"linePrefix\")(code) : 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 * @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(effects, contBefore, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(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 * @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 * @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 { asciiAlphanumeric, asciiDigit, asciiHexDigit } 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 (test === asciiAlphanumeric && !decodeNamedCharacterReference(self.sliceSerialize(token))) {\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 * @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 = tail && tail[1].type === \"linePrefix\" ? tail[2].sliceSerialize(tail[1], true).length : 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) ? factorySpace(effects, infoBefore, \"whitespace\")(code) : 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 ? ok(code) : 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) ? factorySpace(effects, beforeContentChunk, \"linePrefix\", initialPrefix + 1)(code) : 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) ? factorySpace(effects, beforeSequenceClose, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : 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) ? factorySpace(effects, sequenceCloseAfter, \"whitespace\")(code) : 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 * @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 && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? atBreak(code) : 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 && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? ok(code) : markdownLineEnding(code) ? furtherStart(code) : nok(code);\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 ((events[headEnterIndex][1].type === \"lineEnding\" || events[headEnterIndex][1].type === 'space') && (events[tailExitIndex][1].type === \"lineEnding\" || events[tailExitIndex][1].type === 'space')) {\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 (index === tailExitIndex || events[index][1].type === \"lineEnding\") {\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 code !== 96 || this.events[this.events.length - 1][1].type === \"characterEscape\";\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 (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {\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 * @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(continuationConstruct, contentContinue, contentEnd)(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 (!self.parser.constructs.disable.null.includes('codeIndented') && tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4) {\n      return ok(code);\n    }\n    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code);\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 { markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } 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(self, effects, labelAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionLabel\", \"definitionLabelMarker\", \"definitionLabelString\")(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(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));\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) ? factoryWhitespace(effects, destinationBefore)(code) : 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(effects, destinationAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionDestination\", \"definitionDestinationLiteral\", \"definitionDestinationLiteralMarker\", \"definitionDestinationRaw\", \"definitionDestinationString\")(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) ? factorySpace(effects, afterWhitespace, \"whitespace\")(code) : 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) ? factoryWhitespace(effects, beforeMarker)(code) : 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(effects, titleAfter, nok, \"definitionTitle\", \"definitionTitleMarker\", \"definitionTitleString\")(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) ? factorySpace(effects, titleAfterOptionalWhitespace, \"whitespace\")(code) : 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 * @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 * @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, markdownLineEndingOrSpace, markdownSpace } 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 (contentEnd - 2 > contentStart && events[contentEnd][1].type === \"whitespace\") {\n    contentEnd -= 2;\n  }\n  if (events[contentEnd][1].type === \"atxHeadingSequence\" && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === \"whitespace\")) {\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, [['enter', content, context], ['enter', text, context], ['exit', text, context], ['exit', content, context]]);\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 * @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 { asciiAlpha, asciiAlphanumeric, markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } 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 (code === null || code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\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] ? nok(code) : closingTag ? completeClosingTagAfter(code) : 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 (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\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 (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\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 (code === null || code === 34 || code === 39 || code === 47 || code === 60 || code === 61 || code === 62 || code === 96 || markdownLineEndingOrSpace(code)) {\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(blankLineBefore, continuationAfter, continuationStart)(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(nonLazyContinuationStart, continuationStartNonLazy, continuationAfter)(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 * @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 { asciiAlpha, asciiAlphanumeric, markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } 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 ? end(code) : code === 45 ? commentClose(code) : 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 (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\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 (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\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 (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 96) {\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) ? factorySpace(effects, lineEndingAfterPrefix, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : 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 * @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 (token.type === \"labelImage\" || token.type === \"labelLink\" || token.type === \"labelEnd\") {\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 (token.type === \"link\" || token.type === \"labelLink\" && token._inactive) {\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 (events[index][0] === 'enter' && (token.type === \"labelImage\" || token.type === \"labelLink\") && !token._balanced) {\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 = [['enter', group, context], ['enter', label, context]];\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(media, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + offset + 4, close - 3), context));\n\n  // Text close, marker close, label close.\n  media = push(media, [['exit', text, context], events[close - 2], events[close - 1], ['exit', label, context]]);\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 ((self.events[index][1].type === \"labelImage\" || self.events[index][1].type === \"labelLink\") && !self.events[index][1]._balanced) {\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(normalizeIdentifier(self.sliceSerialize({\n      start: labelStart.end,\n      end: self.now()\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(resourceConstruct, labelEndOk, defined ? labelEndOk : labelEndNok)(code);\n    }\n\n    // Full (`[asd][fgh]`) or collapsed (`[asd][]`) reference?\n    if (code === 91) {\n      return effects.attempt(referenceFullConstruct, labelEndOk, defined ? referenceNotFull : labelEndNok)(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(referenceCollapsedConstruct, labelEndOk, labelEndNok)(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) ? factoryWhitespace(effects, resourceOpen)(code) : 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(effects, resourceDestinationAfter, resourceDestinationMissing, \"resourceDestination\", \"resourceDestinationLiteral\", \"resourceDestinationLiteralMarker\", \"resourceDestinationRaw\", \"resourceDestinationString\", 32)(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) ? factoryWhitespace(effects, resourceBetween)(code) : 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(effects, resourceTitleAfter, nok, \"resourceTitle\", \"resourceTitleMarker\", \"resourceTitleString\")(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) ? factoryWhitespace(effects, resourceEnd)(code) : 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(self, effects, referenceFullAfter, referenceFullMissing, \"reference\", \"referenceMarker\", \"referenceString\")(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(normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1))) ? ok(code) : 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 * @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 ? nok(code) : ok(code);\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 ? nok(code) : ok(code);\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 * @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 = tail && tail[1].type === \"linePrefix\" ? tail[2].sliceSerialize(tail[1], true).length : 0;\n  let size = 0;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    const kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? \"listUnordered\" : \"listOrdered\");\n    if (kind === \"listUnordered\" ? !self.containerState.marker || code === self.containerState.marker : asciiDigit(code)) {\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 ? effects.check(thematicBreak, nok, atMarker)(code) : 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 ((!self.interrupt || size < 2) && (self.containerState.marker ? code === self.containerState.marker : code === 41 || code === 46)) {\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(blankLine,\n    // Can’t be empty when interrupting.\n    self.interrupt ? nok : onBlank, effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix));\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 = initialSize + 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 = self.containerState.furtherBlankLines || self.containerState.initialBlankLine;\n\n    // We have a blank line.\n    // Still, try to consume at most the items size.\n    return factorySpace(effects, ok, \"listItemIndent\", self.containerState.size + 1)(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(effects, effects.attempt(list, ok, nok), \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n  }\n}\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this;\n  return factorySpace(effects, afterPrefix, \"listItemIndent\", self.containerState.size + 1);\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"listItemIndent\" && tail[2].sliceSerialize(tail[1], true).length === self.containerState.size ? ok(code) : 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(effects, afterPrefix, \"listItemPrefixWhitespace\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4 + 1);\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return !markdownSpace(code) && tail && tail[1].type === \"listItemPrefixWhitespace\" ? ok(code) : nok(code);\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 (self.events[index][1].type !== \"lineEnding\" && self.events[index][1].type !== \"linePrefix\" && self.events[index][1].type !== \"content\") {\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) ? factorySpace(effects, after, \"lineSuffix\")(code) : 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 * @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) ? factorySpace(effects, atBreak, \"whitespace\")(code) : atBreak(code);\n  }\n}"],"names":["attention","name","tokenize","effects","ok","attentionMarkers","this","parser","constructs","null","previous","before","marker","code","enter","inside","consume","token","exit","after","open","includes","close","_open","Boolean","_close","resolveAll","events","context","group","text","openingSequence","closingSequence","use","nextEvents","offset","index","length","type","sliceSerialize","charCodeAt","end","start","Object","assign","movePoint","insideSpan","slice","point","column","_bufferIndex","autolink","nok","size","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","next","blankLine","partial","blockQuote","self","state","containerState","_container","continuation","contBefore","disable","undefined","attempt","characterEscape","characterReference","max","test","numeric","value","nonLazyContinuation","lineStart","lazy","now","line","codeFenced","closeStart","startBefore","beforeSequenceClose","sequenceClose","sizeOpen","sequenceCloseAfter","initialPrefix","tail","sequenceOpen","beforeSequenceOpen","infoBefore","interrupt","check","atNonLazyBreak","contentType","info","metaBefore","meta","contentBefore","contentStart","beforeContentChunk","contentChunk","concrete","codeIndented","afterPrefix","atBreak","furtherStart","codeText","between","data","resolve","tailExitIndex","headEnterIndex","splice","content","chunkInside","contentEnd","continuationConstruct","contentContinue","prefixed","flow","definition","identifier","call","labelAfter","markerAfter","destinationBefore","destinationAfter","titleBefore","afterWhitespace","defined","push","beforeMarker","f","titleAfter","titleAfterOptionalWhitespace","hardBreakEscape","headingAtx","sequenceFurther","htmlFlow","closingTag","buffer","markerB","declarationOpen","tagCloseStart","continuationDeclarationInside","String","fromCharCode","tagName","commentOpenInside","cdataOpenInside","slash","toLowerCase","basicSelfClosing","completeClosingTagAfter","completeAttributeNameBefore","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCdataInside","continuationStart","blankLineBefore","continuationAfter","nonLazyContinuationStart","continuationStartNonLazy","continuationBefore","continuationRawEndTag","resolveTo","htmlText","returnState","instruction","tagOpen","declaration","commentEnd","comment","commentClose","lineEndingBefore","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","lineEndingAfter","lineEndingAfterPrefix","labelEnd","labelStart","_balanced","_inactive","labelEndNok","resourceConstruct","labelEndOk","referenceFullConstruct","referenceNotFull","referenceCollapsedConstruct","media","label","resourceBefore","resourceOpen","resourceEnd","resourceDestinationAfter","resourceDestinationMissing","resourceBetween","resourceTitleAfter","referenceFullAfter","referenceFullMissing","referenceCollapsedOpen","labelStartImage","labelStartLink","lineEnding","list","initialSize","kind","atMarker","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","_closeFlow","furtherBlankLines","notInCurrentItem","indentConstruct","setextUnderline","paragraph","heading","thematicBreak","sequence"],"sourceRoot":""}