{"version":3,"file":"static/js/micromark-vendor.eea4ecaf.js","mappings":"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","sources":["../../node_modules/micromark-core-commonmark/lib/attention.js","../../node_modules/micromark-core-commonmark/lib/autolink.js","../../node_modules/micromark-core-commonmark/lib/blank-line.js","../../node_modules/micromark-core-commonmark/lib/block-quote.js","../../node_modules/micromark-core-commonmark/lib/character-escape.js","../../node_modules/micromark-core-commonmark/lib/character-reference.js","../../node_modules/micromark-core-commonmark/lib/code-fenced.js","../../node_modules/micromark-core-commonmark/lib/code-indented.js","../../node_modules/micromark-core-commonmark/lib/code-text.js","../../node_modules/micromark-core-commonmark/lib/content.js","../../node_modules/micromark-core-commonmark/lib/definition.js","../../node_modules/micromark-core-commonmark/lib/hard-break-escape.js","../../node_modules/micromark-core-commonmark/lib/heading-atx.js","../../node_modules/micromark-core-commonmark/lib/html-flow.js","../../node_modules/micromark-core-commonmark/lib/html-text.js","../../node_modules/micromark-core-commonmark/lib/label-end.js","../../node_modules/micromark-core-commonmark/lib/label-start-image.js","../../node_modules/micromark-core-commonmark/lib/label-start-link.js","../../node_modules/micromark-core-commonmark/lib/line-ending.js","../../node_modules/micromark-core-commonmark/lib/list.js","../../node_modules/micromark-core-commonmark/lib/setext-underline.js","../../node_modules/micromark-core-commonmark/lib/thematic-break.js","../../node_modules/micromark-extension-gfm/index.js","../../node_modules/micromark-factory-destination/index.js","../../node_modules/micromark-factory-label/index.js","../../node_modules/micromark-factory-space/index.js","../../node_modules/micromark-factory-title/index.js","../../node_modules/micromark-factory-whitespace/index.js","../../node_modules/micromark-util-character/lib/unicode-punctuation-regex.js","../../node_modules/micromark-util-character/index.js","../../node_modules/micromark-util-chunked/index.js","../../node_modules/micromark-util-encode/index.js","../../node_modules/micromark-util-subtokenize/index.js"],"sourcesContent":["/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\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').Event} Event\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Point} Point\n */\nimport {push, splice} from 'micromark-util-chunked'\nimport {classifyCharacter} from 'micromark-util-classify-character'\nimport {resolveAll} from 'micromark-util-resolve-all'\n\n/** @type {Construct} */\nexport const attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\n}\n/**\n * Take all events and resolve attention to emphasis or strong.\n *\n * @type {Resolver}\n */\n\nfunction resolveAllAttention(events, context) {\n  let index = -1\n  /** @type {number} */\n\n  let open\n  /** @type {Token} */\n\n  let group\n  /** @type {Token} */\n\n  let text\n  /** @type {Token} */\n\n  let openingSequence\n  /** @type {Token} */\n\n  let closingSequence\n  /** @type {number} */\n\n  let use\n  /** @type {Event[]} */\n\n  let nextEvents\n  /** @type {number} */\n\n  let offset // 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\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (\n      events[index][0] === 'enter' &&\n      events[index][1].type === 'attentionSequence' &&\n      events[index][1]._close\n    ) {\n      open = index // Now walk back to find an opener.\n\n      while (open--) {\n        // Find a token that can open the closer.\n        if (\n          events[open][0] === 'exit' &&\n          events[open][1].type === 'attentionSequence' &&\n          events[open][1]._open && // If the markers are the same:\n          context.sliceSerialize(events[open][1]).charCodeAt(0) ===\n            context.sliceSerialize(events[index][1]).charCodeAt(0)\n        ) {\n          // If the opening can close or the closing can open,\n          // and the close size *is not* a multiple of three,\n          // but the sum of the opening and closing size *is* multiple of three,\n          // then don’t match.\n          if (\n            (events[open][1]._close || events[index][1]._open) &&\n            (events[index][1].end.offset - events[index][1].start.offset) % 3 &&\n            !(\n              (events[open][1].end.offset -\n                events[open][1].start.offset +\n                events[index][1].end.offset -\n                events[index][1].start.offset) %\n              3\n            )\n          ) {\n            continue\n          } // Number of markers to use from the sequence.\n\n          use =\n            events[open][1].end.offset - events[open][1].start.offset > 1 &&\n            events[index][1].end.offset - events[index][1].start.offset > 1\n              ? 2\n              : 1\n          const start = Object.assign({}, events[open][1].end)\n          const end = Object.assign({}, events[index][1].start)\n          movePoint(start, -use)\n          movePoint(end, use)\n          openingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start,\n            end: Object.assign({}, events[open][1].end)\n          }\n          closingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: Object.assign({}, events[index][1].start),\n            end\n          }\n          text = {\n            type: use > 1 ? 'strongText' : 'emphasisText',\n            start: Object.assign({}, events[open][1].end),\n            end: Object.assign({}, events[index][1].start)\n          }\n          group = {\n            type: use > 1 ? 'strong' : 'emphasis',\n            start: Object.assign({}, openingSequence.start),\n            end: Object.assign({}, closingSequence.end)\n          }\n          events[open][1].end = Object.assign({}, openingSequence.start)\n          events[index][1].start = Object.assign({}, closingSequence.end)\n          nextEvents = [] // If there are more markers in the opening, add them before.\n\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = push(nextEvents, [\n              ['enter', events[open][1], context],\n              ['exit', events[open][1], context]\n            ])\n          } // Opening.\n\n          nextEvents = push(nextEvents, [\n            ['enter', group, context],\n            ['enter', openingSequence, context],\n            ['exit', openingSequence, context],\n            ['enter', text, context]\n          ]) // Between.\n\n          nextEvents = push(\n            nextEvents,\n            resolveAll(\n              context.parser.constructs.insideSpan.null,\n              events.slice(open + 1, index),\n              context\n            )\n          ) // Closing.\n\n          nextEvents = push(nextEvents, [\n            ['exit', text, context],\n            ['enter', closingSequence, context],\n            ['exit', closingSequence, context],\n            ['exit', group, context]\n          ]) // If there are more markers in the closing, add them after.\n\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2\n            nextEvents = push(nextEvents, [\n              ['enter', events[index][1], context],\n              ['exit', events[index][1], context]\n            ])\n          } else {\n            offset = 0\n          }\n\n          splice(events, open - 1, index - open + 3, nextEvents)\n          index = open + nextEvents.length - offset - 2\n          break\n        }\n      }\n    }\n  } // Remove remaining sequences.\n\n  index = -1\n\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data'\n    }\n  }\n\n  return events\n}\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  /** @type {NonNullable<Code>} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('attentionSequence')\n    marker = code\n    return sequence(code)\n  }\n  /** @type {State} */\n\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return sequence\n    }\n\n    const token = effects.exit('attentionSequence')\n    const after = classifyCharacter(code)\n    const open =\n      !after || (after === 2 && before) || attentionMarkers.includes(code)\n    const close =\n      !before || (before === 2 && after) || attentionMarkers.includes(previous)\n    token._open = Boolean(marker === 42 ? open : open && (before || !close))\n    token._close = Boolean(marker === 42 ? close : close && (after || !open))\n    return ok(code)\n  }\n}\n/**\n * Move a point a bit.\n *\n * Note: `move` only works inside lines! It’s not possible to move past other\n * chunks (replacement characters, tabs, or line endings).\n *\n * @param {Point} point\n * @param {number} offset\n * @returns {void}\n */\n\nfunction movePoint(point, offset) {\n  point.column += offset\n  point.offset += offset\n  point._bufferIndex += offset\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  asciiAtext,\n  asciiControl\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeAutolink(effects, ok, nok) {\n  let size = 1\n  return start\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  /** @type {State} */\n\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return schemeOrEmailAtext\n    }\n\n    return asciiAtext(code) ? emailAtext(code) : nok(code)\n  }\n  /** @type {State} */\n\n  function schemeOrEmailAtext(code) {\n    return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)\n      ? schemeInsideOrEmailAtext(code)\n      : emailAtext(code)\n  }\n  /** @type {State} */\n\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code)\n      return urlInside\n    }\n\n    if (\n      (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) &&\n      size++ < 32\n    ) {\n      effects.consume(code)\n      return schemeInsideOrEmailAtext\n    }\n\n    return emailAtext(code)\n  }\n  /** @type {State} */\n\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit('autolinkProtocol')\n      return end(code)\n    }\n\n    if (code === null || code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code)\n    }\n\n    effects.consume(code)\n    return urlInside\n  }\n  /** @type {State} */\n\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code)\n      size = 0\n      return emailAtSignOrDot\n    }\n\n    if (asciiAtext(code)) {\n      effects.consume(code)\n      return emailAtext\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code)\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\n    if (code === 62) {\n      // Exit, then change the type.\n      effects.exit('autolinkProtocol').type = 'autolinkEmail'\n      return end(code)\n    }\n\n    return emailValue(code)\n  }\n  /** @type {State} */\n\n  function emailValue(code) {\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      effects.consume(code)\n      return code === 45 ? emailValue : emailLabel\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function end(code) {\n    effects.enter('autolinkMarker')\n    effects.consume(code)\n    effects.exit('autolinkMarker')\n    effects.exit('autolink')\n    return ok\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const blankLine = {\n  tokenize: tokenizeBlankLine,\n  partial: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return factorySpace(effects, afterWhitespace, 'linePrefix')\n  /** @type {State} */\n\n  function afterWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownSpace} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (code === 62) {\n      const state = self.containerState\n\n      if (!state.open) {\n        effects.enter('blockQuote', {\n          _container: true\n        })\n        state.open = true\n      }\n\n      effects.enter('blockQuotePrefix')\n      effects.enter('blockQuoteMarker')\n      effects.consume(code)\n      effects.exit('blockQuoteMarker')\n      return after\n    }\n\n    return nok(code)\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\n    effects.exit('blockQuotePrefix')\n    return ok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  return factorySpace(\n    effects,\n    effects.attempt(blockQuote, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4\n  )\n}\n/** @type {Exiter} */\n\nfunction exit(effects) {\n  effects.exit('blockQuote')\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {asciiPunctuation} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start\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 open\n  }\n  /** @type {State} */\n\n  function open(code) {\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\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {\n  asciiAlphanumeric,\n  asciiDigit,\n  asciiHexDigit\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  const self = this\n  let size = 0\n  /** @type {number} */\n\n  let max\n  /** @type {(code: Code) => code is number} */\n\n  let test\n  return start\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  /** @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\n    effects.enter('characterReferenceValue')\n    max = 31\n    test = asciiAlphanumeric\n    return value(code)\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\n    effects.enter('characterReferenceValue')\n    max = 7\n    test = asciiDigit\n    return value(code)\n  }\n  /** @type {State} */\n\n  function value(code) {\n    /** @type {Token} */\n    let token\n\n    if (code === 59 && size) {\n      token = effects.exit('characterReferenceValue')\n\n      if (\n        test === asciiAlphanumeric &&\n        !decodeNamedCharacterReference(self.sliceSerialize(token))\n      ) {\n        return nok(code)\n      }\n\n      effects.enter('characterReferenceMarker')\n      effects.consume(code)\n      effects.exit('characterReferenceMarker')\n      effects.exit('characterReference')\n      return ok\n    }\n\n    if (test(code) && size++ < max) {\n      effects.consume(code)\n      return value\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  const self = this\n  /** @type {Construct} */\n\n  const closingFenceConstruct = {\n    tokenize: tokenizeClosingFence,\n    partial: true\n  }\n  /** @type {Construct} */\n\n  const nonLazyLine = {\n    tokenize: tokenizeNonLazyLine,\n    partial: true\n  }\n  const tail = this.events[this.events.length - 1]\n  const initialPrefix =\n    tail && tail[1].type === 'linePrefix'\n      ? tail[2].sliceSerialize(tail[1], true).length\n      : 0\n  let sizeOpen = 0\n  /** @type {NonNullable<Code>} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('codeFenced')\n    effects.enter('codeFencedFence')\n    effects.enter('codeFencedFenceSequence')\n    marker = code\n    return sequenceOpen(code)\n  }\n  /** @type {State} */\n\n  function sequenceOpen(code) {\n    if (code === marker) {\n      effects.consume(code)\n      sizeOpen++\n      return sequenceOpen\n    }\n\n    effects.exit('codeFencedFenceSequence')\n    return sizeOpen < 3\n      ? nok(code)\n      : factorySpace(effects, infoOpen, 'whitespace')(code)\n  }\n  /** @type {State} */\n\n  function infoOpen(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code)\n    }\n\n    effects.enter('codeFencedFenceInfo')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return info(code)\n  }\n  /** @type {State} */\n\n  function info(code) {\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceInfo')\n      return factorySpace(effects, infoAfter, 'whitespace')(code)\n    }\n\n    if (code === 96 && code === marker) return nok(code)\n    effects.consume(code)\n    return info\n  }\n  /** @type {State} */\n\n  function infoAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code)\n    }\n\n    effects.enter('codeFencedFenceMeta')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return meta(code)\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 openAfter(code)\n    }\n\n    if (code === 96 && code === marker) return nok(code)\n    effects.consume(code)\n    return meta\n  }\n  /** @type {State} */\n\n  function openAfter(code) {\n    effects.exit('codeFencedFence')\n    return self.interrupt ? ok(code) : contentStart(code)\n  }\n  /** @type {State} */\n\n  function contentStart(code) {\n    if (code === null) {\n      return after(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(\n        nonLazyLine,\n        effects.attempt(\n          closingFenceConstruct,\n          after,\n          initialPrefix\n            ? factorySpace(\n                effects,\n                contentStart,\n                'linePrefix',\n                initialPrefix + 1\n              )\n            : contentStart\n        ),\n        after\n      )(code)\n    }\n\n    effects.enter('codeFlowValue')\n    return contentContinue(code)\n  }\n  /** @type {State} */\n\n  function contentContinue(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return contentStart(code)\n    }\n\n    effects.consume(code)\n    return contentContinue\n  }\n  /** @type {State} */\n\n  function after(code) {\n    effects.exit('codeFenced')\n    return ok(code)\n  }\n  /** @type {Tokenizer} */\n\n  function tokenizeNonLazyLine(effects, ok, nok) {\n    const self = this\n    return start\n    /** @type {State} */\n\n    function start(code) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return lineStart\n    }\n    /** @type {State} */\n\n    function lineStart(code) {\n      return self.parser.lazy[self.now().line] ? nok(code) : ok(code)\n    }\n  }\n  /** @type {Tokenizer} */\n\n  function tokenizeClosingFence(effects, ok, nok) {\n    let size = 0\n    return factorySpace(\n      effects,\n      closingSequenceStart,\n      'linePrefix',\n      this.parser.constructs.disable.null.includes('codeIndented')\n        ? undefined\n        : 4\n    )\n    /** @type {State} */\n\n    function closingSequenceStart(code) {\n      effects.enter('codeFencedFence')\n      effects.enter('codeFencedFenceSequence')\n      return closingSequence(code)\n    }\n    /** @type {State} */\n\n    function closingSequence(code) {\n      if (code === marker) {\n        effects.consume(code)\n        size++\n        return closingSequence\n      }\n\n      if (size < sizeOpen) return nok(code)\n      effects.exit('codeFencedFenceSequence')\n      return factorySpace(effects, closingSequenceEnd, 'whitespace')(code)\n    }\n    /** @type {State} */\n\n    function closingSequenceEnd(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit('codeFencedFence')\n        return ok(code)\n      }\n\n      return nok(code)\n    }\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented\n}\n/** @type {Construct} */\n\nconst indentedContent = {\n  tokenize: tokenizeIndentedContent,\n  partial: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('codeIndented')\n    return factorySpace(effects, afterStartPrefix, 'linePrefix', 4 + 1)(code)\n  }\n  /** @type {State} */\n\n  function afterStartPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n      ? afterPrefix(code)\n      : nok(code)\n  }\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    if (code === null) {\n      return after(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(indentedContent, afterPrefix, after)(code)\n    }\n\n    effects.enter('codeFlowValue')\n    return content(code)\n  }\n  /** @type {State} */\n\n  function content(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return afterPrefix(code)\n    }\n\n    effects.consume(code)\n    return content\n  }\n  /** @type {State} */\n\n  function after(code) {\n    effects.exit('codeIndented')\n    return ok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeIndentedContent(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\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\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return start\n    }\n\n    return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)(code)\n  }\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n      ? ok(code)\n      : markdownLineEnding(code)\n      ? start(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Previous} Previous\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous\n}\n/** @type {Resolver} */\n\nfunction resolveCodeText(events) {\n  let tailExitIndex = events.length - 4\n  let headEnterIndex = 3\n  /** @type {number} */\n\n  let index\n  /** @type {number|undefined} */\n\n  let enter // If we start and end with an EOL or a space.\n\n  if (\n    (events[headEnterIndex][1].type === 'lineEnding' ||\n      events[headEnterIndex][1].type === 'space') &&\n    (events[tailExitIndex][1].type === 'lineEnding' ||\n      events[tailExitIndex][1].type === 'space')\n  ) {\n    index = headEnterIndex // And we have data.\n\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  } // Merge adjacent spaces and data.\n\n  index = headEnterIndex - 1\n  tailExitIndex++\n\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== 'lineEnding') {\n        enter = index\n      }\n    } else if (\n      index === tailExitIndex ||\n      events[index][1].type === 'lineEnding'\n    ) {\n      events[enter][1].type = 'codeTextData'\n\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\n      enter = undefined\n    }\n  }\n\n  return events\n}\n/** @type {Previous} */\n\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return (\n    code !== 96 ||\n    this.events[this.events.length - 1][1].type === 'characterEscape'\n  )\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCodeText(effects, ok, nok) {\n  const self = this\n  let sizeOpen = 0\n  /** @type {number} */\n\n  let size\n  /** @type {Token} */\n\n  let token\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('codeText')\n    effects.enter('codeTextSequence')\n    return openingSequence(code)\n  }\n  /** @type {State} */\n\n  function openingSequence(code) {\n    if (code === 96) {\n      effects.consume(code)\n      sizeOpen++\n      return openingSequence\n    }\n\n    effects.exit('codeTextSequence')\n    return gap(code)\n  }\n  /** @type {State} */\n\n  function gap(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code)\n    } // Closing fence?\n    // Could also be data.\n\n    if (code === 96) {\n      token = effects.enter('codeTextSequence')\n      size = 0\n      return closingSequence(code)\n    } // Tabs don’t work, and virtual spaces don’t make sense.\n\n    if (code === 32) {\n      effects.enter('space')\n      effects.consume(code)\n      effects.exit('space')\n      return gap\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return gap\n    } // Data.\n\n    effects.enter('codeTextData')\n    return data(code)\n  } // In code.\n\n  /** @type {State} */\n\n  function data(code) {\n    if (\n      code === null ||\n      code === 32 ||\n      code === 96 ||\n      markdownLineEnding(code)\n    ) {\n      effects.exit('codeTextData')\n      return gap(code)\n    }\n\n    effects.consume(code)\n    return data\n  } // Closing fence.\n\n  /** @type {State} */\n\n  function closingSequence(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code)\n      size++\n      return closingSequence\n    } // Done!\n\n    if (size === sizeOpen) {\n      effects.exit('codeTextSequence')\n      effects.exit('codeText')\n      return ok(code)\n    } // More or less accents: mark as data.\n\n    token.type = 'codeTextData'\n    return data(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {subtokenize} from 'micromark-util-subtokenize'\n\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/** @type {Construct} */\n\nconst continuationConstruct = {\n  tokenize: tokenizeContinuation,\n  partial: true\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 */\n\nfunction resolveContent(events) {\n  subtokenize(events)\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeContent(effects, ok) {\n  /** @type {Token} */\n  let previous\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('content')\n    previous = effects.enter('chunkContent', {\n      contentType: 'content'\n    })\n    return data(code)\n  }\n  /** @type {State} */\n\n  function data(code) {\n    if (code === null) {\n      return contentEnd(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.check(\n        continuationConstruct,\n        contentContinue,\n        contentEnd\n      )(code)\n    } // Data.\n\n    effects.consume(code)\n    return data\n  }\n  /** @type {State} */\n\n  function contentEnd(code) {\n    effects.exit('chunkContent')\n    effects.exit('content')\n    return ok(code)\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 data\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeContinuation(effects, ok, nok) {\n  const self = this\n  return startLookahead\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  /** @type {State} */\n\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    const tail = self.events[self.events.length - 1]\n\n    if (\n      !self.parser.constructs.disable.null.includes('codeIndented') &&\n      tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n    ) {\n      return ok(code)\n    }\n\n    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\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 {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n}\n/** @type {Construct} */\n\nconst titleConstruct = {\n  tokenize: tokenizeTitle,\n  partial: true\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeDefinition(effects, ok, nok) {\n  const self = this\n  /** @type {string} */\n\n  let identifier\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('definition')\n    return factoryLabel.call(\n      self,\n      effects,\n      labelAfter,\n      nok,\n      'definitionLabel',\n      'definitionLabelMarker',\n      'definitionLabelString'\n    )(code)\n  }\n  /** @type {State} */\n\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(\n      self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n    )\n\n    if (code === 58) {\n      effects.enter('definitionMarker')\n      effects.consume(code)\n      effects.exit('definitionMarker') // Note: blank lines can’t exist in content.\n\n      return factoryWhitespace(\n        effects,\n        factoryDestination(\n          effects,\n          effects.attempt(\n            titleConstruct,\n            factorySpace(effects, after, 'whitespace'),\n            factorySpace(effects, after, 'whitespace')\n          ),\n          nok,\n          'definitionDestination',\n          'definitionDestinationLiteral',\n          'definitionDestinationLiteralMarker',\n          'definitionDestinationRaw',\n          'definitionDestinationString'\n        )\n      )\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('definition')\n\n      if (!self.parser.defined.includes(identifier)) {\n        self.parser.defined.push(identifier)\n      }\n\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeTitle(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, before)(code)\n      : nok(code)\n  }\n  /** @type {State} */\n\n  function before(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(\n        effects,\n        factorySpace(effects, after, 'whitespace'),\n        nok,\n        'definitionTitle',\n        'definitionTitleMarker',\n        'definitionTitleString'\n      )(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('hardBreakEscape')\n    effects.enter('escapeMarker')\n    effects.consume(code)\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit('escapeMarker')\n      effects.exit('hardBreakEscape')\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {splice} from 'micromark-util-chunked'\n\n/** @type {Construct} */\nexport const headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\n}\n/** @type {Resolver} */\n\nfunction resolveHeadingAtx(events, context) {\n  let contentEnd = events.length - 2\n  let contentStart = 3\n  /** @type {Token} */\n\n  let content\n  /** @type {Token} */\n\n  let text // Prefix whitespace, part of the opening.\n\n  if (events[contentStart][1].type === 'whitespace') {\n    contentStart += 2\n  } // Suffix whitespace, part of the closing.\n\n  if (\n    contentEnd - 2 > contentStart &&\n    events[contentEnd][1].type === 'whitespace'\n  ) {\n    contentEnd -= 2\n  }\n\n  if (\n    events[contentEnd][1].type === 'atxHeadingSequence' &&\n    (contentStart === contentEnd - 1 ||\n      (contentEnd - 4 > contentStart &&\n        events[contentEnd - 2][1].type === 'whitespace'))\n  ) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4\n  }\n\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      // @ts-expect-error Constants are fine to assign.\n      contentType: 'text'\n    }\n    splice(events, contentStart, contentEnd - contentStart + 1, [\n      ['enter', content, context],\n      ['enter', text, context],\n      ['exit', text, context],\n      ['exit', content, context]\n    ])\n  }\n\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  const self = this\n  let size = 0\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('atxHeading')\n    effects.enter('atxHeadingSequence')\n    return fenceOpenInside(code)\n  }\n  /** @type {State} */\n\n  function fenceOpenInside(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code)\n      return fenceOpenInside\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingSequence')\n      return self.interrupt ? ok(code) : headingBreak(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function headingBreak(code) {\n    if (code === 35) {\n      effects.enter('atxHeadingSequence')\n      return sequence(code)\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('atxHeading')\n      return ok(code)\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headingBreak, 'whitespace')(code)\n    }\n\n    effects.enter('atxHeadingText')\n    return data(code)\n  }\n  /** @type {State} */\n\n  function sequence(code) {\n    if (code === 35) {\n      effects.consume(code)\n      return sequence\n    }\n\n    effects.exit('atxHeadingSequence')\n    return headingBreak(code)\n  }\n  /** @type {State} */\n\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingText')\n      return headingBreak(code)\n    }\n\n    effects.consume(code)\n    return data\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {htmlBlockNames, htmlRawNames} from 'micromark-util-html-tag-name'\nimport {blankLine} from './blank-line.js'\n/** @type {Construct} */\n\nexport const htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n}\n/** @type {Construct} */\n\nconst nextBlankConstruct = {\n  tokenize: tokenizeNextBlank,\n  partial: true\n}\n/** @type {Resolver} */\n\nfunction resolveToHtmlFlow(events) {\n  let index = events.length\n\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {\n      break\n    }\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 // Add the prefix start to the HTML line token.\n\n    events[index + 1][1].start = events[index - 2][1].start // Remove the line prefix.\n\n    events.splice(index - 2, 2)\n  }\n\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  const self = this\n  /** @type {number} */\n\n  let kind\n  /** @type {boolean} */\n\n  let startTag\n  /** @type {string} */\n\n  let buffer\n  /** @type {number} */\n\n  let index\n  /** @type {Code} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('htmlFlow')\n    effects.enter('htmlFlowData')\n    effects.consume(code)\n    return open\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationStart\n    }\n\n    if (code === 47) {\n      effects.consume(code)\n      return tagCloseStart\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      kind = 3 // 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\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      buffer = String.fromCharCode(code)\n      startTag = true\n      return tagName\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function declarationStart(code) {\n    if (code === 45) {\n      effects.consume(code)\n      kind = 2\n      return commentOpenInside\n    }\n\n    if (code === 91) {\n      effects.consume(code)\n      kind = 5\n      buffer = 'CDATA['\n      index = 0\n      return cdataOpenInside\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      kind = 4\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function cdataOpenInside(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code)\n      return index === buffer.length\n        ? self.interrupt\n          ? ok\n          : continuation\n        : cdataOpenInside\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      buffer = String.fromCharCode(code)\n      return tagName\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagName(code) {\n    if (\n      code === null ||\n      code === 47 ||\n      code === 62 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      if (\n        code !== 47 &&\n        startTag &&\n        htmlRawNames.includes(buffer.toLowerCase())\n      ) {\n        kind = 1\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n\n      if (htmlBlockNames.includes(buffer.toLowerCase())) {\n        kind = 6\n\n        if (code === 47) {\n          effects.consume(code)\n          return basicSelfClosing\n        }\n\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n\n      kind = 7 // Do not support complete HTML when interrupting\n\n      return self.interrupt && !self.parser.lazy[self.now().line]\n        ? nok(code)\n        : startTag\n        ? completeAttributeNameBefore(code)\n        : completeClosingTagAfter(code)\n    }\n\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      buffer += String.fromCharCode(code)\n      return tagName\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return self.interrupt ? ok : continuation\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeClosingTagAfter\n    }\n\n    return completeEnd(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return completeEnd\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameBefore\n    }\n\n    return completeEnd(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeName(code) {\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n\n    return completeAttributeNameAfter(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameAfter\n    }\n\n    return completeAttributeNameBefore(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      marker = code\n      return completeAttributeValueQuoted\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n\n    marker = null\n    return completeAttributeValueUnquoted(code)\n  }\n  /** @type {State} */\n\n  function completeAttributeValueQuoted(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    if (code === marker) {\n      effects.consume(code)\n      return completeAttributeValueQuotedAfter\n    }\n\n    effects.consume(code)\n    return completeAttributeValueQuoted\n  }\n  /** @type {State} */\n\n  function completeAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      return completeAttributeNameAfter(code)\n    }\n\n    effects.consume(code)\n    return completeAttributeValueUnquoted\n  }\n  /** @type {State} */\n\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return completeAfter\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function completeAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAfter\n    }\n\n    return code === null || markdownLineEnding(code)\n      ? continuation(code)\n      : nok(code)\n  }\n  /** @type {State} */\n\n  function continuation(code) {\n    if (code === 45 && kind === 2) {\n      effects.consume(code)\n      return continuationCommentInside\n    }\n\n    if (code === 60 && kind === 1) {\n      effects.consume(code)\n      return continuationRawTagOpen\n    }\n\n    if (code === 62 && kind === 4) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    if (code === 63 && kind === 3) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    if (code === 93 && kind === 5) {\n      effects.consume(code)\n      return continuationCharacterDataInside\n    }\n\n    if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {\n      return effects.check(\n        nextBlankConstruct,\n        continuationClose,\n        continuationAtLineEnding\n      )(code)\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return continuationAtLineEnding(code)\n    }\n\n    effects.consume(code)\n    return continuation\n  }\n  /** @type {State} */\n\n  function continuationAtLineEnding(code) {\n    effects.exit('htmlFlowData')\n    return htmlContinueStart(code)\n  }\n  /** @type {State} */\n\n  function htmlContinueStart(code) {\n    if (code === null) {\n      return done(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(\n        {\n          tokenize: htmlLineEnd,\n          partial: true\n        },\n        htmlContinueStart,\n        done\n      )(code)\n    }\n\n    effects.enter('htmlFlowData')\n    return continuation(code)\n  }\n  /** @type {Tokenizer} */\n\n  function htmlLineEnd(effects, ok, nok) {\n    return start\n    /** @type {State} */\n\n    function start(code) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return lineStart\n    }\n    /** @type {State} */\n\n    function lineStart(code) {\n      return self.parser.lazy[self.now().line] ? nok(code) : ok(code)\n    }\n  }\n  /** @type {State} */\n\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code)\n      buffer = ''\n      return continuationRawEndTag\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationRawEndTag(code) {\n    if (code === 62 && htmlRawNames.includes(buffer.toLowerCase())) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code)\n      buffer += String.fromCharCode(code)\n      return continuationRawEndTag\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationCharacterDataInside(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return continuationClose\n    } // More dashes.\n\n    if (code === 45 && kind === 2) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n\n    return continuation(code)\n  }\n  /** @type {State} */\n\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData')\n      return done(code)\n    }\n\n    effects.consume(code)\n    return continuationClose\n  }\n  /** @type {State} */\n\n  function done(code) {\n    effects.exit('htmlFlow')\n    return ok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeNextBlank(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.exit('htmlFlowData')\n    effects.enter('lineEndingBlank')\n    effects.consume(code)\n    effects.exit('lineEndingBlank')\n    return effects.attempt(blankLine, ok, nok)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeHtmlText(effects, ok, nok) {\n  const self = this\n  /** @type {NonNullable<Code>|undefined} */\n\n  let marker\n  /** @type {string} */\n\n  let buffer\n  /** @type {number} */\n\n  let index\n  /** @type {State} */\n\n  let returnState\n  return start\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  /** @type {State} */\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationOpen\n    }\n\n    if (code === 47) {\n      effects.consume(code)\n      return tagCloseStart\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      return instruction\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentOpen\n    }\n\n    if (code === 91) {\n      effects.consume(code)\n      buffer = 'CDATA['\n      index = 0\n      return cdataOpen\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return declaration\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function commentOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentStart\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function commentStart(code) {\n    if (code === null || code === 62) {\n      return nok(code)\n    }\n\n    if (code === 45) {\n      effects.consume(code)\n      return commentStartDash\n    }\n\n    return comment(code)\n  }\n  /** @type {State} */\n\n  function commentStartDash(code) {\n    if (code === null || code === 62) {\n      return nok(code)\n    }\n\n    return comment(code)\n  }\n  /** @type {State} */\n\n  function comment(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 45) {\n      effects.consume(code)\n      return commentClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = comment\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return comment\n  }\n  /** @type {State} */\n\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return end\n    }\n\n    return comment(code)\n  }\n  /** @type {State} */\n\n  function cdataOpen(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code)\n      return index === buffer.length ? cdata : cdataOpen\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function cdata(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 93) {\n      effects.consume(code)\n      return cdataClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = cdata\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return cdata\n  }\n  /** @type {State} */\n\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n\n    return cdata(code)\n  }\n  /** @type {State} */\n\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code)\n    }\n\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n\n    return cdata(code)\n  }\n  /** @type {State} */\n\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = declaration\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return declaration\n  }\n  /** @type {State} */\n\n  function instruction(code) {\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (code === 63) {\n      effects.consume(code)\n      return instructionClose\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = instruction\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return instruction\n  }\n  /** @type {State} */\n\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code)\n  }\n  /** @type {State} */\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagClose(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n\n    return tagCloseBetween(code)\n  }\n  /** @type {State} */\n\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagCloseBetween\n    }\n\n    return end(code)\n  }\n  /** @type {State} */\n\n  function tagOpen(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return end\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenBetween\n    }\n\n    return end(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeName(code) {\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n\n    return tagOpenAttributeNameAfter(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeNameAfter\n    }\n\n    return tagOpenBetween(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      marker = code\n      return tagOpenAttributeValueQuoted\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore\n      return atLineEnding(code)\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n\n    effects.consume(code)\n    marker = undefined\n    return tagOpenAttributeValueUnquoted\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return tagOpenAttributeValueQuotedAfter\n    }\n\n    if (code === null) {\n      return nok(code)\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted\n      return atLineEnding(code)\n    }\n\n    effects.consume(code)\n    return tagOpenAttributeValueQuoted\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function tagOpenAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 60 ||\n      code === 61 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n\n    if (code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n\n    effects.consume(code)\n    return tagOpenAttributeValueUnquoted\n  } // We can’t have blank lines in content, so no need to worry about empty\n  // tokens.\n\n  /** @type {State} */\n\n  function atLineEnding(code) {\n    effects.exit('htmlTextData')\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(\n      effects,\n      afterPrefix,\n      'linePrefix',\n      self.parser.constructs.disable.null.includes('codeIndented')\n        ? undefined\n        : 4\n    )\n  }\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    effects.enter('htmlTextData')\n    return returnState(code)\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\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\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\n/** @type {Construct} */\nexport const labelEnd = {\n  name: 'labelEnd',\n  tokenize: tokenizeLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  resolveAll: resolveAllLabelEnd\n}\n/** @type {Construct} */\n\nconst resourceConstruct = {\n  tokenize: tokenizeResource\n}\n/** @type {Construct} */\n\nconst fullReferenceConstruct = {\n  tokenize: tokenizeFullReference\n}\n/** @type {Construct} */\n\nconst collapsedReferenceConstruct = {\n  tokenize: tokenizeCollapsedReference\n}\n/** @type {Resolver} */\n\nfunction resolveAllLabelEnd(events) {\n  let index = -1\n  /** @type {Token} */\n\n  let token\n\n  while (++index < events.length) {\n    token = events[index][1]\n\n    if (\n      token.type === 'labelImage' ||\n      token.type === 'labelLink' ||\n      token.type === 'labelEnd'\n    ) {\n      // Remove the marker.\n      events.splice(index + 1, token.type === 'labelImage' ? 4 : 2)\n      token.type = 'data'\n      index++\n    }\n  }\n\n  return events\n}\n/** @type {Resolver} */\n\nfunction resolveToLabelEnd(events, context) {\n  let index = events.length\n  let offset = 0\n  /** @type {Token} */\n\n  let token\n  /** @type {number|undefined} */\n\n  let open\n  /** @type {number|undefined} */\n\n  let close\n  /** @type {Event[]} */\n\n  let media // Find an opening.\n\n  while (index--) {\n    token = events[index][1]\n\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (\n        token.type === 'link' ||\n        (token.type === 'labelLink' && token._inactive)\n      ) {\n        break\n      } // Mark other link openings as inactive, as we can’t have links in\n      // links.\n\n      if (events[index][0] === 'enter' && token.type === 'labelLink') {\n        token._inactive = true\n      }\n    } else if (close) {\n      if (\n        events[index][0] === 'enter' &&\n        (token.type === 'labelImage' || token.type === 'labelLink') &&\n        !token._balanced\n      ) {\n        open = index\n\n        if (token.type !== 'labelLink') {\n          offset = 2\n          break\n        }\n      }\n    } else if (token.type === 'labelEnd') {\n      close = index\n    }\n  }\n\n  const group = {\n    type: events[open][1].type === 'labelLink' ? 'link' : 'image',\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  }\n  const label = {\n    type: 'label',\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[close][1].end)\n  }\n  const text = {\n    type: 'labelText',\n    start: Object.assign({}, events[open + offset + 2][1].end),\n    end: Object.assign({}, events[close - 2][1].start)\n  }\n  media = [\n    ['enter', group, context],\n    ['enter', label, context]\n  ] // Opening marker.\n\n  media = push(media, events.slice(open + 1, open + offset + 3)) // Text open.\n\n  media = push(media, [['enter', text, context]]) // Between.\n\n  media = push(\n    media,\n    resolveAll(\n      context.parser.constructs.insideSpan.null,\n      events.slice(open + offset + 4, close - 3),\n      context\n    )\n  ) // Text close, marker close, label close.\n\n  media = push(media, [\n    ['exit', text, context],\n    events[close - 2],\n    events[close - 1],\n    ['exit', label, context]\n  ]) // Reference, resource, or so.\n\n  media = push(media, events.slice(close + 1)) // Media close.\n\n  media = push(media, [['exit', group, context]])\n  splice(events, open, events.length, media)\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  const self = this\n  let index = self.events.length\n  /** @type {Token} */\n\n  let labelStart\n  /** @type {boolean} */\n\n  let defined // Find an opening.\n\n  while (index--) {\n    if (\n      (self.events[index][1].type === 'labelImage' ||\n        self.events[index][1].type === 'labelLink') &&\n      !self.events[index][1]._balanced\n    ) {\n      labelStart = self.events[index][1]\n      break\n    }\n  }\n\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (!labelStart) {\n      return nok(code)\n    } // It’s a balanced bracket, but contains a link.\n\n    if (labelStart._inactive) return balanced(code)\n    defined = self.parser.defined.includes(\n      normalizeIdentifier(\n        self.sliceSerialize({\n          start: labelStart.end,\n          end: self.now()\n        })\n      )\n    )\n    effects.enter('labelEnd')\n    effects.enter('labelMarker')\n    effects.consume(code)\n    effects.exit('labelMarker')\n    effects.exit('labelEnd')\n    return afterLabelEnd\n  }\n  /** @type {State} */\n\n  function afterLabelEnd(code) {\n    // Resource: `[asd](fgh)`.\n    if (code === 40) {\n      return effects.attempt(\n        resourceConstruct,\n        ok,\n        defined ? ok : balanced\n      )(code)\n    } // Collapsed (`[asd][]`) or full (`[asd][fgh]`) reference?\n\n    if (code === 91) {\n      return effects.attempt(\n        fullReferenceConstruct,\n        ok,\n        defined\n          ? effects.attempt(collapsedReferenceConstruct, ok, balanced)\n          : balanced\n      )(code)\n    } // Shortcut reference: `[asd]`?\n\n    return defined ? ok(code) : balanced(code)\n  }\n  /** @type {State} */\n\n  function balanced(code) {\n    labelStart._balanced = true\n    return nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeResource(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('resource')\n    effects.enter('resourceMarker')\n    effects.consume(code)\n    effects.exit('resourceMarker')\n    return factoryWhitespace(effects, open)\n  }\n  /** @type {State} */\n\n  function open(code) {\n    if (code === 41) {\n      return end(code)\n    }\n\n    return factoryDestination(\n      effects,\n      destinationAfter,\n      nok,\n      'resourceDestination',\n      'resourceDestinationLiteral',\n      'resourceDestinationLiteralMarker',\n      'resourceDestinationRaw',\n      'resourceDestinationString',\n      32\n    )(code)\n  }\n  /** @type {State} */\n\n  function destinationAfter(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, between)(code)\n      : end(code)\n  }\n  /** @type {State} */\n\n  function between(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(\n        effects,\n        factoryWhitespace(effects, end),\n        nok,\n        'resourceTitle',\n        'resourceTitleMarker',\n        'resourceTitleString'\n      )(code)\n    }\n\n    return end(code)\n  }\n  /** @type {State} */\n\n  function end(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\n    return nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeFullReference(effects, ok, nok) {\n  const self = this\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    return factoryLabel.call(\n      self,\n      effects,\n      afterLabel,\n      nok,\n      'reference',\n      'referenceMarker',\n      'referenceString'\n    )(code)\n  }\n  /** @type {State} */\n\n  function afterLabel(code) {\n    return self.parser.defined.includes(\n      normalizeIdentifier(\n        self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n      )\n    )\n      ? ok(code)\n      : nok(code)\n  }\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeCollapsedReference(effects, ok, nok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('reference')\n    effects.enter('referenceMarker')\n    effects.consume(code)\n    effects.exit('referenceMarker')\n    return open\n  }\n  /** @type {State} */\n\n  function open(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\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {labelEnd} from './label-end.js'\n/** @type {Construct} */\n\nexport const labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  const self = this\n  return start\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  /** @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\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function after(code) {\n    /* To do: remove in the future once we’ve switched from\n     * `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n     * which doesn’t need this */\n\n    /* Hidden footnotes hook */\n\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs\n      ? nok(code)\n      : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {labelEnd} from './label-end.js'\n/** @type {Construct} */\n\nexport const labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  const self = this\n  return start\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  /** @type {State} */\n\n  function after(code) {\n    /* To do: remove in the future once we’ve switched from\n     * `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n     * which doesn’t need this */\n\n    /* Hidden footnotes hook. */\n\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs\n      ? nok(code)\n      : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeLineEnding(effects, ok) {\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, ok, 'linePrefix')\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\n\n/**\n * @typedef {Record<string, unknown> & {marker: Code, type: string, size: number}} ListContainerState\n * @typedef {TokenizeContext & {containerState: ListContainerState}} TokenizeContextWithState\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/** @type {Construct} */\n\nexport const list = {\n  name: 'list',\n  tokenize: tokenizeListStart,\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd\n}\n/** @type {Construct} */\n\nconst listItemPrefixWhitespaceConstruct = {\n  tokenize: tokenizeListItemPrefixWhitespace,\n  partial: true\n}\n/** @type {Construct} */\n\nconst indentConstruct = {\n  tokenize: tokenizeIndent,\n  partial: true\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListStart(effects, ok, nok) {\n  const self = this\n  const tail = self.events[self.events.length - 1]\n  let initialSize =\n    tail && tail[1].type === 'linePrefix'\n      ? tail[2].sliceSerialize(tail[1], true).length\n      : 0\n  let size = 0\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    const kind =\n      self.containerState.type ||\n      (code === 42 || code === 43 || code === 45\n        ? 'listUnordered'\n        : 'listOrdered')\n\n    if (\n      kind === 'listUnordered'\n        ? !self.containerState.marker || code === self.containerState.marker\n        : asciiDigit(code)\n    ) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind\n        effects.enter(kind, {\n          _container: true\n        })\n      }\n\n      if (kind === 'listUnordered') {\n        effects.enter('listItemPrefix')\n        return code === 42 || code === 45\n          ? effects.check(thematicBreak, nok, atMarker)(code)\n          : atMarker(code)\n      }\n\n      if (!self.interrupt || code === 49) {\n        effects.enter('listItemPrefix')\n        effects.enter('listItemValue')\n        return inside(code)\n      }\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code)\n      return inside\n    }\n\n    if (\n      (!self.interrupt || size < 2) &&\n      (self.containerState.marker\n        ? code === self.containerState.marker\n        : code === 41 || code === 46)\n    ) {\n      effects.exit('listItemValue')\n      return atMarker(code)\n    }\n\n    return nok(code)\n  }\n  /**\n   * @type {State}\n   **/\n\n  function atMarker(code) {\n    effects.enter('listItemMarker')\n    effects.consume(code)\n    effects.exit('listItemMarker')\n    self.containerState.marker = self.containerState.marker || code\n    return effects.check(\n      blankLine, // Can’t be empty when interrupting.\n      self.interrupt ? nok : onBlank,\n      effects.attempt(\n        listItemPrefixWhitespaceConstruct,\n        endOfPrefix,\n        otherPrefix\n      )\n    )\n  }\n  /** @type {State} */\n\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true\n    initialSize++\n    return endOfPrefix(code)\n  }\n  /** @type {State} */\n\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\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function endOfPrefix(code) {\n    self.containerState.size =\n      initialSize +\n      self.sliceSerialize(effects.exit('listItemPrefix'), true).length\n    return ok(code)\n  }\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListContinuation(effects, ok, nok) {\n  const self = this\n  self.containerState._closeFlow = undefined\n  return effects.check(blankLine, onBlank, notBlank)\n  /** @type {State} */\n\n  function onBlank(code) {\n    self.containerState.furtherBlankLines =\n      self.containerState.furtherBlankLines ||\n      self.containerState.initialBlankLine // We have a blank line.\n    // Still, try to consume at most the items size.\n\n    return factorySpace(\n      effects,\n      ok,\n      'listItemIndent',\n      self.containerState.size + 1\n    )(code)\n  }\n  /** @type {State} */\n\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\n    self.containerState.furtherBlankLines = undefined\n    self.containerState.initialBlankLine = undefined\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code)\n  }\n  /** @type {State} */\n\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true // As we’re closing flow, we’re no longer interrupting.\n\n    self.interrupt = undefined\n    return factorySpace(\n      effects,\n      effects.attempt(list, ok, nok),\n      'linePrefix',\n      self.parser.constructs.disable.null.includes('codeIndented')\n        ? undefined\n        : 4\n    )(code)\n  }\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemIndent',\n    self.containerState.size + 1\n  )\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'listItemIndent' &&\n      tail[2].sliceSerialize(tail[1], true).length === self.containerState.size\n      ? ok(code)\n      : nok(code)\n  }\n}\n/**\n * @type {Exiter}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type)\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  const self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemPrefixWhitespace',\n    self.parser.constructs.disable.null.includes('codeIndented')\n      ? undefined\n      : 4 + 1\n  )\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return !markdownSpace(code) &&\n      tail &&\n      tail[1].type === 'listItemPrefixWhitespace'\n      ? ok(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\n}\n/** @type {Resolver} */\n\nfunction resolveToSetextUnderline(events, context) {\n  let index = events.length\n  /** @type {number|undefined} */\n\n  let content\n  /** @type {number|undefined} */\n\n  let text\n  /** @type {number|undefined} */\n\n  let definition // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === 'content') {\n        content = index\n        break\n      }\n\n      if (events[index][1].type === 'paragraph') {\n        text = index\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\n      if (!definition && events[index][1].type === 'definition') {\n        definition = index\n      }\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  } // Change the paragraph to setext heading text.\n\n  events[text][1].type = 'setextHeadingText' // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n\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  } // Add the heading exit at the end.\n\n  events.push(['exit', heading, context])\n  return events\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  const self = this\n  let index = self.events.length\n  /** @type {NonNullable<Code>} */\n\n  let marker\n  /** @type {boolean} */\n\n  let paragraph // Find an opening.\n\n  while (index--) {\n    // Skip enter/exit of line ending, line prefix, and content.\n    // We can now either have a definition or a paragraph.\n    if (\n      self.events[index][1].type !== 'lineEnding' &&\n      self.events[index][1].type !== 'linePrefix' &&\n      self.events[index][1].type !== 'content'\n    ) {\n      paragraph = self.events[index][1].type === 'paragraph'\n      break\n    }\n  }\n\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {\n      effects.enter('setextHeadingLine')\n      effects.enter('setextHeadingLineSequence')\n      marker = code\n      return closingSequence(code)\n    }\n\n    return nok(code)\n  }\n  /** @type {State} */\n\n  function closingSequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return closingSequence\n    }\n\n    effects.exit('setextHeadingLineSequence')\n    return factorySpace(effects, closingSequenceEnd, 'lineSuffix')(code)\n  }\n  /** @type {State} */\n\n  function closingSequenceEnd(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('setextHeadingLine')\n      return ok(code)\n    }\n\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n\n/** @type {Construct} */\nexport const thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n}\n/** @type {Tokenizer} */\n\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  let size = 0\n  /** @type {NonNullable<Code>} */\n\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('thematicBreak')\n    marker = code\n    return atBreak(code)\n  }\n  /** @type {State} */\n\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter('thematicBreakSequence')\n      return sequence(code)\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, 'whitespace')(code)\n    }\n\n    if (size < 3 || (code !== null && !markdownLineEnding(code))) {\n      return nok(code)\n    }\n\n    effects.exit('thematicBreak')\n    return ok(code)\n  }\n  /** @type {State} */\n\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      size++\n      return sequence\n    }\n\n    effects.exit('thematicBreakSequence')\n    return atBreak(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension\n * @typedef {import('micromark-extension-gfm-strikethrough').Options} Options\n * @typedef {import('micromark-extension-gfm-footnote').HtmlOptions} HtmlOptions\n */\n\nimport {\n  combineExtensions,\n  combineHtmlExtensions\n} from 'micromark-util-combine-extensions'\nimport {\n  gfmAutolinkLiteral,\n  gfmAutolinkLiteralHtml\n} from 'micromark-extension-gfm-autolink-literal'\nimport {gfmFootnote, gfmFootnoteHtml} from 'micromark-extension-gfm-footnote'\nimport {\n  gfmStrikethrough,\n  gfmStrikethroughHtml\n} from 'micromark-extension-gfm-strikethrough'\nimport {gfmTable, gfmTableHtml} from 'micromark-extension-gfm-table'\nimport {gfmTagfilterHtml} from 'micromark-extension-gfm-tagfilter'\nimport {\n  gfmTaskListItem,\n  gfmTaskListItemHtml\n} from 'micromark-extension-gfm-task-list-item'\n\n/**\n * Support GFM or markdown on github.com.\n *\n * @param {Options} [options]\n * @returns {Extension}\n */\nexport function gfm(options) {\n  return combineExtensions([\n    gfmAutolinkLiteral,\n    gfmFootnote(),\n    gfmStrikethrough(options),\n    gfmTable,\n    gfmTaskListItem\n  ])\n}\n\n/**\n * Support to compile GFM to HTML.\n *\n * @param {HtmlOptions} [options]\n * @returns {HtmlExtension}\n */\nexport function gfmHtml(options) {\n  return combineHtmlExtensions([\n    gfmAutolinkLiteralHtml,\n    gfmFootnoteHtml(options),\n    gfmStrikethroughHtml,\n    gfmTableHtml,\n    gfmTagfilterHtml,\n    gfmTaskListItemHtml\n  ])\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\nimport {\n  asciiControl,\n  markdownLineEndingOrSpace,\n  markdownLineEnding\n} from 'micromark-util-character'\n\n/**\n * @param {Effects} effects\n * @param {State} ok\n * @param {State} nok\n * @param {string} type\n * @param {string} literalType\n * @param {string} literalMarkerType\n * @param {string} rawType\n * @param {string} stringType\n * @param {number} [max=Infinity]\n * @returns {State}\n */\n// eslint-disable-next-line max-params\nexport function factoryDestination(\n  effects,\n  ok,\n  nok,\n  type,\n  literalType,\n  literalMarkerType,\n  rawType,\n  stringType,\n  max\n) {\n  const limit = max || Number.POSITIVE_INFINITY\n  let balance = 0\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type)\n      effects.enter(literalType)\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      return destinationEnclosedBefore\n    }\n\n    if (code === null || code === 41 || asciiControl(code)) {\n      return nok(code)\n    }\n\n    effects.enter(type)\n    effects.enter(rawType)\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return destinationRaw(code)\n  }\n  /** @type {State} */\n\n  function destinationEnclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      effects.exit(literalType)\n      effects.exit(type)\n      return ok\n    }\n\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return destinationEnclosed(code)\n  }\n  /** @type {State} */\n\n  function destinationEnclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      return destinationEnclosedBefore(code)\n    }\n\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    effects.consume(code)\n    return code === 92 ? destinationEnclosedEscape : destinationEnclosed\n  }\n  /** @type {State} */\n\n  function destinationEnclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code)\n      return destinationEnclosed\n    }\n\n    return destinationEnclosed(code)\n  }\n  /** @type {State} */\n\n  function destinationRaw(code) {\n    if (code === 40) {\n      if (++balance > limit) return nok(code)\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    if (code === 41) {\n      if (!balance--) {\n        effects.exit('chunkString')\n        effects.exit(stringType)\n        effects.exit(rawType)\n        effects.exit(type)\n        return ok(code)\n      }\n\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      if (balance) return nok(code)\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      effects.exit(rawType)\n      effects.exit(type)\n      return ok(code)\n    }\n\n    if (asciiControl(code)) return nok(code)\n    effects.consume(code)\n    return code === 92 ? destinationRawEscape : destinationRaw\n  }\n  /** @type {State} */\n\n  function destinationRawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code)\n      return destinationRaw\n    }\n\n    return destinationRaw(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n\n/**\n * @this {TokenizeContext}\n * @param {Effects} effects\n * @param {State} ok\n * @param {State} nok\n * @param {string} type\n * @param {string} markerType\n * @param {string} stringType\n * @returns {State}\n */\n// eslint-disable-next-line max-params\nexport function factoryLabel(effects, ok, nok, type, markerType, stringType) {\n  const self = this\n  let size = 0\n  /** @type {boolean} */\n\n  let data\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter(type)\n    effects.enter(markerType)\n    effects.consume(code)\n    effects.exit(markerType)\n    effects.enter(stringType)\n    return atBreak\n  }\n  /** @type {State} */\n\n  function atBreak(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      (code === 93 && !data) ||\n      /* To do: remove in the future once we’ve switched from\n       * `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n       * which doesn’t need this */\n\n      /* Hidden footnotes hook */\n\n      /* c8 ignore next 3 */\n      (code === 94 &&\n        !size &&\n        '_hiddenFootnoteSupport' in self.parser.constructs) ||\n      size > 999\n    ) {\n      return nok(code)\n    }\n\n    if (code === 93) {\n      effects.exit(stringType)\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return atBreak\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return label(code)\n  }\n  /** @type {State} */\n\n  function label(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      code === 93 ||\n      markdownLineEnding(code) ||\n      size++ > 999\n    ) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n\n    effects.consume(code)\n    data = data || !markdownSpace(code)\n    return code === 92 ? labelEscape : label\n  }\n  /** @type {State} */\n\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code)\n      size++\n      return label\n    }\n\n    return label(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\nimport {markdownSpace} from 'micromark-util-character'\n/**\n * @param {Effects} effects\n * @param {State} ok\n * @param {string} type\n * @param {number} [max=Infinity]\n * @returns {State}\n */\n\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Number.POSITIVE_INFINITY\n  let size = 0\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type)\n      return prefix(code)\n    }\n\n    return ok(code)\n  }\n  /** @type {State} */\n\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code)\n      return prefix\n    }\n\n    effects.exit(type)\n    return ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n\n/**\n * @param {Effects} effects\n * @param {State} ok\n * @param {State} nok\n * @param {string} type\n * @param {string} markerType\n * @param {string} stringType\n * @returns {State}\n */\n// eslint-disable-next-line max-params\nexport function factoryTitle(effects, ok, nok, type, markerType, stringType) {\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter(type)\n    effects.enter(markerType)\n    effects.consume(code)\n    effects.exit(markerType)\n    marker = code === 40 ? 41 : code\n    return atFirstTitleBreak\n  }\n  /** @type {State} */\n\n  function atFirstTitleBreak(code) {\n    if (code === marker) {\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n\n    effects.enter(stringType)\n    return atTitleBreak(code)\n  }\n  /** @type {State} */\n\n  function atTitleBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType)\n      return atFirstTitleBreak(marker)\n    }\n\n    if (code === null) {\n      return nok(code)\n    } // Note: blank lines can’t exist in content.\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return factorySpace(effects, atTitleBreak, 'linePrefix')\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return title(code)\n  }\n  /** @type {State} */\n\n  function title(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      return atTitleBreak(code)\n    }\n\n    effects.consume(code)\n    return code === 92 ? titleEscape : title\n  }\n  /** @type {State} */\n\n  function titleEscape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code)\n      return title\n    }\n\n    return title(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n\n/**\n * @param {Effects} effects\n * @param {State} ok\n */\nexport function factoryWhitespace(effects, ok) {\n  /** @type {boolean} */\n  let seen\n  return start\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      seen = true\n      return start\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(\n        effects,\n        start,\n        seen ? 'linePrefix' : 'lineSuffix'\n      )(code)\n    }\n\n    return ok(code)\n  }\n}\n","// This module is generated by `script/`.\n//\n// CommonMark handles attention (emphasis, strong) markers based on what comes\n// before or after them.\n// One such difference is if those characters are Unicode punctuation.\n// This script is generated from the Unicode data.\nexport const unicodePunctuationRegex =\n  /[!-/:-@[-`{-~\\u00A1\\u00A7\\u00AB\\u00B6\\u00B7\\u00BB\\u00BF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061E\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport {unicodePunctuationRegex} from './lib/unicode-punctuation-regex.js'\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n */\n\nexport const asciiAlpha = regexCheck(/[A-Za-z]/)\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n */\n\nexport const asciiDigit = regexCheck(/\\d/)\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n */\n\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/)\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n */\n\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/)\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n */\n\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/)\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n */\n\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/)\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  )\n}\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32)\n}\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2\n}\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32\n}\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n */\n\nexport const unicodeWhitespace = regexCheck(/\\s/)\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n */\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n\nexport const unicodePunctuation = regexCheck(unicodePunctuationRegex)\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n * @returns {(code: Code) => code is number}\n */\n\nfunction regexCheck(regex) {\n  return check\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code Character code\n   * @returns {code is number} Whether the character code matches the bound regex\n   */\n\n  function check(code) {\n    return code !== null && regex.test(String.fromCharCode(code))\n  }\n}\n","/**\n * Like `Array#splice`, but smarter for giant arrays.\n *\n * `Array#splice` takes all items to be inserted as individual argument which\n * causes a stack overflow in V8 when trying to insert 100k items for instance.\n *\n * Otherwise, this does not return the removed items, and takes `items` as an\n * array instead of rest parameters.\n *\n * @template {unknown} T\n * @param {T[]} list\n * @param {number} start\n * @param {number} remove\n * @param {T[]} items\n * @returns {void}\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length\n  let chunkStart = 0\n  /** @type {unknown[]} */\n\n  let parameters // Make start between zero and `end` (included).\n\n  if (start < 0) {\n    start = -start > end ? 0 : end + start\n  } else {\n    start = start > end ? end : start\n  }\n\n  remove = remove > 0 ? remove : 0 // No need to chunk the items if there’s only a couple (10k) items.\n\n  if (items.length < 10000) {\n    parameters = Array.from(items)\n    parameters.unshift(start, remove) // @ts-expect-error Hush, it’s fine.\n    ;[].splice.apply(list, parameters)\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) [].splice.apply(list, [start, remove]) // Insert the items in chunks to not cause stack overflows.\n\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000)\n      parameters.unshift(start, 0) // @ts-expect-error Hush, it’s fine.\n      ;[].splice.apply(list, parameters)\n      chunkStart += 10000\n      start += 10000\n    }\n  }\n}\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n * @param {T[]} list\n * @param {T[]} items\n * @returns {T[]}\n */\n\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items)\n    return list\n  }\n\n  return items\n}\n","const characterReferences = {'\"': 'quot', '&': 'amp', '<': 'lt', '>': 'gt'}\n\n/**\n * Encode only the dangerous HTML characters.\n *\n * This ensures that certain characters which have special meaning in HTML are\n * dealt with.\n * Technically, we can skip `>` and `\"` in many cases, but CM includes them.\n *\n * @param {string} value\n * @returns {string}\n */\nexport function encode(value) {\n  return value.replace(/[\"&<>]/g, replace)\n\n  /**\n   * @param {string} value\n   * @returns {string}\n   */\n  function replace(value) {\n    // @ts-expect-error Hush, it’s fine.\n    return '&' + characterReferences[value] + ';'\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Event} Event\n */\nimport {splice} from 'micromark-util-chunked'\n\n/**\n * Tokenize subcontent.\n *\n * @param {Event[]} events\n * @returns {boolean}\n */\nexport function subtokenize(events) {\n  /** @type {Record<string, number>} */\n  const jumps = {}\n  let index = -1\n  /** @type {Event} */\n\n  let event\n  /** @type {number|undefined} */\n\n  let lineIndex\n  /** @type {number} */\n\n  let otherIndex\n  /** @type {Event} */\n\n  let otherEvent\n  /** @type {Event[]} */\n\n  let parameters\n  /** @type {Event[]} */\n\n  let subevents\n  /** @type {boolean|undefined} */\n\n  let more\n\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index]\n    }\n\n    event = events[index] // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n\n    if (\n      index &&\n      event[1].type === 'chunkFlow' &&\n      events[index - 1][1].type === 'listItemPrefix'\n    ) {\n      subevents = event[1]._tokenizer.events\n      otherIndex = 0\n\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'lineEndingBlank'\n      ) {\n        otherIndex += 2\n      }\n\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'content'\n      ) {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === 'content') {\n            break\n          }\n\n          if (subevents[otherIndex][1].type === 'chunkText') {\n            subevents[otherIndex][1]._isInFirstContentOfListItem = true\n            otherIndex++\n          }\n        }\n      }\n    } // Enter.\n\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        Object.assign(jumps, subcontent(events, index))\n        index = jumps[index]\n        more = true\n      }\n    } // Exit.\n    else if (event[1]._container) {\n      otherIndex = index\n      lineIndex = undefined\n\n      while (otherIndex--) {\n        otherEvent = events[otherIndex]\n\n        if (\n          otherEvent[1].type === 'lineEnding' ||\n          otherEvent[1].type === 'lineEndingBlank'\n        ) {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events[lineIndex][1].type = 'lineEndingBlank'\n            }\n\n            otherEvent[1].type = 'lineEnding'\n            lineIndex = otherIndex\n          }\n        } else {\n          break\n        }\n      }\n\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = Object.assign({}, events[lineIndex][1].start) // Switch container exit w/ line endings.\n\n        parameters = events.slice(lineIndex, index)\n        parameters.unshift(event)\n        splice(events, lineIndex, index - lineIndex + 1, parameters)\n      }\n    }\n  }\n\n  return !more\n}\n/**\n * Tokenize embedded tokens.\n *\n * @param {Event[]} events\n * @param {number} eventIndex\n * @returns {Record<string, number>}\n */\n\nfunction subcontent(events, eventIndex) {\n  const token = events[eventIndex][1]\n  const context = events[eventIndex][2]\n  let startPosition = eventIndex - 1\n  /** @type {number[]} */\n\n  const startPositions = []\n  const tokenizer =\n    token._tokenizer || context.parser[token.contentType](token.start)\n  const childEvents = tokenizer.events\n  /** @type {[number, number][]} */\n\n  const jumps = []\n  /** @type {Record<string, number>} */\n\n  const gaps = {}\n  /** @type {Chunk[]} */\n\n  let stream\n  /** @type {Token|undefined} */\n\n  let previous\n  let index = -1\n  /** @type {Token|undefined} */\n\n  let current = token\n  let adjust = 0\n  let start = 0\n  const breaks = [start] // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n\n  while (current) {\n    // Find the position of the event for this token.\n    while (events[++startPosition][1] !== current) {\n      // Empty.\n    }\n\n    startPositions.push(startPosition)\n\n    if (!current._tokenizer) {\n      stream = context.sliceStream(current)\n\n      if (!current.next) {\n        stream.push(null)\n      }\n\n      if (previous) {\n        tokenizer.defineSkip(current.start)\n      }\n\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true\n      }\n\n      tokenizer.write(stream)\n\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined\n      }\n    } // Unravel the next token.\n\n    previous = current\n    current = current.next\n  } // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n\n  current = token\n\n  while (++index < childEvents.length) {\n    if (\n      // Find a void token that includes a break.\n      childEvents[index][0] === 'exit' &&\n      childEvents[index - 1][0] === 'enter' &&\n      childEvents[index][1].type === childEvents[index - 1][1].type &&\n      childEvents[index][1].start.line !== childEvents[index][1].end.line\n    ) {\n      start = index + 1\n      breaks.push(start) // Help GC.\n\n      current._tokenizer = undefined\n      current.previous = undefined\n      current = current.next\n    }\n  } // Help GC.\n\n  tokenizer.events = [] // If there’s one more token (which is the cases for lines that end in an\n  // EOF), that’s perfect: the last point we found starts it.\n  // If there isn’t then make sure any remaining content is added to it.\n\n  if (current) {\n    // Help GC.\n    current._tokenizer = undefined\n    current.previous = undefined\n  } else {\n    breaks.pop()\n  } // Now splice the events from the subtokenizer into the current events,\n  // moving back to front so that splice indices aren’t affected.\n\n  index = breaks.length\n\n  while (index--) {\n    const slice = childEvents.slice(breaks[index], breaks[index + 1])\n    const start = startPositions.pop()\n    jumps.unshift([start, start + slice.length - 1])\n    splice(events, start, 2, slice)\n  }\n\n  index = -1\n\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1]\n    adjust += jumps[index][1] - jumps[index][0] - 1\n  }\n\n  return gaps\n}\n"],"names":["attention","name","tokenize","effects","ok","marker","attentionMarkers","this","parser","constructs","null","previous","before","classifyCharacter","code","enter","sequence","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","push","insideSpan","slice","splice","point","column","_bufferIndex","autolink","nok","size","asciiAlpha","schemeOrEmailAtext","asciiAtext","emailAtext","asciiAlphanumeric","schemeInsideOrEmailAtext","urlInside","asciiControl","emailAtSignOrDot","emailLabel","emailValue","blankLine","factorySpace","markdownLineEnding","partial","blockQuote","self","state","containerState","_container","markdownSpace","continuation","attempt","disable","undefined","characterEscape","asciiPunctuation","characterReference","max","test","numeric","value","asciiHexDigit","asciiDigit","decodeNamedCharacterReference","codeFenced","closingFenceConstruct","closingSequenceStart","sizeOpen","closingSequenceEnd","nonLazyLine","lineStart","lazy","now","line","tail","initialPrefix","sequenceOpen","infoOpen","openAfter","contentType","info","markdownLineEndingOrSpace","infoAfter","meta","interrupt","contentStart","contentContinue","concrete","codeIndented","afterStartPrefix","afterPrefix","indentedContent","content","codeText","gap","data","resolve","tailExitIndex","headEnterIndex","contentEnd","check","continuationConstruct","next","subtokenize","prefixed","flow","definition","identifier","factoryLabel","labelAfter","normalizeIdentifier","factoryWhitespace","factoryDestination","titleConstruct","defined","factoryTitle","hardBreakEscape","headingAtx","fenceOpenInside","headingBreak","htmlFlow","kind","startTag","buffer","declarationStart","tagCloseStart","continuationDeclarationInside","String","fromCharCode","tagName","commentOpenInside","cdataOpenInside","htmlRawNames","toLowerCase","htmlBlockNames","basicSelfClosing","completeAttributeNameBefore","completeClosingTagAfter","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCharacterDataInside","continuationAtLineEnding","nextBlankConstruct","htmlContinueStart","done","htmlLineEnd","continuationRawEndTag","resolveTo","htmlText","returnState","declarationOpen","instruction","tagOpen","commentOpen","cdataOpen","declaration","commentStart","commentStartDash","comment","commentClose","atLineEnding","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","labelEnd","labelStart","_balanced","_inactive","balanced","afterLabelEnd","resourceConstruct","fullReferenceConstruct","collapsedReferenceConstruct","media","label","destinationAfter","between","afterLabel","labelStartImage","labelStartLink","lineEnding","list","initialSize","thematicBreak","atMarker","inside","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","_closeFlow","furtherBlankLines","notInCurrentItem","indentConstruct","setextUnderline","paragraph","heading","atBreak","gfm","options","combineExtensions","gfmAutolinkLiteral","gfmFootnote","gfmStrikethrough","gfmTable","gfmTaskListItem","literalType","literalMarkerType","rawType","stringType","limit","Number","POSITIVE_INFINITY","balance","destinationEnclosedBefore","destinationRaw","destinationEnclosed","destinationEnclosedEscape","destinationRawEscape","markerType","labelEscape","prefix","atFirstTitleBreak","atTitleBreak","title","titleEscape","seen","regexCheck","unicodeWhitespace","unicodePunctuation","regex","remove","items","parameters","chunkStart","Array","from","unshift","apply","characterReferences","encode","replace","event","lineIndex","otherIndex","otherEvent","subevents","more","jumps","_tokenizer","_isInFirstContentOfListItem","subcontent","eventIndex","stream","startPosition","startPositions","tokenizer","childEvents","gaps","current","adjust","breaks","sliceStream","defineSkip","_gfmTasklistFirstContentOfListItem","write","pop"],"sourceRoot":""}