{"version":3,"file":"js/1771-e8ab6f681480be51ae45.js","mappings":"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","sources":["webpack://artfully-walls/./node_modules/micromark-util-character/index.js","webpack://artfully-walls/./node_modules/micromark-util-chunked/index.js","webpack://artfully-walls/./node_modules/micromark-util-decode-numeric-character-reference/index.js","webpack://artfully-walls/./node_modules/micromark-util-decode-string/index.js","webpack://artfully-walls/./node_modules/micromark-util-normalize-identifier/index.js","webpack://artfully-walls/./node_modules/micromark-util-sanitize-uri/index.js","webpack://artfully-walls/./node_modules/micromark-util-subtokenize/lib/splice-buffer.js","webpack://artfully-walls/./node_modules/micromark-util-subtokenize/index.js","webpack://artfully-walls/./node_modules/micromark-util-combine-extensions/index.js","webpack://artfully-walls/./node_modules/micromark-factory-space/index.js","webpack://artfully-walls/./node_modules/micromark/lib/initialize/content.js","webpack://artfully-walls/./node_modules/micromark/lib/initialize/document.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/blank-line.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/content.js","webpack://artfully-walls/./node_modules/micromark/lib/initialize/flow.js","webpack://artfully-walls/./node_modules/micromark/lib/initialize/text.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/thematic-break.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/list.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/block-quote.js","webpack://artfully-walls/./node_modules/micromark-factory-destination/index.js","webpack://artfully-walls/./node_modules/micromark-factory-label/index.js","webpack://artfully-walls/./node_modules/micromark-factory-title/index.js","webpack://artfully-walls/./node_modules/micromark-factory-whitespace/index.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/definition.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/code-indented.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/heading-atx.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/setext-underline.js","webpack://artfully-walls/./node_modules/micromark-util-html-tag-name/index.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/html-flow.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/code-fenced.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/character-reference.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/character-escape.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/line-ending.js","webpack://artfully-walls/./node_modules/micromark-util-resolve-all/index.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/label-end.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/label-start-image.js","webpack://artfully-walls/./node_modules/micromark-util-classify-character/index.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/attention.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/autolink.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/html-text.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/label-start-link.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/hard-break-escape.js","webpack://artfully-walls/./node_modules/micromark-core-commonmark/lib/code-text.js","webpack://artfully-walls/./node_modules/micromark/lib/constructs.js","webpack://artfully-walls/./node_modules/micromark/lib/create-tokenizer.js","webpack://artfully-walls/./node_modules/micromark/lib/parse.js","webpack://artfully-walls/./node_modules/micromark/lib/postprocess.js","webpack://artfully-walls/./node_modules/micromark/lib/preprocess.js"],"sourcesContent":["/**\n * @import {Code} from 'micromark-util-types'\n */\n\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlpha = regexCheck(/[A-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\n\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  );\n}\n\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiDigit = regexCheck(/\\d/);\n\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\n\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\n\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2;\n}\n\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32);\n}\n\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32;\n}\n\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodePunctuation = regexCheck(/\\p{P}|\\p{S}/u);\n\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/);\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n *   Expression.\n * @returns {(code: Code) => boolean}\n *   Check.\n */\nfunction regexCheck(regex) {\n  return check;\n\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code\n   *   Character code.\n   * @returns {boolean}\n   *   Whether the character code matches the bound regex.\n   */\n  function check(code) {\n    return code !== null && code > -1 && regex.test(String.fromCharCode(code));\n  }\n}","/**\n * Like `Array#splice`, but smarter for giant arrays.\n *\n * `Array#splice` takes all items to be inserted as individual argument which\n * causes a stack overflow in V8 when trying to insert 100k items for instance.\n *\n * Otherwise, this does not return the removed items, and takes `items` as an\n * array instead of rest parameters.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {number} start\n *   Index to remove/insert at (can be negative).\n * @param {number} remove\n *   Number of items to remove.\n * @param {Array<T>} items\n *   Items to inject into `list`.\n * @returns {undefined}\n *   Nothing.\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length;\n  let chunkStart = 0;\n  /** @type {Array<unknown>} */\n  let parameters;\n\n  // Make start between zero and `end` (included).\n  if (start < 0) {\n    start = -start > end ? 0 : end + start;\n  } else {\n    start = start > end ? end : start;\n  }\n  remove = remove > 0 ? remove : 0;\n\n  // No need to chunk the items if there’s only a couple (10k) items.\n  if (items.length < 10000) {\n    parameters = Array.from(items);\n    parameters.unshift(start, remove);\n    // @ts-expect-error Hush, it’s fine.\n    list.splice(...parameters);\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) list.splice(start, remove);\n\n    // Insert the items in chunks to not cause stack overflows.\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000);\n      parameters.unshift(start, 0);\n      // @ts-expect-error Hush, it’s fine.\n      list.splice(...parameters);\n      chunkStart += 10000;\n      start += 10000;\n    }\n  }\n}\n\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {Array<T>} items\n *   Items to add to `list`.\n * @returns {Array<T>}\n *   Either `list` or `items`.\n */\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items);\n    return list;\n  }\n  return items;\n}","/**\n * Turn the number (in string form as either hexa- or plain decimal) coming from\n * a numeric character reference into a character.\n *\n * Sort of like `String.fromCodePoint(Number.parseInt(value, base))`, but makes\n * non-characters and control characters safe.\n *\n * @param {string} value\n *   Value to decode.\n * @param {number} base\n *   Numeric base.\n * @returns {string}\n *   Character.\n */\nexport function decodeNumericCharacterReference(value, base) {\n  const code = Number.parseInt(value, base);\n  if (\n  // C0 except for HT, LF, FF, CR, space.\n  code < 9 || code === 11 || code > 13 && code < 32 ||\n  // Control character (DEL) of C0, and C1 controls.\n  code > 126 && code < 160 ||\n  // Lone high surrogates and low surrogates.\n  code > 55_295 && code < 57_344 ||\n  // Noncharacters.\n  code > 64_975 && code < 65_008 || /* eslint-disable no-bitwise */\n  (code & 65_535) === 65_535 || (code & 65_535) === 65_534 || /* eslint-enable no-bitwise */\n  // Out of range\n  code > 1_114_111) {\n    return \"\\uFFFD\";\n  }\n  return String.fromCodePoint(code);\n}","import { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { decodeNumericCharacterReference } from 'micromark-util-decode-numeric-character-reference';\nconst characterEscapeOrReference = /\\\\([!-/:-@[-`{-~])|&(#(?:\\d{1,7}|x[\\da-f]{1,6})|[\\da-z]{1,31});/gi;\n\n/**\n * Decode markdown strings (which occur in places such as fenced code info\n * strings, destinations, labels, and titles).\n *\n * The “string” content type allows character escapes and -references.\n * This decodes those.\n *\n * @param {string} value\n *   Value to decode.\n * @returns {string}\n *   Decoded value.\n */\nexport function decodeString(value) {\n  return value.replace(characterEscapeOrReference, decode);\n}\n\n/**\n * @param {string} $0\n *   Match.\n * @param {string} $1\n *   Character escape.\n * @param {string} $2\n *   Character reference.\n * @returns {string}\n *   Decoded value\n */\nfunction decode($0, $1, $2) {\n  if ($1) {\n    // Escape.\n    return $1;\n  }\n\n  // Reference.\n  const head = $2.charCodeAt(0);\n  if (head === 35) {\n    const head = $2.charCodeAt(1);\n    const hex = head === 120 || head === 88;\n    return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10);\n  }\n  return decodeNamedCharacterReference($2) || $0;\n}","/**\n * Normalize an identifier (as found in references, definitions).\n *\n * Collapses markdown whitespace, trim, and then lower- and uppercase.\n *\n * Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their\n * lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different\n * uppercase character (U+0398 (`Θ`)).\n * So, to get a canonical form, we perform both lower- and uppercase.\n *\n * Using uppercase last makes sure keys will never interact with default\n * prototypal values (such as `constructor`): nothing in the prototype of\n * `Object` is uppercase.\n *\n * @param {string} value\n *   Identifier to normalize.\n * @returns {string}\n *   Normalized identifier.\n */\nexport function normalizeIdentifier(value) {\n  return value\n  // Collapse markdown whitespace.\n  .replace(/[\\t\\n\\r ]+/g, \" \")\n  // Trim.\n  .replace(/^ | $/g, '')\n  // Some characters are considered “uppercase”, but if their lowercase\n  // counterpart is uppercased will result in a different uppercase\n  // character.\n  // Hence, to get that form, we perform both lower- and uppercase.\n  // Upper case makes sure keys will not interact with default prototypal\n  // methods: no method is uppercase.\n  .toLowerCase().toUpperCase();\n}","import { asciiAlphanumeric } from 'micromark-util-character';\nimport { encode } from 'micromark-util-encode';\n/**\n * Make a value safe for injection as a URL.\n *\n * This encodes unsafe characters with percent-encoding and skips already\n * encoded sequences (see `normalizeUri`).\n * Further unsafe characters are encoded as character references (see\n * `micromark-util-encode`).\n *\n * A regex of allowed protocols can be given, in which case the URL is\n * sanitized.\n * For example, `/^(https?|ircs?|mailto|xmpp)$/i` can be used for `a[href]`, or\n * `/^https?$/i` for `img[src]` (this is what `github.com` allows).\n * If the URL includes an unknown protocol (one not matched by `protocol`, such\n * as a dangerous example, `javascript:`), the value is ignored.\n *\n * @param {string | null | undefined} url\n *   URI to sanitize.\n * @param {RegExp | null | undefined} [protocol]\n *   Allowed protocols.\n * @returns {string}\n *   Sanitized URI.\n */\nexport function sanitizeUri(url, protocol) {\n  const value = encode(normalizeUri(url || ''));\n  if (!protocol) {\n    return value;\n  }\n  const colon = value.indexOf(':');\n  const questionMark = value.indexOf('?');\n  const numberSign = value.indexOf('#');\n  const slash = value.indexOf('/');\n  if (\n  // If there is no protocol, it’s relative.\n  colon < 0 ||\n  // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.\n  slash > -1 && colon > slash || questionMark > -1 && colon > questionMark || numberSign > -1 && colon > numberSign ||\n  // It is a protocol, it should be allowed.\n  protocol.test(value.slice(0, colon))) {\n    return value;\n  }\n  return '';\n}\n\n/**\n * Normalize a URL.\n *\n * Encode unsafe characters with percent-encoding, skipping already encoded\n * sequences.\n *\n * @param {string} value\n *   URI to normalize.\n * @returns {string}\n *   Normalized URI.\n */\nexport function normalizeUri(value) {\n  /** @type {Array<string>} */\n  const result = [];\n  let index = -1;\n  let start = 0;\n  let skip = 0;\n  while (++index < value.length) {\n    const code = value.charCodeAt(index);\n    /** @type {string} */\n    let replace = '';\n\n    // A correct percent encoded value.\n    if (code === 37 && asciiAlphanumeric(value.charCodeAt(index + 1)) && asciiAlphanumeric(value.charCodeAt(index + 2))) {\n      skip = 2;\n    }\n    // ASCII.\n    else if (code < 128) {\n      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {\n        replace = String.fromCharCode(code);\n      }\n    }\n    // Astral.\n    else if (code > 55_295 && code < 57_344) {\n      const next = value.charCodeAt(index + 1);\n\n      // A correct surrogate pair.\n      if (code < 56_320 && next > 56_319 && next < 57_344) {\n        replace = String.fromCharCode(code, next);\n        skip = 1;\n      }\n      // Lone surrogate.\n      else {\n        replace = \"\\uFFFD\";\n      }\n    }\n    // Unicode.\n    else {\n      replace = String.fromCharCode(code);\n    }\n    if (replace) {\n      result.push(value.slice(start, index), encodeURIComponent(replace));\n      start = index + skip + 1;\n      replace = '';\n    }\n    if (skip) {\n      index += skip;\n      skip = 0;\n    }\n  }\n  return result.join('') + value.slice(start);\n}","/**\n * Some of the internal operations of micromark do lots of editing\n * operations on very large arrays. This runs into problems with two\n * properties of most circa-2020 JavaScript interpreters:\n *\n *  - Array-length modifications at the high end of an array (push/pop) are\n *    expected to be common and are implemented in (amortized) time\n *    proportional to the number of elements added or removed, whereas\n *    other operations (shift/unshift and splice) are much less efficient.\n *  - Function arguments are passed on the stack, so adding tens of thousands\n *    of elements to an array with `arr.push(...newElements)` will frequently\n *    cause stack overflows. (see <https://stackoverflow.com/questions/22123769/rangeerror-maximum-call-stack-size-exceeded-why>)\n *\n * SpliceBuffers are an implementation of gap buffers, which are a\n * generalization of the \"queue made of two stacks\" idea. The splice buffer\n * maintains a cursor, and moving the cursor has cost proportional to the\n * distance the cursor moves, but inserting, deleting, or splicing in\n * new information at the cursor is as efficient as the push/pop operation.\n * This allows for an efficient sequence of splices (or pushes, pops, shifts,\n * or unshifts) as long such edits happen at the same part of the array or\n * generally sweep through the array from the beginning to the end.\n *\n * The interface for splice buffers also supports large numbers of inputs by\n * passing a single array argument rather passing multiple arguments on the\n * function call stack.\n *\n * @template T\n *   Item type.\n */\nexport class SpliceBuffer {\n  /**\n   * @param {ReadonlyArray<T> | null | undefined} [initial]\n   *   Initial items (optional).\n   * @returns\n   *   Splice buffer.\n   */\n  constructor(initial) {\n    /** @type {Array<T>} */\n    this.left = initial ? [...initial] : [];\n    /** @type {Array<T>} */\n    this.right = [];\n  }\n\n  /**\n   * Array access;\n   * does not move the cursor.\n   *\n   * @param {number} index\n   *   Index.\n   * @return {T}\n   *   Item.\n   */\n  get(index) {\n    if (index < 0 || index >= this.left.length + this.right.length) {\n      throw new RangeError('Cannot access index `' + index + '` in a splice buffer of size `' + (this.left.length + this.right.length) + '`');\n    }\n    if (index < this.left.length) return this.left[index];\n    return this.right[this.right.length - index + this.left.length - 1];\n  }\n\n  /**\n   * The length of the splice buffer, one greater than the largest index in the\n   * array.\n   */\n  get length() {\n    return this.left.length + this.right.length;\n  }\n\n  /**\n   * Remove and return `list[0]`;\n   * moves the cursor to `0`.\n   *\n   * @returns {T | undefined}\n   *   Item, optional.\n   */\n  shift() {\n    this.setCursor(0);\n    return this.right.pop();\n  }\n\n  /**\n   * Slice the buffer to get an array;\n   * does not move the cursor.\n   *\n   * @param {number} start\n   *   Start.\n   * @param {number | null | undefined} [end]\n   *   End (optional).\n   * @returns {Array<T>}\n   *   Array of items.\n   */\n  slice(start, end) {\n    /** @type {number} */\n    const stop = end === null || end === undefined ? Number.POSITIVE_INFINITY : end;\n    if (stop < this.left.length) {\n      return this.left.slice(start, stop);\n    }\n    if (start > this.left.length) {\n      return this.right.slice(this.right.length - stop + this.left.length, this.right.length - start + this.left.length).reverse();\n    }\n    return this.left.slice(start).concat(this.right.slice(this.right.length - stop + this.left.length).reverse());\n  }\n\n  /**\n   * Mimics the behavior of Array.prototype.splice() except for the change of\n   * interface necessary to avoid segfaults when patching in very large arrays.\n   *\n   * This operation moves cursor is moved to `start` and results in the cursor\n   * placed after any inserted items.\n   *\n   * @param {number} start\n   *   Start;\n   *   zero-based index at which to start changing the array;\n   *   negative numbers count backwards from the end of the array and values\n   *   that are out-of bounds are clamped to the appropriate end of the array.\n   * @param {number | null | undefined} [deleteCount=0]\n   *   Delete count (default: `0`);\n   *   maximum number of elements to delete, starting from start.\n   * @param {Array<T> | null | undefined} [items=[]]\n   *   Items to include in place of the deleted items (default: `[]`).\n   * @return {Array<T>}\n   *   Any removed items.\n   */\n  splice(start, deleteCount, items) {\n    /** @type {number} */\n    const count = deleteCount || 0;\n    this.setCursor(Math.trunc(start));\n    const removed = this.right.splice(this.right.length - count, Number.POSITIVE_INFINITY);\n    if (items) chunkedPush(this.left, items);\n    return removed.reverse();\n  }\n\n  /**\n   * Remove and return the highest-numbered item in the array, so\n   * `list[list.length - 1]`;\n   * Moves the cursor to `length`.\n   *\n   * @returns {T | undefined}\n   *   Item, optional.\n   */\n  pop() {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    return this.left.pop();\n  }\n\n  /**\n   * Inserts a single item to the high-numbered side of the array;\n   * moves the cursor to `length`.\n   *\n   * @param {T} item\n   *   Item.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  push(item) {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    this.left.push(item);\n  }\n\n  /**\n   * Inserts many items to the high-numbered side of the array.\n   * Moves the cursor to `length`.\n   *\n   * @param {Array<T>} items\n   *   Items.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  pushMany(items) {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    chunkedPush(this.left, items);\n  }\n\n  /**\n   * Inserts a single item to the low-numbered side of the array;\n   * Moves the cursor to `0`.\n   *\n   * @param {T} item\n   *   Item.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  unshift(item) {\n    this.setCursor(0);\n    this.right.push(item);\n  }\n\n  /**\n   * Inserts many items to the low-numbered side of the array;\n   * moves the cursor to `0`.\n   *\n   * @param {Array<T>} items\n   *   Items.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  unshiftMany(items) {\n    this.setCursor(0);\n    chunkedPush(this.right, items.reverse());\n  }\n\n  /**\n   * Move the cursor to a specific position in the array. Requires\n   * time proportional to the distance moved.\n   *\n   * If `n < 0`, the cursor will end up at the beginning.\n   * If `n > length`, the cursor will end up at the end.\n   *\n   * @param {number} n\n   *   Position.\n   * @return {undefined}\n   *   Nothing.\n   */\n  setCursor(n) {\n    if (n === this.left.length || n > this.left.length && this.right.length === 0 || n < 0 && this.left.length === 0) return;\n    if (n < this.left.length) {\n      // Move cursor to the this.left\n      const removed = this.left.splice(n, Number.POSITIVE_INFINITY);\n      chunkedPush(this.right, removed.reverse());\n    } else {\n      // Move cursor to the this.right\n      const removed = this.right.splice(this.left.length + this.right.length - n, Number.POSITIVE_INFINITY);\n      chunkedPush(this.left, removed.reverse());\n    }\n  }\n}\n\n/**\n * Avoid stack overflow by pushing items onto the stack in segments\n *\n * @template T\n *   Item type.\n * @param {Array<T>} list\n *   List to inject into.\n * @param {ReadonlyArray<T>} right\n *   Items to inject.\n * @return {undefined}\n *   Nothing.\n */\nfunction chunkedPush(list, right) {\n  /** @type {number} */\n  let chunkStart = 0;\n  if (right.length < 10000) {\n    list.push(...right);\n  } else {\n    while (chunkStart < right.length) {\n      list.push(...right.slice(chunkStart, chunkStart + 10000));\n      chunkStart += 10000;\n    }\n  }\n}","/**\n * @import {Chunk, Event, Token} from 'micromark-util-types'\n */\n\nimport { splice } from 'micromark-util-chunked';\nimport { SpliceBuffer } from './lib/splice-buffer.js';\n\n// Hidden API exposed for testing.\nexport { SpliceBuffer } from './lib/splice-buffer.js';\n\n/**\n * Tokenize subcontent.\n *\n * @param {Array<Event>} eventsArray\n *   List of events.\n * @returns {boolean}\n *   Whether subtokens were found.\n */\n// eslint-disable-next-line complexity\nexport function subtokenize(eventsArray) {\n  /** @type {Record<string, number>} */\n  const jumps = {};\n  let index = -1;\n  /** @type {Event} */\n  let event;\n  /** @type {number | undefined} */\n  let lineIndex;\n  /** @type {number} */\n  let otherIndex;\n  /** @type {Event} */\n  let otherEvent;\n  /** @type {Array<Event>} */\n  let parameters;\n  /** @type {Array<Event>} */\n  let subevents;\n  /** @type {boolean | undefined} */\n  let more;\n  const events = new SpliceBuffer(eventsArray);\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index];\n    }\n    event = events.get(index);\n\n    // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n    if (index && event[1].type === \"chunkFlow\" && events.get(index - 1)[1].type === \"listItemPrefix\") {\n      subevents = event[1]._tokenizer.events;\n      otherIndex = 0;\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === \"lineEndingBlank\") {\n        otherIndex += 2;\n      }\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === \"content\") {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === \"content\") {\n            break;\n          }\n          if (subevents[otherIndex][1].type === \"chunkText\") {\n            subevents[otherIndex][1]._isInFirstContentOfListItem = true;\n            otherIndex++;\n          }\n        }\n      }\n    }\n\n    // Enter.\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        Object.assign(jumps, subcontent(events, index));\n        index = jumps[index];\n        more = true;\n      }\n    }\n    // Exit.\n    else if (event[1]._container) {\n      otherIndex = index;\n      lineIndex = undefined;\n      while (otherIndex--) {\n        otherEvent = events.get(otherIndex);\n        if (otherEvent[1].type === \"lineEnding\" || otherEvent[1].type === \"lineEndingBlank\") {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events.get(lineIndex)[1].type = \"lineEndingBlank\";\n            }\n            otherEvent[1].type = \"lineEnding\";\n            lineIndex = otherIndex;\n          }\n        } else {\n          break;\n        }\n      }\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = {\n          ...events.get(lineIndex)[1].start\n        };\n\n        // Switch container exit w/ line endings.\n        parameters = events.slice(lineIndex, index);\n        parameters.unshift(event);\n        events.splice(lineIndex, index - lineIndex + 1, parameters);\n      }\n    }\n  }\n\n  // The changes to the `events` buffer must be copied back into the eventsArray\n  splice(eventsArray, 0, Number.POSITIVE_INFINITY, events.slice(0));\n  return !more;\n}\n\n/**\n * Tokenize embedded tokens.\n *\n * @param {SpliceBuffer<Event>} events\n *   Events.\n * @param {number} eventIndex\n *   Index.\n * @returns {Record<string, number>}\n *   Gaps.\n */\nfunction subcontent(events, eventIndex) {\n  const token = events.get(eventIndex)[1];\n  const context = events.get(eventIndex)[2];\n  let startPosition = eventIndex - 1;\n  /** @type {Array<number>} */\n  const startPositions = [];\n  const tokenizer = token._tokenizer || context.parser[token.contentType](token.start);\n  const childEvents = tokenizer.events;\n  /** @type {Array<[number, number]>} */\n  const jumps = [];\n  /** @type {Record<string, number>} */\n  const gaps = {};\n  /** @type {Array<Chunk>} */\n  let stream;\n  /** @type {Token | undefined} */\n  let previous;\n  let index = -1;\n  /** @type {Token | undefined} */\n  let current = token;\n  let adjust = 0;\n  let start = 0;\n  const breaks = [start];\n\n  // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n  while (current) {\n    // Find the position of the event for this token.\n    while (events.get(++startPosition)[1] !== current) {\n      // Empty.\n    }\n    startPositions.push(startPosition);\n    if (!current._tokenizer) {\n      stream = context.sliceStream(current);\n      if (!current.next) {\n        stream.push(null);\n      }\n      if (previous) {\n        tokenizer.defineSkip(current.start);\n      }\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true;\n      }\n      tokenizer.write(stream);\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined;\n      }\n    }\n\n    // Unravel the next token.\n    previous = current;\n    current = current.next;\n  }\n\n  // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n  current = token;\n  while (++index < childEvents.length) {\n    if (\n    // Find a void token that includes a break.\n    childEvents[index][0] === 'exit' && childEvents[index - 1][0] === 'enter' && childEvents[index][1].type === childEvents[index - 1][1].type && childEvents[index][1].start.line !== childEvents[index][1].end.line) {\n      start = index + 1;\n      breaks.push(start);\n      // Help GC.\n      current._tokenizer = undefined;\n      current.previous = undefined;\n      current = current.next;\n    }\n  }\n\n  // Help GC.\n  tokenizer.events = [];\n\n  // If there’s one more token (which is the cases for lines that end in an\n  // EOF), that’s perfect: the last point we found starts it.\n  // If there isn’t then make sure any remaining content is added to it.\n  if (current) {\n    // Help GC.\n    current._tokenizer = undefined;\n    current.previous = undefined;\n  } else {\n    breaks.pop();\n  }\n\n  // Now splice the events from the subtokenizer into the current events,\n  // moving back to front so that splice indices aren’t affected.\n  index = breaks.length;\n  while (index--) {\n    const slice = childEvents.slice(breaks[index], breaks[index + 1]);\n    const start = startPositions.pop();\n    jumps.push([start, start + slice.length - 1]);\n    events.splice(start, 2, slice);\n  }\n  jumps.reverse();\n  index = -1;\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1];\n    adjust += jumps[index][1] - jumps[index][0] - 1;\n  }\n  return gaps;\n}","/**\n * @import {\n *   Extension,\n *   Handles,\n *   HtmlExtension,\n *   NormalizedExtension\n * } from 'micromark-util-types'\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine multiple syntax extensions into one.\n *\n * @param {ReadonlyArray<Extension>} extensions\n *   List of syntax extensions.\n * @returns {NormalizedExtension}\n *   A single combined extension.\n */\nexport function combineExtensions(extensions) {\n  /** @type {NormalizedExtension} */\n  const all = {}\n  let index = -1\n\n  while (++index < extensions.length) {\n    syntaxExtension(all, extensions[index])\n  }\n\n  return all\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {NormalizedExtension} all\n *   Extension to merge into.\n * @param {Extension} extension\n *   Extension to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction syntaxExtension(all, extension) {\n  /** @type {keyof Extension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    /** @type {Record<string, unknown>} */\n    const left = maybe || (all[hook] = {})\n    /** @type {Record<string, unknown> | undefined} */\n    const right = extension[hook]\n    /** @type {string} */\n    let code\n\n    if (right) {\n      for (code in right) {\n        if (!hasOwnProperty.call(left, code)) left[code] = []\n        const value = right[code]\n        constructs(\n          // @ts-expect-error Looks like a list.\n          left[code],\n          Array.isArray(value) ? value : value ? [value] : []\n        )\n      }\n    }\n  }\n}\n\n/**\n * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {Array<unknown>} existing\n *   List of constructs to merge into.\n * @param {Array<unknown>} list\n *   List of constructs to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction constructs(existing, list) {\n  let index = -1\n  /** @type {Array<unknown>} */\n  const before = []\n\n  while (++index < list.length) {\n    // @ts-expect-error Looks like an object.\n    ;(list[index].add === 'after' ? existing : before).push(list[index])\n  }\n\n  splice(existing, 0, 0, before)\n}\n\n/**\n * Combine multiple HTML extensions into one.\n *\n * @param {ReadonlyArray<HtmlExtension>} htmlExtensions\n *   List of HTML extensions.\n * @returns {HtmlExtension}\n *   Single combined HTML extension.\n */\nexport function combineHtmlExtensions(htmlExtensions) {\n  /** @type {HtmlExtension} */\n  const handlers = {}\n  let index = -1\n\n  while (++index < htmlExtensions.length) {\n    htmlExtension(handlers, htmlExtensions[index])\n  }\n\n  return handlers\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {HtmlExtension} all\n *   Extension to merge into.\n * @param {HtmlExtension} extension\n *   Extension to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction htmlExtension(all, extension) {\n  /** @type {keyof HtmlExtension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    const left = maybe || (all[hook] = {})\n    const right = extension[hook]\n    /** @type {keyof Handles} */\n    let type\n\n    if (right) {\n      for (type in right) {\n        // @ts-expect-error assume document vs regular handler are managed correctly.\n        left[type] = right[type]\n      }\n    }\n  }\n}\n","/**\n * @import {Effects, State, TokenType} from 'micromark-util-types'\n */\n\nimport { markdownSpace } from 'micromark-util-character';\n\n// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.\n\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   spaces in markdown are often optional, in which case this factory can be\n *     used and `ok` will be switched to whether spaces were found or not\n * *   one line ending or space can be detected with `markdownSpace(code)` right\n *     before using `factorySpace`\n *\n * ###### Examples\n *\n * Where `␉` represents a tab (plus how much it expands) and `␠` represents a\n * single space.\n *\n * ```markdown\n * ␉\n * ␠␠␠␠\n * ␉␠\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {TokenType} type\n *   Type (`' \\t'`).\n * @param {number | undefined} [max=Infinity]\n *   Max (exclusive).\n * @returns {State}\n *   Start state.\n */\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Number.POSITIVE_INFINITY;\n  let size = 0;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type);\n      return prefix(code);\n    }\n    return ok(code);\n  }\n\n  /** @type {State} */\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code);\n      return prefix;\n    }\n    effects.exit(type);\n    return ok(code);\n  }\n}","/**\n * @import {\n *   InitialConstruct,\n *   Initializer,\n *   State,\n *   TokenizeContext,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {InitialConstruct} */\nexport const content = {\n  tokenize: initializeContent\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Initializer}\n *   Content.\n */\nfunction initializeContent(effects) {\n  const contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial);\n  /** @type {Token} */\n  let previous;\n  return contentStart;\n\n  /** @type {State} */\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, contentStart, \"linePrefix\");\n  }\n\n  /** @type {State} */\n  function paragraphInitial(code) {\n    effects.enter(\"paragraph\");\n    return lineStart(code);\n  }\n\n  /** @type {State} */\n  function lineStart(code) {\n    const token = effects.enter(\"chunkText\", {\n      contentType: \"text\",\n      previous\n    });\n    if (previous) {\n      previous.next = token;\n    }\n    previous = token;\n    return data(code);\n  }\n\n  /** @type {State} */\n  function data(code) {\n    if (code === null) {\n      effects.exit(\"chunkText\");\n      effects.exit(\"paragraph\");\n      effects.consume(code);\n      return;\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      effects.exit(\"chunkText\");\n      return lineStart;\n    }\n\n    // Data.\n    effects.consume(code);\n    return data;\n  }\n}","/**\n * @import {\n *   Construct,\n *   ContainerState,\n *   InitialConstruct,\n *   Initializer,\n *   Point,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\n/**\n * @typedef {[Construct, ContainerState]} StackItem\n *   Construct and its state.\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { splice } from 'micromark-util-chunked';\n/** @type {InitialConstruct} */\nexport const document = {\n  tokenize: initializeDocument\n};\n\n/** @type {Construct} */\nconst containerConstruct = {\n  tokenize: tokenizeContainer\n};\n\n/**\n * @this {TokenizeContext}\n *   Self.\n * @type {Initializer}\n *   Initializer.\n */\nfunction initializeDocument(effects) {\n  const self = this;\n  /** @type {Array<StackItem>} */\n  const stack = [];\n  let continued = 0;\n  /** @type {TokenizeContext | undefined} */\n  let childFlow;\n  /** @type {Token | undefined} */\n  let childToken;\n  /** @type {number} */\n  let lineStartOffset;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    // First we iterate through the open blocks, starting with the root\n    // document, and descending through last children down to the last open\n    // block.\n    // Each block imposes a condition that the line must satisfy if the block is\n    // to remain open.\n    // For example, a block quote requires a `>` character.\n    // A paragraph requires a non-blank line.\n    // In this phase we may match all or just some of the open blocks.\n    // But we cannot close unmatched blocks yet, because we may have a lazy\n    // continuation line.\n    if (continued < stack.length) {\n      const item = stack[continued];\n      self.containerState = item[1];\n      return effects.attempt(item[0].continuation, documentContinue, checkNewContainers)(code);\n    }\n\n    // Done.\n    return checkNewContainers(code);\n  }\n\n  /** @type {State} */\n  function documentContinue(code) {\n    continued++;\n\n    // Note: this field is called `_closeFlow` but it also closes containers.\n    // Perhaps a good idea to rename it but it’s already used in the wild by\n    // extensions.\n    if (self.containerState._closeFlow) {\n      self.containerState._closeFlow = undefined;\n      if (childFlow) {\n        closeFlow();\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when dealing with lazy lines in `writeToChild`.\n      const indexBeforeExits = self.events.length;\n      let indexBeforeFlow = indexBeforeExits;\n      /** @type {Point | undefined} */\n      let point;\n\n      // Find the flow chunk.\n      while (indexBeforeFlow--) {\n        if (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === \"chunkFlow\") {\n          point = self.events[indexBeforeFlow][1].end;\n          break;\n        }\n      }\n      exitContainers(continued);\n\n      // Fix positions.\n      let index = indexBeforeExits;\n      while (index < self.events.length) {\n        self.events[index][1].end = {\n          ...point\n        };\n        index++;\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));\n\n      // Discard the duplicate exits.\n      self.events.length = index;\n      return checkNewContainers(code);\n    }\n    return start(code);\n  }\n\n  /** @type {State} */\n  function checkNewContainers(code) {\n    // Next, after consuming the continuation markers for existing blocks, we\n    // look for new block starts (e.g. `>` for a block quote).\n    // If we encounter a new block start, we close any blocks unmatched in\n    // step 1 before creating the new block as a child of the last matched\n    // block.\n    if (continued === stack.length) {\n      // No need to `check` whether there’s a container, of `exitContainers`\n      // would be moot.\n      // We can instead immediately `attempt` to parse one.\n      if (!childFlow) {\n        return documentContinued(code);\n      }\n\n      // If we have concrete content, such as block HTML or fenced code,\n      // we can’t have containers “pierce” into them, so we can immediately\n      // start.\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        return flowStart(code);\n      }\n\n      // If we do have flow, it could still be a blank line,\n      // but we’d be interrupting it w/ a new container if there’s a current\n      // construct.\n      // To do: next major: remove `_gfmTableDynamicInterruptHack` (no longer\n      // needed in micromark-extension-gfm-table@1.0.6).\n      self.interrupt = Boolean(childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack);\n    }\n\n    // Check if there is a new container.\n    self.containerState = {};\n    return effects.check(containerConstruct, thereIsANewContainer, thereIsNoNewContainer)(code);\n  }\n\n  /** @type {State} */\n  function thereIsANewContainer(code) {\n    if (childFlow) closeFlow();\n    exitContainers(continued);\n    return documentContinued(code);\n  }\n\n  /** @type {State} */\n  function thereIsNoNewContainer(code) {\n    self.parser.lazy[self.now().line] = continued !== stack.length;\n    lineStartOffset = self.now().offset;\n    return flowStart(code);\n  }\n\n  /** @type {State} */\n  function documentContinued(code) {\n    // Try new containers.\n    self.containerState = {};\n    return effects.attempt(containerConstruct, containerContinue, flowStart)(code);\n  }\n\n  /** @type {State} */\n  function containerContinue(code) {\n    continued++;\n    stack.push([self.currentConstruct, self.containerState]);\n    // Try another.\n    return documentContinued(code);\n  }\n\n  /** @type {State} */\n  function flowStart(code) {\n    if (code === null) {\n      if (childFlow) closeFlow();\n      exitContainers(0);\n      effects.consume(code);\n      return;\n    }\n    childFlow = childFlow || self.parser.flow(self.now());\n    effects.enter(\"chunkFlow\", {\n      _tokenizer: childFlow,\n      contentType: \"flow\",\n      previous: childToken\n    });\n    return flowContinue(code);\n  }\n\n  /** @type {State} */\n  function flowContinue(code) {\n    if (code === null) {\n      writeToChild(effects.exit(\"chunkFlow\"), true);\n      exitContainers(0);\n      effects.consume(code);\n      return;\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      writeToChild(effects.exit(\"chunkFlow\"));\n      // Get ready for the next line.\n      continued = 0;\n      self.interrupt = undefined;\n      return start;\n    }\n    effects.consume(code);\n    return flowContinue;\n  }\n\n  /**\n   * @param {Token} token\n   *   Token.\n   * @param {boolean | undefined} [endOfFile]\n   *   Whether the token is at the end of the file (default: `false`).\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function writeToChild(token, endOfFile) {\n    const stream = self.sliceStream(token);\n    if (endOfFile) stream.push(null);\n    token.previous = childToken;\n    if (childToken) childToken.next = token;\n    childToken = token;\n    childFlow.defineSkip(token.start);\n    childFlow.write(stream);\n\n    // Alright, so we just added a lazy line:\n    //\n    // ```markdown\n    // > a\n    // b.\n    //\n    // Or:\n    //\n    // > ~~~c\n    // d\n    //\n    // Or:\n    //\n    // > | e |\n    // f\n    // ```\n    //\n    // The construct in the second example (fenced code) does not accept lazy\n    // lines, so it marked itself as done at the end of its first line, and\n    // then the content construct parses `d`.\n    // Most constructs in markdown match on the first line: if the first line\n    // forms a construct, a non-lazy line can’t “unmake” it.\n    //\n    // The construct in the third example is potentially a GFM table, and\n    // those are *weird*.\n    // It *could* be a table, from the first line, if the following line\n    // matches a condition.\n    // In this case, that second line is lazy, which “unmakes” the first line\n    // and turns the whole into one content block.\n    //\n    // We’ve now parsed the non-lazy and the lazy line, and can figure out\n    // whether the lazy line started a new flow block.\n    // If it did, we exit the current containers between the two flow blocks.\n    if (self.parser.lazy[token.start.line]) {\n      let index = childFlow.events.length;\n      while (index--) {\n        if (\n        // The token starts before the line ending…\n        childFlow.events[index][1].start.offset < lineStartOffset && (\n        // …and either is not ended yet…\n        !childFlow.events[index][1].end ||\n        // …or ends after it.\n        childFlow.events[index][1].end.offset > lineStartOffset)) {\n          // Exit: there’s still something open, which means it’s a lazy line\n          // part of something.\n          return;\n        }\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when closing flow in `documentContinue`.\n      const indexBeforeExits = self.events.length;\n      let indexBeforeFlow = indexBeforeExits;\n      /** @type {boolean | undefined} */\n      let seen;\n      /** @type {Point | undefined} */\n      let point;\n\n      // Find the previous chunk (the one before the lazy line).\n      while (indexBeforeFlow--) {\n        if (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === \"chunkFlow\") {\n          if (seen) {\n            point = self.events[indexBeforeFlow][1].end;\n            break;\n          }\n          seen = true;\n        }\n      }\n      exitContainers(continued);\n\n      // Fix positions.\n      index = indexBeforeExits;\n      while (index < self.events.length) {\n        self.events[index][1].end = {\n          ...point\n        };\n        index++;\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));\n\n      // Discard the duplicate exits.\n      self.events.length = index;\n    }\n  }\n\n  /**\n   * @param {number} size\n   *   Size.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function exitContainers(size) {\n    let index = stack.length;\n\n    // Exit open containers.\n    while (index-- > size) {\n      const entry = stack[index];\n      self.containerState = entry[1];\n      entry[0].exit.call(self, effects);\n    }\n    stack.length = size;\n  }\n  function closeFlow() {\n    childFlow.write([null]);\n    childToken = undefined;\n    childFlow = undefined;\n    self.containerState._closeFlow = undefined;\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n *   Tokenizer.\n */\nfunction tokenizeContainer(effects, ok, nok) {\n  // Always populated by defaults.\n\n  return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok, nok), \"linePrefix\", this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4);\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blankLine = {\n  partial: true,\n  tokenize: tokenizeBlankLine\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of blank line.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *     ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    return markdownSpace(code) ? factorySpace(effects, after, \"linePrefix\")(code) : after(code);\n  }\n\n  /**\n   * At eof/eol, after optional whitespace.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *       ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { subtokenize } from 'micromark-util-subtokenize';\n/**\n * No name because it must not be turned off.\n * @type {Construct}\n */\nexport const content = {\n  resolve: resolveContent,\n  tokenize: tokenizeContent\n};\n\n/** @type {Construct} */\nconst continuationConstruct = {\n  partial: true,\n  tokenize: tokenizeContinuation\n};\n\n/**\n * Content is transparent: it’s parsed right now. That way, definitions are also\n * parsed right now: before text in paragraphs (specifically, media) are parsed.\n *\n * @type {Resolver}\n */\nfunction resolveContent(events) {\n  subtokenize(events);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeContent(effects, ok) {\n  /** @type {Token | undefined} */\n  let previous;\n  return chunkStart;\n\n  /**\n   * Before a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkStart(code) {\n    effects.enter(\"content\");\n    previous = effects.enter(\"chunkContent\", {\n      contentType: \"content\"\n    });\n    return chunkInside(code);\n  }\n\n  /**\n   * In a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkInside(code) {\n    if (code === null) {\n      return contentEnd(code);\n    }\n\n    // To do: in `markdown-rs`, each line is parsed on its own, and everything\n    // is stitched together resolving.\n    if (markdownLineEnding(code)) {\n      return effects.check(continuationConstruct, contentContinue, contentEnd)(code);\n    }\n\n    // Data.\n    effects.consume(code);\n    return chunkInside;\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentEnd(code) {\n    effects.exit(\"chunkContent\");\n    effects.exit(\"content\");\n    return ok(code);\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentContinue(code) {\n    effects.consume(code);\n    effects.exit(\"chunkContent\");\n    previous.next = effects.enter(\"chunkContent\", {\n      contentType: \"content\",\n      previous\n    });\n    previous = previous.next;\n    return chunkInside;\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeContinuation(effects, ok, nok) {\n  const self = this;\n  return startLookahead;\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function startLookahead(code) {\n    effects.exit(\"chunkContent\");\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, prefixed, \"linePrefix\");\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    // Always populated by defaults.\n\n    const tail = self.events[self.events.length - 1];\n    if (!self.parser.constructs.disable.null.includes('codeIndented') && tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4) {\n      return ok(code);\n    }\n    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code);\n  }\n}","/**\n * @import {\n *   InitialConstruct,\n *   Initializer,\n *   State,\n *   TokenizeContext\n * } from 'micromark-util-types'\n */\n\nimport { blankLine, content } from 'micromark-core-commonmark';\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {InitialConstruct} */\nexport const flow = {\n  tokenize: initializeFlow\n};\n\n/**\n * @this {TokenizeContext}\n *   Self.\n * @type {Initializer}\n *   Initializer.\n */\nfunction initializeFlow(effects) {\n  const self = this;\n  const initial = effects.attempt(\n  // Try to parse a blank line.\n  blankLine, atBlankEnding,\n  // Try to parse initial flow (essentially, only code).\n  effects.attempt(this.parser.constructs.flowInitial, afterConstruct, factorySpace(effects, effects.attempt(this.parser.constructs.flow, afterConstruct, effects.attempt(content, afterConstruct)), \"linePrefix\")));\n  return initial;\n\n  /** @type {State} */\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEndingBlank\");\n    effects.consume(code);\n    effects.exit(\"lineEndingBlank\");\n    self.currentConstruct = undefined;\n    return initial;\n  }\n\n  /** @type {State} */\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    self.currentConstruct = undefined;\n    return initial;\n  }\n}","/**\n * @import {\n *   Code,\n *   InitialConstruct,\n *   Initializer,\n *   Resolver,\n *   State,\n *   TokenizeContext\n * } from 'micromark-util-types'\n */\n\nexport const resolver = {\n  resolveAll: createResolver()\n};\nexport const string = initializeFactory('string');\nexport const text = initializeFactory('text');\n\n/**\n * @param {'string' | 'text'} field\n *   Field.\n * @returns {InitialConstruct}\n *   Construct.\n */\nfunction initializeFactory(field) {\n  return {\n    resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined),\n    tokenize: initializeText\n  };\n\n  /**\n   * @this {TokenizeContext}\n   *   Context.\n   * @type {Initializer}\n   */\n  function initializeText(effects) {\n    const self = this;\n    const constructs = this.parser.constructs[field];\n    const text = effects.attempt(constructs, start, notText);\n    return start;\n\n    /** @type {State} */\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code);\n    }\n\n    /** @type {State} */\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code);\n        return;\n      }\n      effects.enter(\"data\");\n      effects.consume(code);\n      return data;\n    }\n\n    /** @type {State} */\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit(\"data\");\n        return text(code);\n      }\n\n      // Data.\n      effects.consume(code);\n      return data;\n    }\n\n    /**\n     * @param {Code} code\n     *   Code.\n     * @returns {boolean}\n     *   Whether the code is a break.\n     */\n    function atBreak(code) {\n      if (code === null) {\n        return true;\n      }\n      const list = constructs[code];\n      let index = -1;\n      if (list) {\n        // Always populated by defaults.\n\n        while (++index < list.length) {\n          const item = list[index];\n          if (!item.previous || item.previous.call(self, self.previous)) {\n            return true;\n          }\n        }\n      }\n      return false;\n    }\n  }\n}\n\n/**\n * @param {Resolver | undefined} [extraResolver]\n *   Resolver.\n * @returns {Resolver}\n *   Resolver.\n */\nfunction createResolver(extraResolver) {\n  return resolveAllText;\n\n  /** @type {Resolver} */\n  function resolveAllText(events, context) {\n    let index = -1;\n    /** @type {number | undefined} */\n    let enter;\n\n    // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === \"data\") {\n          enter = index;\n          index++;\n        }\n      } else if (!events[index] || events[index][1].type !== \"data\") {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end;\n          events.splice(enter + 2, index - enter - 2);\n          index = enter + 2;\n        }\n        enter = undefined;\n      }\n    }\n    return extraResolver ? extraResolver(events, context) : events;\n  }\n}\n\n/**\n * A rather ugly set of instructions which again looks at chunks in the input\n * stream.\n * The reason to do this here is that it is *much* faster to parse in reverse.\n * And that we can’t hook into `null` to split the line suffix before an EOF.\n * To do: figure out if we can make this into a clean utility, or even in core.\n * As it will be useful for GFMs literal autolink extension (and maybe even\n * tables?)\n *\n * @type {Resolver}\n */\nfunction resolveAllLineSuffixes(events, context) {\n  let eventIndex = 0; // Skip first.\n\n  while (++eventIndex <= events.length) {\n    if ((eventIndex === events.length || events[eventIndex][1].type === \"lineEnding\") && events[eventIndex - 1][1].type === \"data\") {\n      const data = events[eventIndex - 1][1];\n      const chunks = context.sliceStream(data);\n      let index = chunks.length;\n      let bufferIndex = -1;\n      let size = 0;\n      /** @type {boolean | undefined} */\n      let tabs;\n      while (index--) {\n        const chunk = chunks[index];\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length;\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++;\n            bufferIndex--;\n          }\n          if (bufferIndex) break;\n          bufferIndex = -1;\n        }\n        // Number\n        else if (chunk === -2) {\n          tabs = true;\n          size++;\n        } else if (chunk === -1) {\n          // Empty\n        } else {\n          // Replacement character, exit.\n          index++;\n          break;\n        }\n      }\n      if (size) {\n        const token = {\n          type: eventIndex === events.length || tabs || size < 2 ? \"lineSuffix\" : \"hardBreakTrailing\",\n          start: {\n            _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex,\n            _index: data.start._index + index,\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size\n          },\n          end: {\n            ...data.end\n          }\n        };\n        data.end = {\n          ...token.start\n        };\n        if (data.start.offset === data.end.offset) {\n          Object.assign(data, token);\n        } else {\n          events.splice(eventIndex, 0, ['enter', token, context], ['exit', token, context]);\n          eventIndex += 2;\n        }\n      }\n      eventIndex++;\n    }\n  }\n  return events;\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  let size = 0;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of thematic break.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"thematicBreak\");\n    // To do: parse indent like `markdown-rs`.\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at marker.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    marker = code;\n    return atBreak(code);\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter(\"thematicBreakSequence\");\n      return sequence(code);\n    }\n    if (size >= 3 && (code === null || markdownLineEnding(code))) {\n      effects.exit(\"thematicBreak\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      size++;\n      return sequence;\n    }\n    effects.exit(\"thematicBreakSequence\");\n    return markdownSpace(code) ? factorySpace(effects, atBreak, \"whitespace\")(code) : atBreak(code);\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   Exiter,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { asciiDigit, markdownSpace } from 'micromark-util-character';\nimport { blankLine } from './blank-line.js';\nimport { thematicBreak } from './thematic-break.js';\n\n/** @type {Construct} */\nexport const list = {\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd,\n  name: 'list',\n  tokenize: tokenizeListStart\n};\n\n/** @type {Construct} */\nconst listItemPrefixWhitespaceConstruct = {\n  partial: true,\n  tokenize: tokenizeListItemPrefixWhitespace\n};\n\n/** @type {Construct} */\nconst indentConstruct = {\n  partial: true,\n  tokenize: tokenizeIndent\n};\n\n// To do: `markdown-rs` parses list items on their own and later stitches them\n// together.\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeListStart(effects, ok, nok) {\n  const self = this;\n  const tail = self.events[self.events.length - 1];\n  let initialSize = tail && tail[1].type === \"linePrefix\" ? tail[2].sliceSerialize(tail[1], true).length : 0;\n  let size = 0;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    const kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? \"listUnordered\" : \"listOrdered\");\n    if (kind === \"listUnordered\" ? !self.containerState.marker || code === self.containerState.marker : asciiDigit(code)) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind;\n        effects.enter(kind, {\n          _container: true\n        });\n      }\n      if (kind === \"listUnordered\") {\n        effects.enter(\"listItemPrefix\");\n        return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code);\n      }\n      if (!self.interrupt || code === 49) {\n        effects.enter(\"listItemPrefix\");\n        effects.enter(\"listItemValue\");\n        return inside(code);\n      }\n    }\n    return nok(code);\n  }\n\n  /** @type {State} */\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code);\n      return inside;\n    }\n    if ((!self.interrupt || size < 2) && (self.containerState.marker ? code === self.containerState.marker : code === 41 || code === 46)) {\n      effects.exit(\"listItemValue\");\n      return atMarker(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * @type {State}\n   **/\n  function atMarker(code) {\n    effects.enter(\"listItemMarker\");\n    effects.consume(code);\n    effects.exit(\"listItemMarker\");\n    self.containerState.marker = self.containerState.marker || code;\n    return effects.check(blankLine,\n    // Can’t be empty when interrupting.\n    self.interrupt ? nok : onBlank, effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix));\n  }\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true;\n    initialSize++;\n    return endOfPrefix(code);\n  }\n\n  /** @type {State} */\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter(\"listItemPrefixWhitespace\");\n      effects.consume(code);\n      effects.exit(\"listItemPrefixWhitespace\");\n      return endOfPrefix;\n    }\n    return nok(code);\n  }\n\n  /** @type {State} */\n  function endOfPrefix(code) {\n    self.containerState.size = initialSize + self.sliceSerialize(effects.exit(\"listItemPrefix\"), true).length;\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeListContinuation(effects, ok, nok) {\n  const self = this;\n  self.containerState._closeFlow = undefined;\n  return effects.check(blankLine, onBlank, notBlank);\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.furtherBlankLines = self.containerState.furtherBlankLines || self.containerState.initialBlankLine;\n\n    // We have a blank line.\n    // Still, try to consume at most the items size.\n    return factorySpace(effects, ok, \"listItemIndent\", self.containerState.size + 1)(code);\n  }\n\n  /** @type {State} */\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = undefined;\n      self.containerState.initialBlankLine = undefined;\n      return notInCurrentItem(code);\n    }\n    self.containerState.furtherBlankLines = undefined;\n    self.containerState.initialBlankLine = undefined;\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code);\n  }\n\n  /** @type {State} */\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true;\n    // As we’re closing flow, we’re no longer interrupting.\n    self.interrupt = undefined;\n    // Always populated by defaults.\n\n    return factorySpace(effects, effects.attempt(list, ok, nok), \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this;\n  return factorySpace(effects, afterPrefix, \"listItemIndent\", self.containerState.size + 1);\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"listItemIndent\" && tail[2].sliceSerialize(tail[1], true).length === self.containerState.size ? ok(code) : nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Exiter}\n */\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type);\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  const self = this;\n\n  // Always populated by defaults.\n\n  return factorySpace(effects, afterPrefix, \"listItemPrefixWhitespace\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4 + 1);\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return !markdownSpace(code) && tail && tail[1].type === \"listItemPrefixWhitespace\" ? ok(code) : nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   Exiter,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blockQuote = {\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit,\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of block quote.\n   *\n   * ```markdown\n   * > | > a\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 62) {\n      const state = self.containerState;\n      if (!state.open) {\n        effects.enter(\"blockQuote\", {\n          _container: true\n        });\n        state.open = true;\n      }\n      effects.enter(\"blockQuotePrefix\");\n      effects.enter(\"blockQuoteMarker\");\n      effects.consume(code);\n      effects.exit(\"blockQuoteMarker\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `>`, before optional whitespace.\n   *\n   * ```markdown\n   * > | > a\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter(\"blockQuotePrefixWhitespace\");\n      effects.consume(code);\n      effects.exit(\"blockQuotePrefixWhitespace\");\n      effects.exit(\"blockQuotePrefix\");\n      return ok;\n    }\n    effects.exit(\"blockQuotePrefix\");\n    return ok(code);\n  }\n}\n\n/**\n * Start of block quote continuation.\n *\n * ```markdown\n *   | > a\n * > | > b\n *     ^\n * ```\n *\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  const self = this;\n  return contStart;\n\n  /**\n   * Start of block quote continuation.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contStart(code) {\n    if (markdownSpace(code)) {\n      // Always populated by defaults.\n\n      return factorySpace(effects, contBefore, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n    }\n    return contBefore(code);\n  }\n\n  /**\n   * At `>`, after optional whitespace.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contBefore(code) {\n    return effects.attempt(blockQuote, ok, nok)(code);\n  }\n}\n\n/** @type {Exiter} */\nfunction exit(effects) {\n  effects.exit(\"blockQuote\");\n}","/**\n * @import {Effects, State, TokenType} from 'micromark-util-types'\n */\n\nimport { asciiControl, markdownLineEndingOrSpace, markdownLineEnding } from 'micromark-util-character';\n/**\n * Parse destinations.\n *\n * ###### Examples\n *\n * ```markdown\n * <a>\n * <a\\>b>\n * <a b>\n * <a)>\n * a\n * a\\)b\n * a(b)c\n * a(b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type for whole (`<a>` or `b`).\n * @param {TokenType} literalType\n *   Type when enclosed (`<a>`).\n * @param {TokenType} literalMarkerType\n *   Type for enclosing (`<` and `>`).\n * @param {TokenType} rawType\n *   Type when not enclosed (`b`).\n * @param {TokenType} stringType\n *   Type for the value (`a` or `b`).\n * @param {number | undefined} [max=Infinity]\n *   Depth of nested parens (inclusive).\n * @returns {State}\n *   Start state.\n */\nexport function factoryDestination(effects, ok, nok, type, literalType, literalMarkerType, rawType, stringType, max) {\n  const limit = max || Number.POSITIVE_INFINITY;\n  let balance = 0;\n  return start;\n\n  /**\n   * Start of destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *     ^\n   * > | aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type);\n      effects.enter(literalType);\n      effects.enter(literalMarkerType);\n      effects.consume(code);\n      effects.exit(literalMarkerType);\n      return enclosedBefore;\n    }\n\n    // ASCII control, space, closing paren.\n    if (code === null || code === 32 || code === 41 || asciiControl(code)) {\n      return nok(code);\n    }\n    effects.enter(type);\n    effects.enter(rawType);\n    effects.enter(stringType);\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return raw(code);\n  }\n\n  /**\n   * After `<`, at an enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType);\n      effects.consume(code);\n      effects.exit(literalMarkerType);\n      effects.exit(literalType);\n      effects.exit(type);\n      return ok;\n    }\n    effects.enter(stringType);\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return enclosed(code);\n  }\n\n  /**\n   * In enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosed(code) {\n    if (code === 62) {\n      effects.exit(\"chunkString\");\n      effects.exit(stringType);\n      return enclosedBefore(code);\n    }\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return code === 92 ? enclosedEscape : enclosed;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | <a\\*a>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code);\n      return enclosed;\n    }\n    return enclosed(code);\n  }\n\n  /**\n   * In raw destination.\n   *\n   * ```markdown\n   * > | aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function raw(code) {\n    if (!balance && (code === null || code === 41 || markdownLineEndingOrSpace(code))) {\n      effects.exit(\"chunkString\");\n      effects.exit(stringType);\n      effects.exit(rawType);\n      effects.exit(type);\n      return ok(code);\n    }\n    if (balance < limit && code === 40) {\n      effects.consume(code);\n      balance++;\n      return raw;\n    }\n    if (code === 41) {\n      effects.consume(code);\n      balance--;\n      return raw;\n    }\n\n    // ASCII control (but *not* `\\0`) and space and `(`.\n    // Note: in `markdown-rs`, `\\0` exists in codes, in `micromark-js` it\n    // doesn’t.\n    if (code === null || code === 32 || code === 40 || asciiControl(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return code === 92 ? rawEscape : raw;\n  }\n\n  /**\n   * After `\\`, at special character.\n   *\n   * ```markdown\n   * > | a\\*a\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function rawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code);\n      return raw;\n    }\n    return raw(code);\n  }\n}","/**\n * @import {\n *   Effects,\n *   State,\n *   TokenizeContext,\n *   TokenType\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/**\n * Parse labels.\n *\n * > 👉 **Note**: labels in markdown are capped at 999 characters in the string.\n *\n * ###### Examples\n *\n * ```markdown\n * [a]\n * [a\n * b]\n * [a\\]b]\n * ```\n *\n * @this {TokenizeContext}\n *   Tokenize context.\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole label (`[a]`).\n * @param {TokenType} markerType\n *   Type for the markers (`[` and `]`).\n * @param {TokenType} stringType\n *   Type for the identifier (`a`).\n * @returns {State}\n *   Start state.\n */\nexport function factoryLabel(effects, ok, nok, type, markerType, stringType) {\n  const self = this;\n  let size = 0;\n  /** @type {boolean} */\n  let seen;\n  return start;\n\n  /**\n   * Start of label.\n   *\n   * ```markdown\n   * > | [a]\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(type);\n    effects.enter(markerType);\n    effects.consume(code);\n    effects.exit(markerType);\n    effects.enter(stringType);\n    return atBreak;\n  }\n\n  /**\n   * In label, at something, before something else.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (size > 999 || code === null || code === 91 || code === 93 && !seen ||\n    // To do: remove in the future once we’ve switched from\n    // `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n    // which doesn’t need this.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    code === 94 && !size && '_hiddenFootnoteSupport' in self.parser.constructs) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.exit(stringType);\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n\n    // To do: indent? Link chunks and EOLs together?\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return atBreak;\n    }\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return labelInside(code);\n  }\n\n  /**\n   * In label, in text.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelInside(code) {\n    if (code === null || code === 91 || code === 93 || markdownLineEnding(code) || size++ > 999) {\n      effects.exit(\"chunkString\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    if (!seen) seen = !markdownSpace(code);\n    return code === 92 ? labelEscape : labelInside;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | [a\\*a]\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return labelInside;\n    }\n    return labelInside(code);\n  }\n}","/**\n * @import {\n *   Code,\n *   Effects,\n *   State,\n *   TokenType\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/**\n * Parse titles.\n *\n * ###### Examples\n *\n * ```markdown\n * \"a\"\n * 'b'\n * (c)\n * \"a\n * b\"\n * 'a\n *     b'\n * (a\\)b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole title (`\"a\"`, `'b'`, `(c)`).\n * @param {TokenType} markerType\n *   Type for the markers (`\"`, `'`, `(`, and `)`).\n * @param {TokenType} stringType\n *   Type for the value (`a`).\n * @returns {State}\n *   Start state.\n */\nexport function factoryTitle(effects, ok, nok, type, markerType, stringType) {\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of title.\n   *\n   * ```markdown\n   * > | \"a\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      effects.enter(type);\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      marker = code === 40 ? 41 : code;\n      return begin;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After opening marker.\n   *\n   * This is also used at the closing marker.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function begin(code) {\n    if (code === marker) {\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n    effects.enter(stringType);\n    return atBreak(code);\n  }\n\n  /**\n   * At something, before something else.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType);\n      return begin(marker);\n    }\n    if (code === null) {\n      return nok(code);\n    }\n\n    // Note: blank lines can’t exist in content.\n    if (markdownLineEnding(code)) {\n      // To do: use `space_or_tab_eol_with_options`, connect.\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return factorySpace(effects, atBreak, \"linePrefix\");\n    }\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return inside(code);\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return code === 92 ? escape : inside;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | \"a\\*b\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function escape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code);\n      return inside;\n    }\n    return inside(code);\n  }\n}","/**\n * @import {Effects, State} from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   line endings or spaces in markdown are often optional, in which case this\n *     factory can be used and `ok` will be switched to whether spaces were found\n *     or not\n * *   one line ending or space can be detected with\n *     `markdownLineEndingOrSpace(code)` right before using `factoryWhitespace`\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @returns {State}\n *   Start state.\n */\nexport function factoryWhitespace(effects, ok) {\n  /** @type {boolean} */\n  let seen;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      seen = true;\n      return start;\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, start, seen ? \"linePrefix\" : \"lineSuffix\")(code);\n    }\n    return ok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factoryDestination } from 'micromark-factory-destination';\nimport { factoryLabel } from 'micromark-factory-label';\nimport { factorySpace } from 'micromark-factory-space';\nimport { factoryTitle } from 'micromark-factory-title';\nimport { factoryWhitespace } from 'micromark-factory-whitespace';\nimport { markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\n/** @type {Construct} */\nexport const definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n};\n\n/** @type {Construct} */\nconst titleBefore = {\n  partial: true,\n  tokenize: tokenizeTitleBefore\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeDefinition(effects, ok, nok) {\n  const self = this;\n  /** @type {string} */\n  let identifier;\n  return start;\n\n  /**\n   * At start of a definition.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // Do not interrupt paragraphs (but do follow definitions).\n    // To do: do `interrupt` the way `markdown-rs` does.\n    // To do: parse whitespace the way `markdown-rs` does.\n    effects.enter(\"definition\");\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at `[`.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    // To do: parse whitespace the way `markdown-rs` does.\n\n    return factoryLabel.call(self, effects, labelAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionLabel\", \"definitionLabelMarker\", \"definitionLabelString\")(code);\n  }\n\n  /**\n   * After label.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));\n    if (code === 58) {\n      effects.enter(\"definitionMarker\");\n      effects.consume(code);\n      effects.exit(\"definitionMarker\");\n      return markerAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After marker.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function markerAfter(code) {\n    // Note: whitespace is optional.\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, destinationBefore)(code) : destinationBefore(code);\n  }\n\n  /**\n   * Before destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationBefore(code) {\n    return factoryDestination(effects, destinationAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionDestination\", \"definitionDestinationLiteral\", \"definitionDestinationLiteralMarker\", \"definitionDestinationRaw\", \"definitionDestinationString\")(code);\n  }\n\n  /**\n   * After destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationAfter(code) {\n    return effects.attempt(titleBefore, after, after)(code);\n  }\n\n  /**\n   * After definition.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return markdownSpace(code) ? factorySpace(effects, afterWhitespace, \"whitespace\")(code) : afterWhitespace(code);\n  }\n\n  /**\n   * After definition, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterWhitespace(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"definition\");\n\n      // Note: we don’t care about uniqueness.\n      // It’s likely that that doesn’t happen very frequently.\n      // It is more likely that it wastes precious time.\n      self.parser.defined.push(identifier);\n\n      // To do: `markdown-rs` interrupt.\n      // // You’d be interrupting.\n      // tokenizer.interrupt = true\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeTitleBefore(effects, ok, nok) {\n  return titleBefore;\n\n  /**\n   * After destination, at whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleBefore(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, beforeMarker)(code) : nok(code);\n  }\n\n  /**\n   * At title.\n   *\n   * ```markdown\n   *   | [a]: b\n   * > | \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeMarker(code) {\n    return factoryTitle(effects, titleAfter, nok, \"definitionTitle\", \"definitionTitleMarker\", \"definitionTitleString\")(code);\n  }\n\n  /**\n   * After title.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfter(code) {\n    return markdownSpace(code) ? factorySpace(effects, titleAfterOptionalWhitespace, \"whitespace\")(code) : titleAfterOptionalWhitespace(code);\n  }\n\n  /**\n   * After title, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfterOptionalWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented\n};\n\n/** @type {Construct} */\nconst furtherStart = {\n  partial: true,\n  tokenize: tokenizeFurtherStart\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of code (indented).\n   *\n   * > **Parsing note**: it is not needed to check if this first line is a\n   * > filled line (that it has a non-whitespace character), because blank lines\n   * > are parsed already, so we never run into that.\n   *\n   * ```markdown\n   * > |     aaa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: manually check if interrupting like `markdown-rs`.\n\n    effects.enter(\"codeIndented\");\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, \"linePrefix\", 4 + 1)(code);\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? atBreak(code) : nok(code);\n  }\n\n  /**\n   * At a break.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === null) {\n      return after(code);\n    }\n    if (markdownLineEnding(code)) {\n      return effects.attempt(furtherStart, atBreak, after)(code);\n    }\n    effects.enter(\"codeFlowValue\");\n    return inside(code);\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFlowValue\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return inside;\n  }\n\n  /** @type {State} */\n  function after(code) {\n    effects.exit(\"codeIndented\");\n    // To do: allow interrupting like `markdown-rs`.\n    // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeFurtherStart(effects, ok, nok) {\n  const self = this;\n  return furtherStart;\n\n  /**\n   * At eol, trying to parse another indent.\n   *\n   * ```markdown\n   * > |     aaa\n   *            ^\n   *   |     bbb\n   * ```\n   *\n   * @type {State}\n   */\n  function furtherStart(code) {\n    // To do: improve `lazy` / `pierce` handling.\n    // If this is a lazy line, it can’t be code.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return furtherStart;\n    }\n\n    // To do: the code here in `micromark-js` is a bit different from\n    // `markdown-rs` because there it can attempt spaces.\n    // We can’t yet.\n    //\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, \"linePrefix\", 4 + 1)(code);\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? ok(code) : markdownLineEnding(code) ? furtherStart(code) : nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { splice } from 'micromark-util-chunked';\n/** @type {Construct} */\nexport const headingAtx = {\n  name: 'headingAtx',\n  resolve: resolveHeadingAtx,\n  tokenize: tokenizeHeadingAtx\n};\n\n/** @type {Resolver} */\nfunction resolveHeadingAtx(events, context) {\n  let contentEnd = events.length - 2;\n  let contentStart = 3;\n  /** @type {Token} */\n  let content;\n  /** @type {Token} */\n  let text;\n\n  // Prefix whitespace, part of the opening.\n  if (events[contentStart][1].type === \"whitespace\") {\n    contentStart += 2;\n  }\n\n  // Suffix whitespace, part of the closing.\n  if (contentEnd - 2 > contentStart && events[contentEnd][1].type === \"whitespace\") {\n    contentEnd -= 2;\n  }\n  if (events[contentEnd][1].type === \"atxHeadingSequence\" && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === \"whitespace\")) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;\n  }\n  if (contentEnd > contentStart) {\n    content = {\n      type: \"atxHeadingText\",\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end\n    };\n    text = {\n      type: \"chunkText\",\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end,\n      contentType: \"text\"\n    };\n    splice(events, contentStart, contentEnd - contentStart + 1, [['enter', content, context], ['enter', text, context], ['exit', text, context], ['exit', content, context]]);\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  let size = 0;\n  return start;\n\n  /**\n   * Start of a heading (atx).\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    effects.enter(\"atxHeading\");\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at `#`.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"atxHeadingSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code);\n      return sequenceOpen;\n    }\n\n    // Always at least one `#`.\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"atxHeadingSequence\");\n      return atBreak(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ## aa\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === 35) {\n      effects.enter(\"atxHeadingSequence\");\n      return sequenceFurther(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"atxHeading\");\n      // To do: interrupt like `markdown-rs`.\n      // // Feel free to interrupt.\n      // tokenizer.interrupt = false\n      return ok(code);\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, \"whitespace\")(code);\n    }\n\n    // To do: generate `data` tokens, add the `text` token later.\n    // Needs edit map, see: `markdown.rs`.\n    effects.enter(\"atxHeadingText\");\n    return data(code);\n  }\n\n  /**\n   * In further sequence (after whitespace).\n   *\n   * Could be normal “visible” hashes in the heading or a final sequence.\n   *\n   * ```markdown\n   * > | ## aa ##\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceFurther(code) {\n    if (code === 35) {\n      effects.consume(code);\n      return sequenceFurther;\n    }\n    effects.exit(\"atxHeadingSequence\");\n    return atBreak(code);\n  }\n\n  /**\n   * In text.\n   *\n   * ```markdown\n   * > | ## aa\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"atxHeadingText\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const setextUnderline = {\n  name: 'setextUnderline',\n  resolveTo: resolveToSetextUnderline,\n  tokenize: tokenizeSetextUnderline\n};\n\n/** @type {Resolver} */\nfunction resolveToSetextUnderline(events, context) {\n  // To do: resolve like `markdown-rs`.\n  let index = events.length;\n  /** @type {number | undefined} */\n  let content;\n  /** @type {number | undefined} */\n  let text;\n  /** @type {number | undefined} */\n  let definition;\n\n  // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === \"content\") {\n        content = index;\n        break;\n      }\n      if (events[index][1].type === \"paragraph\") {\n        text = index;\n      }\n    }\n    // Exit\n    else {\n      if (events[index][1].type === \"content\") {\n        // Remove the content end (if needed we’ll add it later)\n        events.splice(index, 1);\n      }\n      if (!definition && events[index][1].type === \"definition\") {\n        definition = index;\n      }\n    }\n  }\n  const heading = {\n    type: \"setextHeading\",\n    start: {\n      ...events[text][1].start\n    },\n    end: {\n      ...events[events.length - 1][1].end\n    }\n  };\n\n  // Change the paragraph to setext heading text.\n  events[text][1].type = \"setextHeadingText\";\n\n  // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context]);\n    events.splice(definition + 1, 0, ['exit', events[content][1], context]);\n    events[content][1].end = {\n      ...events[definition][1].end\n    };\n  } else {\n    events[content][1] = heading;\n  }\n\n  // Add the heading exit at the end.\n  events.push(['exit', heading, context]);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  const self = this;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * At start of heading (setext) underline.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    let index = self.events.length;\n    /** @type {boolean | undefined} */\n    let paragraph;\n    // Find an opening.\n    while (index--) {\n      // Skip enter/exit of line ending, line prefix, and content.\n      // We can now either have a definition or a paragraph.\n      if (self.events[index][1].type !== \"lineEnding\" && self.events[index][1].type !== \"linePrefix\" && self.events[index][1].type !== \"content\") {\n        paragraph = self.events[index][1].type === \"paragraph\";\n        break;\n      }\n    }\n\n    // To do: handle lazy/pierce like `markdown-rs`.\n    // To do: parse indent like `markdown-rs`.\n    if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {\n      effects.enter(\"setextHeadingLine\");\n      marker = code;\n      return before(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * After optional whitespace, at `-` or `=`.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"setextHeadingLineSequence\");\n    return inside(code);\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return inside;\n    }\n    effects.exit(\"setextHeadingLineSequence\");\n    return markdownSpace(code) ? factorySpace(effects, after, \"lineSuffix\")(code) : after(code);\n  }\n\n  /**\n   * After sequence, after optional whitespace.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"setextHeadingLine\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n}","/**\n * List of lowercase HTML “block” tag names.\n *\n * The list, when parsing HTML (flow), results in more relaxed rules (condition\n * 6).\n * Because they are known blocks, the HTML-like syntax doesn’t have to be\n * strictly parsed.\n * For tag names not in this list, a more strict algorithm (condition 7) is used\n * to detect whether the HTML-like syntax is seen as HTML (flow) or not.\n *\n * This is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `search` was added in `CommonMark@0.31`.\n */\nexport const htmlBlockNames = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'search',\n  'section',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n]\n\n/**\n * List of lowercase HTML “raw” tag names.\n *\n * The list, when parsing HTML (flow), results in HTML that can include lines\n * without exiting, until a closing tag also in this list is found (condition\n * 1).\n *\n * This module is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `textarea` was added in `CommonMark@0.30`.\n */\nexport const htmlRawNames = ['pre', 'script', 'style', 'textarea']\n","/**\n * @import {\n *   Code,\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiAlphanumeric, asciiAlpha, markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { htmlBlockNames, htmlRawNames } from 'micromark-util-html-tag-name';\nimport { blankLine } from './blank-line.js';\n\n/** @type {Construct} */\nexport const htmlFlow = {\n  concrete: true,\n  name: 'htmlFlow',\n  resolveTo: resolveToHtmlFlow,\n  tokenize: tokenizeHtmlFlow\n};\n\n/** @type {Construct} */\nconst blankLineBefore = {\n  partial: true,\n  tokenize: tokenizeBlankLineBefore\n};\nconst nonLazyContinuationStart = {\n  partial: true,\n  tokenize: tokenizeNonLazyContinuationStart\n};\n\n/** @type {Resolver} */\nfunction resolveToHtmlFlow(events) {\n  let index = events.length;\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === \"htmlFlow\") {\n      break;\n    }\n  }\n  if (index > 1 && events[index - 2][1].type === \"linePrefix\") {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start;\n    // Add the prefix start to the HTML line token.\n    events[index + 1][1].start = events[index - 2][1].start;\n    // Remove the line prefix.\n    events.splice(index - 2, 2);\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  const self = this;\n  /** @type {number} */\n  let marker;\n  /** @type {boolean} */\n  let closingTag;\n  /** @type {string} */\n  let buffer;\n  /** @type {number} */\n  let index;\n  /** @type {Code} */\n  let markerB;\n  return start;\n\n  /**\n   * Start of HTML (flow).\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    return before(code);\n  }\n\n  /**\n   * At `<`, after optional whitespace.\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"htmlFlow\");\n    effects.enter(\"htmlFlowData\");\n    effects.consume(code);\n    return open;\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | <x />\n   *      ^\n   * > | <!doctype>\n   *      ^\n   * > | <!--xxx-->\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      closingTag = true;\n      return tagCloseStart;\n    }\n    if (code === 63) {\n      effects.consume(code);\n      marker = 3;\n      // To do:\n      // tokenizer.concrete = true\n      // To do: use `markdown-rs` style interrupt.\n      // While we’re in an instruction instead of a declaration, we’re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      // Always the case.\n      effects.consume(code);\n      buffer = String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *       ^\n   * > | <!--xxx-->\n   *       ^\n   * > | <![CDATA[>&<]]>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      marker = 2;\n      return commentOpenInside;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      marker = 5;\n      index = 0;\n      return cdataOpenInside;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      marker = 4;\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!-`, inside a comment, at another `-`.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<![`, inside CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *        ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = \"CDATA[\";\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code);\n      if (index === value.length) {\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok : continuation;\n      }\n      return cdataOpenInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | </x>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      // Always the case.\n      effects.consume(code);\n      buffer = String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In tag name.\n   *\n   * ```markdown\n   * > | <ab>\n   *      ^^\n   * > | </ab>\n   *       ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagName(code) {\n    if (code === null || code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      const slash = code === 47;\n      const name = buffer.toLowerCase();\n      if (!slash && !closingTag && htmlRawNames.includes(name)) {\n        marker = 1;\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n      if (htmlBlockNames.includes(buffer.toLowerCase())) {\n        marker = 6;\n        if (slash) {\n          effects.consume(code);\n          return basicSelfClosing;\n        }\n\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n      marker = 7;\n      // Do not support complete HTML when interrupting.\n      return self.interrupt && !self.parser.lazy[self.now().line] ? nok(code) : closingTag ? completeClosingTagAfter(code) : completeAttributeNameBefore(code);\n    }\n\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      buffer += String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After closing slash of a basic tag name.\n   *\n   * ```markdown\n   * > | <div/>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code);\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuation;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After closing slash of a complete tag name.\n   *\n   * ```markdown\n   * > | <x/>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeClosingTagAfter;\n    }\n    return completeEnd(code);\n  }\n\n  /**\n   * At an attribute name.\n   *\n   * At first, this state is used after a complete tag name, after whitespace,\n   * where it expects optional attributes or the end of the tag.\n   * It is also reused after attributes, when expecting more optional\n   * attributes.\n   *\n   * ```markdown\n   * > | <a />\n   *        ^\n   * > | <a :b>\n   *        ^\n   * > | <a _b>\n   *        ^\n   * > | <a b>\n   *        ^\n   * > | <a >\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return completeEnd;\n    }\n\n    // ASCII alphanumerical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameBefore;\n    }\n    return completeEnd(code);\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | <a :b>\n   *         ^\n   * > | <a _b>\n   *         ^\n   * > | <a b>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeName(code) {\n    // ASCII alphanumerical and `-`, `.`, `:`, and `_`.\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n    return completeAttributeNameAfter(code);\n  }\n\n  /**\n   * After attribute name, at an optional initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b>\n   *         ^\n   * > | <a b=c>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameAfter;\n    }\n    return completeAttributeNameBefore(code);\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * > | <a b=\"c\">\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      markerB = code;\n      return completeAttributeValueQuoted;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    return completeAttributeValueUnquoted(code);\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *           ^\n   * > | <a b='c'>\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuoted(code) {\n    if (code === markerB) {\n      effects.consume(code);\n      markerB = null;\n      return completeAttributeValueQuotedAfter;\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return completeAttributeValueQuoted;\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 47 || code === 60 || code === 61 || code === 62 || code === 96 || markdownLineEndingOrSpace(code)) {\n      return completeAttributeNameAfter(code);\n    }\n    effects.consume(code);\n    return completeAttributeValueUnquoted;\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the\n   * end of the tag.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In certain circumstances of a complete tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `>` in a complete tag.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return continuation(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In continuation of any HTML kind.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuation(code) {\n    if (code === 45 && marker === 2) {\n      effects.consume(code);\n      return continuationCommentInside;\n    }\n    if (code === 60 && marker === 1) {\n      effects.consume(code);\n      return continuationRawTagOpen;\n    }\n    if (code === 62 && marker === 4) {\n      effects.consume(code);\n      return continuationClose;\n    }\n    if (code === 63 && marker === 3) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    if (code === 93 && marker === 5) {\n      effects.consume(code);\n      return continuationCdataInside;\n    }\n    if (markdownLineEnding(code) && (marker === 6 || marker === 7)) {\n      effects.exit(\"htmlFlowData\");\n      return effects.check(blankLineBefore, continuationAfter, continuationStart)(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"htmlFlowData\");\n      return continuationStart(code);\n    }\n    effects.consume(code);\n    return continuation;\n  }\n\n  /**\n   * In continuation, at eol.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStart(code) {\n    return effects.check(nonLazyContinuationStart, continuationStartNonLazy, continuationAfter)(code);\n  }\n\n  /**\n   * In continuation, at eol, before non-lazy content.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStartNonLazy(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return continuationBefore;\n  }\n\n  /**\n   * In continuation, before non-lazy content.\n   *\n   * ```markdown\n   *   | <x>\n   * > | asd\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return continuationStart(code);\n    }\n    effects.enter(\"htmlFlowData\");\n    return continuation(code);\n  }\n\n  /**\n   * In comment continuation, after one `-`, expecting another.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In raw continuation, after `<`, at `/`.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code);\n      buffer = '';\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In raw continuation, after `</`, in a raw tag name.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                             ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawEndTag(code) {\n    if (code === 62) {\n      const name = buffer.toLowerCase();\n      if (htmlRawNames.includes(name)) {\n        effects.consume(code);\n        return continuationClose;\n      }\n      return continuation(code);\n    }\n    if (asciiAlpha(code) && buffer.length < 8) {\n      // Always the case.\n      effects.consume(code);\n      buffer += String.fromCharCode(code);\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In cdata continuation, after `]`, expecting `]>`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *                  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCdataInside(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In declaration or instruction continuation, at `>`.\n   *\n   * ```markdown\n   * > | <!-->\n   *         ^\n   * > | <?>\n   *       ^\n   * > | <!q>\n   *        ^\n   * > | <!--ab-->\n   *             ^\n   * > | <![CDATA[>&<]]>\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    // More dashes.\n    if (code === 45 && marker === 2) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In closed continuation: everything we get until the eol/eof is part of it.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"htmlFlowData\");\n      return continuationAfter(code);\n    }\n    effects.consume(code);\n    return continuationClose;\n  }\n\n  /**\n   * Done.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationAfter(code) {\n    effects.exit(\"htmlFlow\");\n    // // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    // // No longer concrete.\n    // tokenizer.concrete = false\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuationStart(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * At eol, before continuation.\n   *\n   * ```markdown\n   * > | * ```js\n   *            ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * A continuation.\n   *\n   * ```markdown\n   *   | * ```js\n   * > | b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLineBefore(effects, ok, nok) {\n  return start;\n\n  /**\n   * Before eol, expecting blank line.\n   *\n   * ```markdown\n   * > | <div>\n   *          ^\n   *   |\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return effects.attempt(blankLine, ok, nok);\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nconst nonLazyContinuation = {\n  partial: true,\n  tokenize: tokenizeNonLazyContinuation\n};\n\n/** @type {Construct} */\nexport const codeFenced = {\n  concrete: true,\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  const self = this;\n  /** @type {Construct} */\n  const closeStart = {\n    partial: true,\n    tokenize: tokenizeCloseStart\n  };\n  let initialPrefix = 0;\n  let sizeOpen = 0;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of code.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse whitespace like `markdown-rs`.\n    return beforeSequenceOpen(code);\n  }\n\n  /**\n   * In opening fence, after prefix, at sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeSequenceOpen(code) {\n    const tail = self.events[self.events.length - 1];\n    initialPrefix = tail && tail[1].type === \"linePrefix\" ? tail[2].sliceSerialize(tail[1], true).length : 0;\n    marker = code;\n    effects.enter(\"codeFenced\");\n    effects.enter(\"codeFencedFence\");\n    effects.enter(\"codeFencedFenceSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening fence sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *      ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === marker) {\n      sizeOpen++;\n      effects.consume(code);\n      return sequenceOpen;\n    }\n    if (sizeOpen < 3) {\n      return nok(code);\n    }\n    effects.exit(\"codeFencedFenceSequence\");\n    return markdownSpace(code) ? factorySpace(effects, infoBefore, \"whitespace\")(code) : infoBefore(code);\n  }\n\n  /**\n   * In opening fence, after the sequence (and optional whitespace), before info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function infoBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFencedFence\");\n      return self.interrupt ? ok(code) : effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);\n    }\n    effects.enter(\"codeFencedFenceInfo\");\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return info(code);\n  }\n\n  /**\n   * In info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function info(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceInfo\");\n      return infoBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceInfo\");\n      return factorySpace(effects, metaBefore, \"whitespace\")(code);\n    }\n    if (code === 96 && code === marker) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return info;\n  }\n\n  /**\n   * In opening fence, after info and whitespace, before meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function metaBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return infoBefore(code);\n    }\n    effects.enter(\"codeFencedFenceMeta\");\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return meta(code);\n  }\n\n  /**\n   * In meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceMeta\");\n      return infoBefore(code);\n    }\n    if (code === 96 && code === marker) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return meta;\n  }\n\n  /**\n   * At eol/eof in code, before a non-lazy closing fence or content.\n   *\n   * ```markdown\n   * > | ~~~js\n   *          ^\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function atNonLazyBreak(code) {\n    return effects.attempt(closeStart, after, contentBefore)(code);\n  }\n\n  /**\n   * Before code content, not a closing fence, at eol.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentBefore(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return contentStart;\n  }\n\n  /**\n   * Before code content, not a closing fence.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentStart(code) {\n    return initialPrefix > 0 && markdownSpace(code) ? factorySpace(effects, beforeContentChunk, \"linePrefix\", initialPrefix + 1)(code) : beforeContentChunk(code);\n  }\n\n  /**\n   * Before code content, after optional prefix.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeContentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);\n    }\n    effects.enter(\"codeFlowValue\");\n    return contentChunk(code);\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^^^^^^^^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFlowValue\");\n      return beforeContentChunk(code);\n    }\n    effects.consume(code);\n    return contentChunk;\n  }\n\n  /**\n   * After code.\n   *\n   * ```markdown\n   *   | ~~~js\n   *   | alert(1)\n   * > | ~~~\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    effects.exit(\"codeFenced\");\n    return ok(code);\n  }\n\n  /**\n   * @this {TokenizeContext}\n   *   Context.\n   * @type {Tokenizer}\n   */\n  function tokenizeCloseStart(effects, ok, nok) {\n    let size = 0;\n    return startBefore;\n\n    /**\n     *\n     *\n     * @type {State}\n     */\n    function startBefore(code) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return start;\n    }\n\n    /**\n     * Before closing fence, at optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function start(code) {\n      // Always populated by defaults.\n\n      // To do: `enter` here or in next state?\n      effects.enter(\"codeFencedFence\");\n      return markdownSpace(code) ? factorySpace(effects, beforeSequenceClose, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : beforeSequenceClose(code);\n    }\n\n    /**\n     * In closing fence, after optional whitespace, at sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function beforeSequenceClose(code) {\n      if (code === marker) {\n        effects.enter(\"codeFencedFenceSequence\");\n        return sequenceClose(code);\n      }\n      return nok(code);\n    }\n\n    /**\n     * In closing fence sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceClose(code) {\n      if (code === marker) {\n        size++;\n        effects.consume(code);\n        return sequenceClose;\n      }\n      if (size >= sizeOpen) {\n        effects.exit(\"codeFencedFenceSequence\");\n        return markdownSpace(code) ? factorySpace(effects, sequenceCloseAfter, \"whitespace\")(code) : sequenceCloseAfter(code);\n      }\n      return nok(code);\n    }\n\n    /**\n     * After closing fence sequence, after optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *        ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceCloseAfter(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit(\"codeFencedFence\");\n        return ok(code);\n      }\n      return nok(code);\n    }\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuation(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return lineStart;\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function lineStart(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { asciiAlphanumeric, asciiDigit, asciiHexDigit } from 'micromark-util-character';\n/** @type {Construct} */\nexport const characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  const self = this;\n  let size = 0;\n  /** @type {number} */\n  let max;\n  /** @type {(code: Code) => boolean} */\n  let test;\n  return start;\n\n  /**\n   * Start of character reference.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *      ^\n   * > | a&#123;b\n   *      ^\n   * > | a&#x9;b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"characterReference\");\n    effects.enter(\"characterReferenceMarker\");\n    effects.consume(code);\n    effects.exit(\"characterReferenceMarker\");\n    return open;\n  }\n\n  /**\n   * After `&`, at `#` for numeric references or alphanumeric for named\n   * references.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^\n   * > | a&#123;b\n   *       ^\n   * > | a&#x9;b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 35) {\n      effects.enter(\"characterReferenceMarkerNumeric\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarkerNumeric\");\n      return numeric;\n    }\n    effects.enter(\"characterReferenceValue\");\n    max = 31;\n    test = asciiAlphanumeric;\n    return value(code);\n  }\n\n  /**\n   * After `#`, at `x` for hexadecimals or digit for decimals.\n   *\n   * ```markdown\n   * > | a&#123;b\n   *        ^\n   * > | a&#x9;b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter(\"characterReferenceMarkerHexadecimal\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarkerHexadecimal\");\n      effects.enter(\"characterReferenceValue\");\n      max = 6;\n      test = asciiHexDigit;\n      return value;\n    }\n    effects.enter(\"characterReferenceValue\");\n    max = 7;\n    test = asciiDigit;\n    return value(code);\n  }\n\n  /**\n   * After markers (`&#x`, `&#`, or `&`), in value, before `;`.\n   *\n   * The character reference kind defines what and how many characters are\n   * allowed.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^^^\n   * > | a&#123;b\n   *        ^^^\n   * > | a&#x9;b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function value(code) {\n    if (code === 59 && size) {\n      const token = effects.exit(\"characterReferenceValue\");\n      if (test === asciiAlphanumeric && !decodeNamedCharacterReference(self.sliceSerialize(token))) {\n        return nok(code);\n      }\n\n      // To do: `markdown-rs` uses a different name:\n      // `CharacterReferenceMarkerSemi`.\n      effects.enter(\"characterReferenceMarker\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarker\");\n      effects.exit(\"characterReference\");\n      return ok;\n    }\n    if (test(code) && size++ < max) {\n      effects.consume(code);\n      return value;\n    }\n    return nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiPunctuation } from 'micromark-util-character';\n/** @type {Construct} */\nexport const characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of character escape.\n   *\n   * ```markdown\n   * > | a\\*b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"characterEscape\");\n    effects.enter(\"escapeMarker\");\n    effects.consume(code);\n    effects.exit(\"escapeMarker\");\n    return inside;\n  }\n\n  /**\n   * After `\\`, at punctuation.\n   *\n   * ```markdown\n   * > | a\\*b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    // ASCII punctuation.\n    if (asciiPunctuation(code)) {\n      effects.enter(\"characterEscapeValue\");\n      effects.consume(code);\n      effects.exit(\"characterEscapeValue\");\n      effects.exit(\"characterEscape\");\n      return ok;\n    }\n    return nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLineEnding(effects, ok) {\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, ok, \"linePrefix\");\n  }\n}","/**\n * @import {Event, Resolver, TokenizeContext} from 'micromark-util-types'\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {ReadonlyArray<{resolveAll?: Resolver | undefined}>} constructs\n *   List of constructs, optionally with `resolveAll`s.\n * @param {Array<Event>} events\n *   List of events.\n * @param {TokenizeContext} context\n *   Context used by `tokenize`.\n * @returns {Array<Event>}\n *   Changed events.\n */\nexport function resolveAll(constructs, events, context) {\n  /** @type {Array<Resolver>} */\n  const called = []\n  let index = -1\n\n  while (++index < constructs.length) {\n    const resolve = constructs[index].resolveAll\n\n    if (resolve && !called.includes(resolve)) {\n      events = resolve(events, context)\n      called.push(resolve)\n    }\n  }\n\n  return events\n}\n","/**\n * @import {\n *   Construct,\n *   Event,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factoryDestination } from 'micromark-factory-destination';\nimport { factoryLabel } from 'micromark-factory-label';\nimport { factoryTitle } from 'micromark-factory-title';\nimport { factoryWhitespace } from 'micromark-factory-whitespace';\nimport { markdownLineEndingOrSpace } from 'micromark-util-character';\nimport { push, splice } from 'micromark-util-chunked';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/** @type {Construct} */\nexport const labelEnd = {\n  name: 'labelEnd',\n  resolveAll: resolveAllLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  tokenize: tokenizeLabelEnd\n};\n\n/** @type {Construct} */\nconst resourceConstruct = {\n  tokenize: tokenizeResource\n};\n/** @type {Construct} */\nconst referenceFullConstruct = {\n  tokenize: tokenizeReferenceFull\n};\n/** @type {Construct} */\nconst referenceCollapsedConstruct = {\n  tokenize: tokenizeReferenceCollapsed\n};\n\n/** @type {Resolver} */\nfunction resolveAllLabelEnd(events) {\n  let index = -1;\n  /** @type {Array<Event>} */\n  const newEvents = [];\n  while (++index < events.length) {\n    const token = events[index][1];\n    newEvents.push(events[index]);\n    if (token.type === \"labelImage\" || token.type === \"labelLink\" || token.type === \"labelEnd\") {\n      // Remove the marker.\n      const offset = token.type === \"labelImage\" ? 4 : 2;\n      token.type = \"data\";\n      index += offset;\n    }\n  }\n\n  // If the events are equal, we don't have to copy newEvents to events\n  if (events.length !== newEvents.length) {\n    splice(events, 0, events.length, newEvents);\n  }\n  return events;\n}\n\n/** @type {Resolver} */\nfunction resolveToLabelEnd(events, context) {\n  let index = events.length;\n  let offset = 0;\n  /** @type {Token} */\n  let token;\n  /** @type {number | undefined} */\n  let open;\n  /** @type {number | undefined} */\n  let close;\n  /** @type {Array<Event>} */\n  let media;\n\n  // Find an opening.\n  while (index--) {\n    token = events[index][1];\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (token.type === \"link\" || token.type === \"labelLink\" && token._inactive) {\n        break;\n      }\n\n      // Mark other link openings as inactive, as we can’t have links in\n      // links.\n      if (events[index][0] === 'enter' && token.type === \"labelLink\") {\n        token._inactive = true;\n      }\n    } else if (close) {\n      if (events[index][0] === 'enter' && (token.type === \"labelImage\" || token.type === \"labelLink\") && !token._balanced) {\n        open = index;\n        if (token.type !== \"labelLink\") {\n          offset = 2;\n          break;\n        }\n      }\n    } else if (token.type === \"labelEnd\") {\n      close = index;\n    }\n  }\n  const group = {\n    type: events[open][1].type === \"labelLink\" ? \"link\" : \"image\",\n    start: {\n      ...events[open][1].start\n    },\n    end: {\n      ...events[events.length - 1][1].end\n    }\n  };\n  const label = {\n    type: \"label\",\n    start: {\n      ...events[open][1].start\n    },\n    end: {\n      ...events[close][1].end\n    }\n  };\n  const text = {\n    type: \"labelText\",\n    start: {\n      ...events[open + offset + 2][1].end\n    },\n    end: {\n      ...events[close - 2][1].start\n    }\n  };\n  media = [['enter', group, context], ['enter', label, context]];\n\n  // Opening marker.\n  media = push(media, events.slice(open + 1, open + offset + 3));\n\n  // Text open.\n  media = push(media, [['enter', text, context]]);\n\n  // Always populated by defaults.\n\n  // Between.\n  media = push(media, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + offset + 4, close - 3), context));\n\n  // Text close, marker close, label close.\n  media = push(media, [['exit', text, context], events[close - 2], events[close - 1], ['exit', label, context]]);\n\n  // Reference, resource, or so.\n  media = push(media, events.slice(close + 1));\n\n  // Media close.\n  media = push(media, [['exit', group, context]]);\n  splice(events, open, events.length, media);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  const self = this;\n  let index = self.events.length;\n  /** @type {Token} */\n  let labelStart;\n  /** @type {boolean} */\n  let defined;\n\n  // Find an opening.\n  while (index--) {\n    if ((self.events[index][1].type === \"labelImage\" || self.events[index][1].type === \"labelLink\") && !self.events[index][1]._balanced) {\n      labelStart = self.events[index][1];\n      break;\n    }\n  }\n  return start;\n\n  /**\n   * Start of label end.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // If there is not an okay opening.\n    if (!labelStart) {\n      return nok(code);\n    }\n\n    // If the corresponding label (link) start is marked as inactive,\n    // it means we’d be wrapping a link, like this:\n    //\n    // ```markdown\n    // > | a [b [c](d) e](f) g.\n    //                  ^\n    // ```\n    //\n    // We can’t have that, so it’s just balanced brackets.\n    if (labelStart._inactive) {\n      return labelEndNok(code);\n    }\n    defined = self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize({\n      start: labelStart.end,\n      end: self.now()\n    })));\n    effects.enter(\"labelEnd\");\n    effects.enter(\"labelMarker\");\n    effects.consume(code);\n    effects.exit(\"labelMarker\");\n    effects.exit(\"labelEnd\");\n    return after;\n  }\n\n  /**\n   * After `]`.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // Note: `markdown-rs` also parses GFM footnotes here, which for us is in\n    // an extension.\n\n    // Resource (`[asd](fgh)`)?\n    if (code === 40) {\n      return effects.attempt(resourceConstruct, labelEndOk, defined ? labelEndOk : labelEndNok)(code);\n    }\n\n    // Full (`[asd][fgh]`) or collapsed (`[asd][]`) reference?\n    if (code === 91) {\n      return effects.attempt(referenceFullConstruct, labelEndOk, defined ? referenceNotFull : labelEndNok)(code);\n    }\n\n    // Shortcut (`[asd]`) reference?\n    return defined ? labelEndOk(code) : labelEndNok(code);\n  }\n\n  /**\n   * After `]`, at `[`, but not at a full reference.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] b\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceNotFull(code) {\n    return effects.attempt(referenceCollapsedConstruct, labelEndOk, labelEndNok)(code);\n  }\n\n  /**\n   * Done, we found something.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *           ^\n   * > | [a][b] c\n   *           ^\n   * > | [a][] b\n   *          ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndOk(code) {\n    // Note: `markdown-rs` does a bunch of stuff here.\n    return ok(code);\n  }\n\n  /**\n   * Done, it’s nothing.\n   *\n   * There was an okay opening, but we didn’t match anything.\n   *\n   * ```markdown\n   * > | [a](b c\n   *        ^\n   * > | [a][b c\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndNok(code) {\n    labelStart._balanced = true;\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeResource(effects, ok, nok) {\n  return resourceStart;\n\n  /**\n   * At a resource.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceStart(code) {\n    effects.enter(\"resource\");\n    effects.enter(\"resourceMarker\");\n    effects.consume(code);\n    effects.exit(\"resourceMarker\");\n    return resourceBefore;\n  }\n\n  /**\n   * In resource, after `(`, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBefore(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceOpen)(code) : resourceOpen(code);\n  }\n\n  /**\n   * In resource, after optional whitespace, at `)` or a destination.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceOpen(code) {\n    if (code === 41) {\n      return resourceEnd(code);\n    }\n    return factoryDestination(effects, resourceDestinationAfter, resourceDestinationMissing, \"resourceDestination\", \"resourceDestinationLiteral\", \"resourceDestinationLiteralMarker\", \"resourceDestinationRaw\", \"resourceDestinationString\", 32)(code);\n  }\n\n  /**\n   * In resource, after destination, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceBetween)(code) : resourceEnd(code);\n  }\n\n  /**\n   * At invalid destination.\n   *\n   * ```markdown\n   * > | [a](<<) b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationMissing(code) {\n    return nok(code);\n  }\n\n  /**\n   * In resource, after destination and whitespace, at `(` or title.\n   *\n   * ```markdown\n   * > | [a](b ) c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBetween(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(effects, resourceTitleAfter, nok, \"resourceTitle\", \"resourceTitleMarker\", \"resourceTitleString\")(code);\n    }\n    return resourceEnd(code);\n  }\n\n  /**\n   * In resource, after title, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b \"c\") d\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceTitleAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceEnd)(code) : resourceEnd(code);\n  }\n\n  /**\n   * In resource, at `)`.\n   *\n   * ```markdown\n   * > | [a](b) d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceEnd(code) {\n    if (code === 41) {\n      effects.enter(\"resourceMarker\");\n      effects.consume(code);\n      effects.exit(\"resourceMarker\");\n      effects.exit(\"resource\");\n      return ok;\n    }\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceFull(effects, ok, nok) {\n  const self = this;\n  return referenceFull;\n\n  /**\n   * In a reference (full), at the `[`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFull(code) {\n    return factoryLabel.call(self, effects, referenceFullAfter, referenceFullMissing, \"reference\", \"referenceMarker\", \"referenceString\")(code);\n  }\n\n  /**\n   * In a reference (full), after `]`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullAfter(code) {\n    return self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1))) ? ok(code) : nok(code);\n  }\n\n  /**\n   * In reference (full) that was missing.\n   *\n   * ```markdown\n   * > | [a][b d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullMissing(code) {\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceCollapsed(effects, ok, nok) {\n  return referenceCollapsedStart;\n\n  /**\n   * In reference (collapsed), at `[`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceCollapsedStart(code) {\n    // We only attempt a collapsed label if there’s a `[`.\n\n    effects.enter(\"reference\");\n    effects.enter(\"referenceMarker\");\n    effects.consume(code);\n    effects.exit(\"referenceMarker\");\n    return referenceCollapsedOpen;\n  }\n\n  /**\n   * In reference (collapsed), at `]`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *         ^\n   * ```\n   *\n   *  @type {State}\n   */\n  function referenceCollapsedOpen(code) {\n    if (code === 93) {\n      effects.enter(\"referenceMarker\");\n      effects.consume(code);\n      effects.exit(\"referenceMarker\");\n      effects.exit(\"reference\");\n      return ok;\n    }\n    return nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { labelEnd } from './label-end.js';\n\n/** @type {Construct} */\nexport const labelStartImage = {\n  name: 'labelStartImage',\n  resolveAll: labelEnd.resolveAll,\n  tokenize: tokenizeLabelStartImage\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of label (image) start.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"labelImage\");\n    effects.enter(\"labelImageMarker\");\n    effects.consume(code);\n    effects.exit(\"labelImageMarker\");\n    return open;\n  }\n\n  /**\n   * After `!`, at `[`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 91) {\n      effects.enter(\"labelMarker\");\n      effects.consume(code);\n      effects.exit(\"labelMarker\");\n      effects.exit(\"labelImage\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `![`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *         ^\n   * ```\n   *\n   * This is needed in because, when GFM footnotes are enabled, images never\n   * form when started with a `^`.\n   * Instead, links form:\n   *\n   * ```markdown\n   * ![^a](b)\n   *\n   * ![^a][b]\n   *\n   * [b]: c\n   * ```\n   *\n   * ```html\n   * <p>!<a href=\\\"b\\\">^a</a></p>\n   * <p>!<a href=\\\"c\\\">^a</a></p>\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // To do: use a new field to do this, this is still needed for\n    // `micromark-extension-gfm-footnote`, but the `label-start-link`\n    // behavior isn’t.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);\n  }\n}","/**\n * @import {Code} from 'micromark-util-types'\n */\n\nimport { markdownLineEndingOrSpace, unicodePunctuation, unicodeWhitespace } from 'micromark-util-character';\n/**\n * Classify whether a code represents whitespace, punctuation, or something\n * else.\n *\n * Used for attention (emphasis, strong), whose sequences can open or close\n * based on the class of surrounding characters.\n *\n * > 👉 **Note**: eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n *   Code.\n * @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined}\n *   Group.\n */\nexport function classifyCharacter(code) {\n  if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n    return 1;\n  }\n  if (unicodePunctuation(code)) {\n    return 2;\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   Event,\n *   Point,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { push, splice } from 'micromark-util-chunked';\nimport { classifyCharacter } from 'micromark-util-classify-character';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/** @type {Construct} */\nexport const attention = {\n  name: 'attention',\n  resolveAll: resolveAllAttention,\n  tokenize: tokenizeAttention\n};\n\n/**\n * Take all events and resolve attention to emphasis or strong.\n *\n * @type {Resolver}\n */\n// eslint-disable-next-line complexity\nfunction resolveAllAttention(events, context) {\n  let index = -1;\n  /** @type {number} */\n  let open;\n  /** @type {Token} */\n  let group;\n  /** @type {Token} */\n  let text;\n  /** @type {Token} */\n  let openingSequence;\n  /** @type {Token} */\n  let closingSequence;\n  /** @type {number} */\n  let use;\n  /** @type {Array<Event>} */\n  let nextEvents;\n  /** @type {number} */\n  let offset;\n\n  // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it’s\n  // a bottleneck for malicious stuff.\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (events[index][0] === 'enter' && events[index][1].type === 'attentionSequence' && events[index][1]._close) {\n      open = index;\n\n      // Now walk back to find an opener.\n      while (open--) {\n        // Find a token that can open the closer.\n        if (events[open][0] === 'exit' && events[open][1].type === 'attentionSequence' && events[open][1]._open &&\n        // If the markers are the same:\n        context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {\n          // If the opening can close or the closing can open,\n          // and the close size *is not* a multiple of three,\n          // but the sum of the opening and closing size *is* multiple of three,\n          // then don’t match.\n          if ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) {\n            continue;\n          }\n\n          // Number of markers to use from the sequence.\n          use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1;\n          const start = {\n            ...events[open][1].end\n          };\n          const end = {\n            ...events[index][1].start\n          };\n          movePoint(start, -use);\n          movePoint(end, use);\n          openingSequence = {\n            type: use > 1 ? \"strongSequence\" : \"emphasisSequence\",\n            start,\n            end: {\n              ...events[open][1].end\n            }\n          };\n          closingSequence = {\n            type: use > 1 ? \"strongSequence\" : \"emphasisSequence\",\n            start: {\n              ...events[index][1].start\n            },\n            end\n          };\n          text = {\n            type: use > 1 ? \"strongText\" : \"emphasisText\",\n            start: {\n              ...events[open][1].end\n            },\n            end: {\n              ...events[index][1].start\n            }\n          };\n          group = {\n            type: use > 1 ? \"strong\" : \"emphasis\",\n            start: {\n              ...openingSequence.start\n            },\n            end: {\n              ...closingSequence.end\n            }\n          };\n          events[open][1].end = {\n            ...openingSequence.start\n          };\n          events[index][1].start = {\n            ...closingSequence.end\n          };\n          nextEvents = [];\n\n          // If there are more markers in the opening, add them before.\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = push(nextEvents, [['enter', events[open][1], context], ['exit', events[open][1], context]]);\n          }\n\n          // Opening.\n          nextEvents = push(nextEvents, [['enter', group, context], ['enter', openingSequence, context], ['exit', openingSequence, context], ['enter', text, context]]);\n\n          // Always populated by defaults.\n\n          // Between.\n          nextEvents = push(nextEvents, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context));\n\n          // Closing.\n          nextEvents = push(nextEvents, [['exit', text, context], ['enter', closingSequence, context], ['exit', closingSequence, context], ['exit', group, context]]);\n\n          // If there are more markers in the closing, add them after.\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2;\n            nextEvents = push(nextEvents, [['enter', events[index][1], context], ['exit', events[index][1], context]]);\n          } else {\n            offset = 0;\n          }\n          splice(events, open - 1, index - open + 3, nextEvents);\n          index = open + nextEvents.length - offset - 2;\n          break;\n        }\n      }\n    }\n  }\n\n  // Remove remaining sequences.\n  index = -1;\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data';\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeAttention(effects, ok) {\n  const attentionMarkers = this.parser.constructs.attentionMarkers.null;\n  const previous = this.previous;\n  const before = classifyCharacter(previous);\n\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Before a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    marker = code;\n    effects.enter('attentionSequence');\n    return inside(code);\n  }\n\n  /**\n   * In a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return inside;\n    }\n    const token = effects.exit('attentionSequence');\n\n    // To do: next major: move this to resolver, just like `markdown-rs`.\n    const after = classifyCharacter(code);\n\n    // Always populated by defaults.\n\n    const open = !after || after === 2 && before || attentionMarkers.includes(code);\n    const close = !before || before === 2 && after || attentionMarkers.includes(previous);\n    token._open = Boolean(marker === 42 ? open : open && (before || !close));\n    token._close = Boolean(marker === 42 ? close : close && (after || !open));\n    return ok(code);\n  }\n}\n\n/**\n * Move a point a bit.\n *\n * Note: `move` only works inside lines! It’s not possible to move past other\n * chunks (replacement characters, tabs, or line endings).\n *\n * @param {Point} point\n *   Point.\n * @param {number} offset\n *   Amount to move.\n * @returns {undefined}\n *   Nothing.\n */\nfunction movePoint(point, offset) {\n  point.column += offset;\n  point.offset += offset;\n  point._bufferIndex += offset;\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiAlphanumeric, asciiAlpha, asciiAtext, asciiControl } from 'micromark-util-character';\n/** @type {Construct} */\nexport const autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeAutolink(effects, ok, nok) {\n  let size = 0;\n  return start;\n\n  /**\n   * Start of an autolink.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *      ^\n   * > | a<user@example.com>b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"autolink\");\n    effects.enter(\"autolinkMarker\");\n    effects.consume(code);\n    effects.exit(\"autolinkMarker\");\n    effects.enter(\"autolinkProtocol\");\n    return open;\n  }\n\n  /**\n   * After `<`, at protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *       ^\n   * > | a<user@example.com>b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return schemeOrEmailAtext;\n    }\n    if (code === 64) {\n      return nok(code);\n    }\n    return emailAtext(code);\n  }\n\n  /**\n   * At second byte of protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeOrEmailAtext(code) {\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) {\n      // Count the previous alphabetical from `open` too.\n      size = 1;\n      return schemeInsideOrEmailAtext(code);\n    }\n    return emailAtext(code);\n  }\n\n  /**\n   * In ambiguous protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code);\n      size = 0;\n      return urlInside;\n    }\n\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) {\n      effects.consume(code);\n      return schemeInsideOrEmailAtext;\n    }\n    size = 0;\n    return emailAtext(code);\n  }\n\n  /**\n   * After protocol, in URL.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit(\"autolinkProtocol\");\n      effects.enter(\"autolinkMarker\");\n      effects.consume(code);\n      effects.exit(\"autolinkMarker\");\n      effects.exit(\"autolink\");\n      return ok;\n    }\n\n    // ASCII control, space, or `<`.\n    if (code === null || code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return urlInside;\n  }\n\n  /**\n   * In email atext.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code);\n      return emailAtSignOrDot;\n    }\n    if (asciiAtext(code)) {\n      effects.consume(code);\n      return emailAtext;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In label, after at-sign or dot.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                 ^       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code);\n  }\n\n  /**\n   * In label, where `.` and `>` are allowed.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n    if (code === 62) {\n      // Exit, then change the token type.\n      effects.exit(\"autolinkProtocol\").type = \"autolinkEmail\";\n      effects.enter(\"autolinkMarker\");\n      effects.consume(code);\n      effects.exit(\"autolinkMarker\");\n      effects.exit(\"autolink\");\n      return ok;\n    }\n    return emailValue(code);\n  }\n\n  /**\n   * In label, where `.` and `>` are *not* allowed.\n   *\n   * Though, this is also used in `emailLabel` to parse other values.\n   *\n   * ```markdown\n   * > | a<user.name@ex-ample.com>b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailValue(code) {\n    // ASCII alphanumeric or `-`.\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      const next = code === 45 ? emailValue : emailLabel;\n      effects.consume(code);\n      return next;\n    }\n    return nok(code);\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { asciiAlphanumeric, asciiAlpha, markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlText(effects, ok, nok) {\n  const self = this;\n  /** @type {NonNullable<Code> | undefined} */\n  let marker;\n  /** @type {number} */\n  let index;\n  /** @type {State} */\n  let returnState;\n  return start;\n\n  /**\n   * Start of HTML (text).\n   *\n   * ```markdown\n   * > | a <b> c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"htmlText\");\n    effects.enter(\"htmlTextData\");\n    effects.consume(code);\n    return open;\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | a <b> c\n   *        ^\n   * > | a <!doctype> c\n   *        ^\n   * > | a <!--b--> c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instruction;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | a <!doctype> c\n   *         ^\n   * > | a <!--b--> c\n   *         ^\n   * > | a <![CDATA[>&<]]> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentOpenInside;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      index = 0;\n      return cdataOpenInside;\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return declaration;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In a comment, after `<!-`, at another `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentEnd;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In comment.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function comment(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 45) {\n      effects.consume(code);\n      return commentClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = comment;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return comment;\n  }\n\n  /**\n   * In comment, after `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentEnd;\n    }\n    return comment(code);\n  }\n\n  /**\n   * In comment, after `--`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentEnd(code) {\n    return code === 62 ? end(code) : code === 45 ? commentClose(code) : comment(code);\n  }\n\n  /**\n   * After `<![`, in CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *          ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = \"CDATA[\";\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === value.length ? cdata : cdataOpenInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In CDATA.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdata(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = cdata;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return cdata;\n  }\n\n  /**\n   * In CDATA, after `]`, at another `]`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n\n  /**\n   * In CDATA, after `]]`, at `>`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n\n  /**\n   * In declaration.\n   *\n   * ```markdown\n   * > | a <!b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = declaration;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return declaration;\n  }\n\n  /**\n   * In instruction.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instruction(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instructionClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = instruction;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return instruction;\n  }\n\n  /**\n   * In instruction, after `?`, at `>`.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code);\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `</x`, in a tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagClose(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return tagCloseBetween(code);\n  }\n\n  /**\n   * In closing tag, after tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagCloseBetween;\n    }\n    return end(code);\n  }\n\n  /**\n   * After `<x`, in opening tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpen(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In opening tag, after tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return end;\n    }\n\n    // ASCII alphabetical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenBetween;\n    }\n    return end(code);\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeName(code) {\n    // ASCII alphabetical and `-`, `.`, `:`, and `_`.\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n    return tagOpenAttributeNameAfter(code);\n  }\n\n  /**\n   * After attribute name, before initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeNameAfter;\n    }\n    return tagOpenBetween(code);\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return tagOpenAttributeValueQuoted;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      marker = undefined;\n      return tagOpenAttributeValueQuotedAfter;\n    }\n    if (code === null) {\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueQuoted;\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 96) {\n      return nok(code);\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the end\n   * of the tag.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In certain circumstances of a tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function end(code) {\n    if (code === 62) {\n      effects.consume(code);\n      effects.exit(\"htmlTextData\");\n      effects.exit(\"htmlText\");\n      return ok;\n    }\n    return nok(code);\n  }\n\n  /**\n   * At eol.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   * > | a <!--a\n   *            ^\n   *   | b-->\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingBefore(code) {\n    effects.exit(\"htmlTextData\");\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return lineEndingAfter;\n  }\n\n  /**\n   * After eol, at optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfter(code) {\n    // Always populated by defaults.\n\n    return markdownSpace(code) ? factorySpace(effects, lineEndingAfterPrefix, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : lineEndingAfterPrefix(code);\n  }\n\n  /**\n   * After eol, after optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfterPrefix(code) {\n    effects.enter(\"htmlTextData\");\n    return returnState(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { labelEnd } from './label-end.js';\n\n/** @type {Construct} */\nexport const labelStartLink = {\n  name: 'labelStartLink',\n  resolveAll: labelEnd.resolveAll,\n  tokenize: tokenizeLabelStartLink\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of label (link) start.\n   *\n   * ```markdown\n   * > | a [b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"labelLink\");\n    effects.enter(\"labelMarker\");\n    effects.consume(code);\n    effects.exit(\"labelMarker\");\n    effects.exit(\"labelLink\");\n    return after;\n  }\n\n  /** @type {State} */\n  function after(code) {\n    // To do: this isn’t needed in `micromark-extension-gfm-footnote`,\n    // remove.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of a hard break (escape).\n   *\n   * ```markdown\n   * > | a\\\n   *      ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"hardBreakEscape\");\n    effects.consume(code);\n    return after;\n  }\n\n  /**\n   * After `\\`, at eol.\n   *\n   * ```markdown\n   * > | a\\\n   *       ^\n   *   | b\n   * ```\n   *\n   *  @type {State}\n   */\n  function after(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit(\"hardBreakEscape\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   Previous,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const codeText = {\n  name: 'codeText',\n  previous,\n  resolve: resolveCodeText,\n  tokenize: tokenizeCodeText\n};\n\n// To do: next major: don’t resolve, like `markdown-rs`.\n/** @type {Resolver} */\nfunction resolveCodeText(events) {\n  let tailExitIndex = events.length - 4;\n  let headEnterIndex = 3;\n  /** @type {number} */\n  let index;\n  /** @type {number | undefined} */\n  let enter;\n\n  // If we start and end with an EOL or a space.\n  if ((events[headEnterIndex][1].type === \"lineEnding\" || events[headEnterIndex][1].type === 'space') && (events[tailExitIndex][1].type === \"lineEnding\" || events[tailExitIndex][1].type === 'space')) {\n    index = headEnterIndex;\n\n    // And we have data.\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === \"codeTextData\") {\n        // Then we have padding.\n        events[headEnterIndex][1].type = \"codeTextPadding\";\n        events[tailExitIndex][1].type = \"codeTextPadding\";\n        headEnterIndex += 2;\n        tailExitIndex -= 2;\n        break;\n      }\n    }\n  }\n\n  // Merge adjacent spaces and data.\n  index = headEnterIndex - 1;\n  tailExitIndex++;\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== \"lineEnding\") {\n        enter = index;\n      }\n    } else if (index === tailExitIndex || events[index][1].type === \"lineEnding\") {\n      events[enter][1].type = \"codeTextData\";\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end;\n        events.splice(enter + 2, index - enter - 2);\n        tailExitIndex -= index - enter - 2;\n        index = enter + 2;\n      }\n      enter = undefined;\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Previous}\n */\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return code !== 96 || this.events[this.events.length - 1][1].type === \"characterEscape\";\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeText(effects, ok, nok) {\n  const self = this;\n  let sizeOpen = 0;\n  /** @type {number} */\n  let size;\n  /** @type {Token} */\n  let token;\n  return start;\n\n  /**\n   * Start of code (text).\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * > | \\`a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"codeText\");\n    effects.enter(\"codeTextSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 96) {\n      effects.consume(code);\n      sizeOpen++;\n      return sequenceOpen;\n    }\n    effects.exit(\"codeTextSequence\");\n    return between(code);\n  }\n\n  /**\n   * Between something and something else.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function between(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code);\n    }\n\n    // To do: next major: don’t do spaces in resolve, but when compiling,\n    // like `markdown-rs`.\n    // Tabs don’t work, and virtual spaces don’t make sense.\n    if (code === 32) {\n      effects.enter('space');\n      effects.consume(code);\n      effects.exit('space');\n      return between;\n    }\n\n    // Closing fence? Could also be data.\n    if (code === 96) {\n      token = effects.enter(\"codeTextSequence\");\n      size = 0;\n      return sequenceClose(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return between;\n    }\n\n    // Data.\n    effects.enter(\"codeTextData\");\n    return data(code);\n  }\n\n  /**\n   * In data.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {\n      effects.exit(\"codeTextData\");\n      return between(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n\n  /**\n   * In closing sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceClose(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code);\n      size++;\n      return sequenceClose;\n    }\n\n    // Done!\n    if (size === sizeOpen) {\n      effects.exit(\"codeTextSequence\");\n      effects.exit(\"codeText\");\n      return ok(code);\n    }\n\n    // More or less accents: mark as data.\n    token.type = \"codeTextData\";\n    return data(code);\n  }\n}","/**\n * @import {Extension} from 'micromark-util-types'\n */\n\nimport { attention, autolink, blockQuote, characterEscape, characterReference, codeFenced, codeIndented, codeText, definition, hardBreakEscape, headingAtx, htmlFlow, htmlText, labelEnd, labelStartImage, labelStartLink, lineEnding, list, setextUnderline, thematicBreak } from 'micromark-core-commonmark';\nimport { resolver as resolveText } from './initialize/text.js';\n\n/** @satisfies {Extension['document']} */\nexport const document = {\n  [42]: list,\n  [43]: list,\n  [45]: list,\n  [48]: list,\n  [49]: list,\n  [50]: list,\n  [51]: list,\n  [52]: list,\n  [53]: list,\n  [54]: list,\n  [55]: list,\n  [56]: list,\n  [57]: list,\n  [62]: blockQuote\n};\n\n/** @satisfies {Extension['contentInitial']} */\nexport const contentInitial = {\n  [91]: definition\n};\n\n/** @satisfies {Extension['flowInitial']} */\nexport const flowInitial = {\n  [-2]: codeIndented,\n  [-1]: codeIndented,\n  [32]: codeIndented\n};\n\n/** @satisfies {Extension['flow']} */\nexport const flow = {\n  [35]: headingAtx,\n  [42]: thematicBreak,\n  [45]: [setextUnderline, thematicBreak],\n  [60]: htmlFlow,\n  [61]: setextUnderline,\n  [95]: thematicBreak,\n  [96]: codeFenced,\n  [126]: codeFenced\n};\n\n/** @satisfies {Extension['string']} */\nexport const string = {\n  [38]: characterReference,\n  [92]: characterEscape\n};\n\n/** @satisfies {Extension['text']} */\nexport const text = {\n  [-5]: lineEnding,\n  [-4]: lineEnding,\n  [-3]: lineEnding,\n  [33]: labelStartImage,\n  [38]: characterReference,\n  [42]: attention,\n  [60]: [autolink, htmlText],\n  [91]: labelStartLink,\n  [92]: [hardBreakEscape, characterEscape],\n  [93]: labelEnd,\n  [95]: attention,\n  [96]: codeText\n};\n\n/** @satisfies {Extension['insideSpan']} */\nexport const insideSpan = {\n  null: [attention, resolveText]\n};\n\n/** @satisfies {Extension['attentionMarkers']} */\nexport const attentionMarkers = {\n  null: [42, 95]\n};\n\n/** @satisfies {Extension['disable']} */\nexport const disable = {\n  null: []\n};","/**\n * @import {\n *   Chunk,\n *   Code,\n *   ConstructRecord,\n *   Construct,\n *   Effects,\n *   InitialConstruct,\n *   ParseContext,\n *   Point,\n *   State,\n *   TokenizeContext,\n *   Token\n * } from 'micromark-util-types'\n */\n\n/**\n * @callback Restore\n *   Restore the state.\n * @returns {undefined}\n *   Nothing.\n *\n * @typedef Info\n *   Info.\n * @property {Restore} restore\n *   Restore.\n * @property {number} from\n *   From.\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n *   Construct.\n * @param {Info} info\n *   Info.\n * @returns {undefined}\n *   Nothing.\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { push, splice } from 'micromark-util-chunked';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/**\n * Create a tokenizer.\n * Tokenizers deal with one type of data (e.g., containers, flow, text).\n * The parser is the object dealing with it all.\n * `initialize` works like other constructs, except that only its `tokenize`\n * function is used, in which case it doesn’t receive an `ok` or `nok`.\n * `from` can be given to set the point before the first character, although\n * when further lines are indented, they must be set with `defineSkip`.\n *\n * @param {ParseContext} parser\n *   Parser.\n * @param {InitialConstruct} initialize\n *   Construct.\n * @param {Omit<Point, '_bufferIndex' | '_index'> | undefined} [from]\n *   Point (optional).\n * @returns {TokenizeContext}\n *   Context.\n */\nexport function createTokenizer(parser, initialize, from) {\n  /** @type {Point} */\n  let point = {\n    _bufferIndex: -1,\n    _index: 0,\n    line: from && from.line || 1,\n    column: from && from.column || 1,\n    offset: from && from.offset || 0\n  };\n  /** @type {Record<string, number>} */\n  const columnStart = {};\n  /** @type {Array<Construct>} */\n  const resolveAllConstructs = [];\n  /** @type {Array<Chunk>} */\n  let chunks = [];\n  /** @type {Array<Token>} */\n  let stack = [];\n  /** @type {boolean | undefined} */\n  let consumed = true;\n\n  /**\n   * Tools used for tokenizing.\n   *\n   * @type {Effects}\n   */\n  const effects = {\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    consume,\n    enter,\n    exit,\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    })\n  };\n\n  /**\n   * State and tools for resolving and serializing.\n   *\n   * @type {TokenizeContext}\n   */\n  const context = {\n    code: null,\n    containerState: {},\n    defineSkip,\n    events: [],\n    now,\n    parser,\n    previous: null,\n    sliceSerialize,\n    sliceStream,\n    write\n  };\n\n  /**\n   * The state function.\n   *\n   * @type {State | undefined}\n   */\n  let state = initialize.tokenize.call(context, effects);\n\n  /**\n   * Track which character we expect to be consumed, to catch bugs.\n   *\n   * @type {Code}\n   */\n  let expectedCode;\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize);\n  }\n  return context;\n\n  /** @type {TokenizeContext['write']} */\n  function write(slice) {\n    chunks = push(chunks, slice);\n    main();\n\n    // Exit if we’re not done, resolve might change stuff.\n    if (chunks[chunks.length - 1] !== null) {\n      return [];\n    }\n    addResult(initialize, 0);\n\n    // Otherwise, resolve, and exit.\n    context.events = resolveAll(resolveAllConstructs, context.events, context);\n    return context.events;\n  }\n\n  //\n  // Tools.\n  //\n\n  /** @type {TokenizeContext['sliceSerialize']} */\n  function sliceSerialize(token, expandTabs) {\n    return serializeChunks(sliceStream(token), expandTabs);\n  }\n\n  /** @type {TokenizeContext['sliceStream']} */\n  function sliceStream(token) {\n    return sliceChunks(chunks, token);\n  }\n\n  /** @type {TokenizeContext['now']} */\n  function now() {\n    // This is a hot path, so we clone manually instead of `Object.assign({}, point)`\n    const {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\n    } = point;\n    return {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\n    };\n  }\n\n  /** @type {TokenizeContext['defineSkip']} */\n  function defineSkip(value) {\n    columnStart[value.line] = value.column;\n    accountForPotentialSkip();\n  }\n\n  //\n  // State management.\n  //\n\n  /**\n   * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n   * `consume`).\n   * Here is where we walk through the chunks, which either include strings of\n   * several characters, or numerical character codes.\n   * The reason to do this in a loop instead of a call is so the stack can\n   * drain.\n   *\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function main() {\n    /** @type {number} */\n    let chunkIndex;\n    while (point._index < chunks.length) {\n      const chunk = chunks[point._index];\n\n      // If we’re in a buffer chunk, loop through it.\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index;\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0;\n        }\n        while (point._index === chunkIndex && point._bufferIndex < chunk.length) {\n          go(chunk.charCodeAt(point._bufferIndex));\n        }\n      } else {\n        go(chunk);\n      }\n    }\n  }\n\n  /**\n   * Deal with one code.\n   *\n   * @param {Code} code\n   *   Code.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function go(code) {\n    consumed = undefined;\n    expectedCode = code;\n    state = state(code);\n  }\n\n  /** @type {Effects['consume']} */\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++;\n      point.column = 1;\n      point.offset += code === -3 ? 2 : 1;\n      accountForPotentialSkip();\n    } else if (code !== -1) {\n      point.column++;\n      point.offset++;\n    }\n\n    // Not in a string chunk.\n    if (point._bufferIndex < 0) {\n      point._index++;\n    } else {\n      point._bufferIndex++;\n\n      // At end of string chunk.\n      if (point._bufferIndex ===\n      // Points w/ non-negative `_bufferIndex` reference\n      // strings.\n      /** @type {string} */\n      chunks[point._index].length) {\n        point._bufferIndex = -1;\n        point._index++;\n      }\n    }\n\n    // Expose the previous character.\n    context.previous = code;\n\n    // Mark as consumed.\n    consumed = true;\n  }\n\n  /** @type {Effects['enter']} */\n  function enter(type, fields) {\n    /** @type {Token} */\n    // @ts-expect-error Patch instead of assign required fields to help GC.\n    const token = fields || {};\n    token.type = type;\n    token.start = now();\n    context.events.push(['enter', token, context]);\n    stack.push(token);\n    return token;\n  }\n\n  /** @type {Effects['exit']} */\n  function exit(type) {\n    const token = stack.pop();\n    token.end = now();\n    context.events.push(['exit', token, context]);\n    return token;\n  }\n\n  /**\n   * Use results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from);\n  }\n\n  /**\n   * Discard results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulcheck(_, info) {\n    info.restore();\n  }\n\n  /**\n   * Factory to attempt/check/interrupt.\n   *\n   * @param {ReturnHandle} onreturn\n   *   Callback.\n   * @param {{interrupt?: boolean | undefined} | undefined} [fields]\n   *   Fields.\n   */\n  function constructFactory(onreturn, fields) {\n    return hook;\n\n    /**\n     * Handle either an object mapping codes to constructs, a list of\n     * constructs, or a single construct.\n     *\n     * @param {Array<Construct> | ConstructRecord | Construct} constructs\n     *   Constructs.\n     * @param {State} returnState\n     *   State.\n     * @param {State | undefined} [bogusState]\n     *   State.\n     * @returns {State}\n     *   State.\n     */\n    function hook(constructs, returnState, bogusState) {\n      /** @type {ReadonlyArray<Construct>} */\n      let listOfConstructs;\n      /** @type {number} */\n      let constructIndex;\n      /** @type {Construct} */\n      let currentConstruct;\n      /** @type {Info} */\n      let info;\n      return Array.isArray(constructs) ? /* c8 ignore next 1 */\n      handleListOfConstructs(constructs) : 'tokenize' in constructs ?\n      // Looks like a construct.\n      handleListOfConstructs([(/** @type {Construct} */constructs)]) : handleMapOfConstructs(constructs);\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       *   Constructs.\n       * @returns {State}\n       *   State.\n       */\n      function handleMapOfConstructs(map) {\n        return start;\n\n        /** @type {State} */\n        function start(code) {\n          const left = code !== null && map[code];\n          const all = code !== null && map.null;\n          const list = [\n          // To do: add more extension tests.\n          /* c8 ignore next 2 */\n          ...(Array.isArray(left) ? left : left ? [left] : []), ...(Array.isArray(all) ? all : all ? [all] : [])];\n          return handleListOfConstructs(list)(code);\n        }\n      }\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ReadonlyArray<Construct>} list\n       *   Constructs.\n       * @returns {State}\n       *   State.\n       */\n      function handleListOfConstructs(list) {\n        listOfConstructs = list;\n        constructIndex = 0;\n        if (list.length === 0) {\n          return bogusState;\n        }\n        return handleConstruct(list[constructIndex]);\n      }\n\n      /**\n       * Handle a single construct.\n       *\n       * @param {Construct} construct\n       *   Construct.\n       * @returns {State}\n       *   State.\n       */\n      function handleConstruct(construct) {\n        return start;\n\n        /** @type {State} */\n        function start(code) {\n          // To do: not needed to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store();\n          currentConstruct = construct;\n          if (!construct.partial) {\n            context.currentConstruct = construct;\n          }\n\n          // Always populated by defaults.\n\n          if (construct.name && context.parser.constructs.disable.null.includes(construct.name)) {\n            return nok(code);\n          }\n          return construct.tokenize.call(\n          // If we do have fields, create an object w/ `context` as its\n          // prototype.\n          // This allows a “live binding”, which is needed for `interrupt`.\n          fields ? Object.assign(Object.create(context), fields) : context, effects, ok, nok)(code);\n        }\n      }\n\n      /** @type {State} */\n      function ok(code) {\n        consumed = true;\n        onreturn(currentConstruct, info);\n        return returnState;\n      }\n\n      /** @type {State} */\n      function nok(code) {\n        consumed = true;\n        info.restore();\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex]);\n        }\n        return bogusState;\n      }\n    }\n  }\n\n  /**\n   * @param {Construct} construct\n   *   Construct.\n   * @param {number} from\n   *   From.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct);\n    }\n    if (construct.resolve) {\n      splice(context.events, from, context.events.length - from, construct.resolve(context.events.slice(from), context));\n    }\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context);\n    }\n  }\n\n  /**\n   * Store state.\n   *\n   * @returns {Info}\n   *   Info.\n   */\n  function store() {\n    const startPoint = now();\n    const startPrevious = context.previous;\n    const startCurrentConstruct = context.currentConstruct;\n    const startEventsIndex = context.events.length;\n    const startStack = Array.from(stack);\n    return {\n      from: startEventsIndex,\n      restore\n    };\n\n    /**\n     * Restore state.\n     *\n     * @returns {undefined}\n     *   Nothing.\n     */\n    function restore() {\n      point = startPoint;\n      context.previous = startPrevious;\n      context.currentConstruct = startCurrentConstruct;\n      context.events.length = startEventsIndex;\n      stack = startStack;\n      accountForPotentialSkip();\n    }\n  }\n\n  /**\n   * Move the current point a bit forward in the line when it’s on a column\n   * skip.\n   *\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line];\n      point.offset += columnStart[point.line] - 1;\n    }\n  }\n}\n\n/**\n * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {Pick<Token, 'end' | 'start'>} token\n *   Token.\n * @returns {Array<Chunk>}\n *   Chunks.\n */\nfunction sliceChunks(chunks, token) {\n  const startIndex = token.start._index;\n  const startBufferIndex = token.start._bufferIndex;\n  const endIndex = token.end._index;\n  const endBufferIndex = token.end._bufferIndex;\n  /** @type {Array<Chunk>} */\n  let view;\n  if (startIndex === endIndex) {\n    // @ts-expect-error `_bufferIndex` is used on string chunks.\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];\n  } else {\n    view = chunks.slice(startIndex, endIndex);\n    if (startBufferIndex > -1) {\n      const head = view[0];\n      if (typeof head === 'string') {\n        view[0] = head.slice(startBufferIndex);\n      } else {\n        view.shift();\n      }\n    }\n    if (endBufferIndex > 0) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view.push(chunks[endIndex].slice(0, endBufferIndex));\n    }\n  }\n  return view;\n}\n\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {boolean | undefined} [expandTabs=false]\n *   Whether to expand tabs (default: `false`).\n * @returns {string}\n *   Result.\n */\nfunction serializeChunks(chunks, expandTabs) {\n  let index = -1;\n  /** @type {Array<string>} */\n  const result = [];\n  /** @type {boolean | undefined} */\n  let atTab;\n  while (++index < chunks.length) {\n    const chunk = chunks[index];\n    /** @type {string} */\n    let value;\n    if (typeof chunk === 'string') {\n      value = chunk;\n    } else switch (chunk) {\n      case -5:\n        {\n          value = \"\\r\";\n          break;\n        }\n      case -4:\n        {\n          value = \"\\n\";\n          break;\n        }\n      case -3:\n        {\n          value = \"\\r\" + \"\\n\";\n          break;\n        }\n      case -2:\n        {\n          value = expandTabs ? \" \" : \"\\t\";\n          break;\n        }\n      case -1:\n        {\n          if (!expandTabs && atTab) continue;\n          value = \" \";\n          break;\n        }\n      default:\n        {\n          // Currently only replacement character.\n          value = String.fromCharCode(chunk);\n        }\n    }\n    atTab = chunk === -2;\n    result.push(value);\n  }\n  return result.join('');\n}","/**\n * @import {\n *   Create,\n *   FullNormalizedExtension,\n *   InitialConstruct,\n *   ParseContext,\n *   ParseOptions\n * } from 'micromark-util-types'\n */\n\nimport { combineExtensions } from 'micromark-util-combine-extensions';\nimport { content } from './initialize/content.js';\nimport { document } from './initialize/document.js';\nimport { flow } from './initialize/flow.js';\nimport { string, text } from './initialize/text.js';\nimport * as defaultConstructs from './constructs.js';\nimport { createTokenizer } from './create-tokenizer.js';\n\n/**\n * @param {ParseOptions | null | undefined} [options]\n *   Configuration (optional).\n * @returns {ParseContext}\n *   Parser.\n */\nexport function parse(options) {\n  const settings = options || {};\n  const constructs = /** @type {FullNormalizedExtension} */\n  combineExtensions([defaultConstructs, ...(settings.extensions || [])]);\n\n  /** @type {ParseContext} */\n  const parser = {\n    constructs,\n    content: create(content),\n    defined: [],\n    document: create(document),\n    flow: create(flow),\n    lazy: {},\n    string: create(string),\n    text: create(text)\n  };\n  return parser;\n\n  /**\n   * @param {InitialConstruct} initial\n   *   Construct to start with.\n   * @returns {Create}\n   *   Create a tokenizer.\n   */\n  function create(initial) {\n    return creator;\n    /** @type {Create} */\n    function creator(from) {\n      return createTokenizer(parser, initial, from);\n    }\n  }\n}","/**\n * @import {Event} from 'micromark-util-types'\n */\n\nimport { subtokenize } from 'micromark-util-subtokenize';\n\n/**\n * @param {Array<Event>} events\n *   Events.\n * @returns {Array<Event>}\n *   Events.\n */\nexport function postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n  return events;\n}","/**\n * @import {Chunk, Code, Encoding, Value} from 'micromark-util-types'\n */\n\n/**\n * @callback Preprocessor\n *   Preprocess a value.\n * @param {Value} value\n *   Value.\n * @param {Encoding | null | undefined} [encoding]\n *   Encoding when `value` is a typed array (optional).\n * @param {boolean | null | undefined} [end=false]\n *   Whether this is the last chunk (default: `false`).\n * @returns {Array<Chunk>}\n *   Chunks.\n */\n\nconst search = /[\\0\\t\\n\\r]/g;\n\n/**\n * @returns {Preprocessor}\n *   Preprocess a value.\n */\nexport function preprocess() {\n  let column = 1;\n  let buffer = '';\n  /** @type {boolean | undefined} */\n  let start = true;\n  /** @type {boolean | undefined} */\n  let atCarriageReturn;\n  return preprocessor;\n\n  /** @type {Preprocessor} */\n  // eslint-disable-next-line complexity\n  function preprocessor(value, encoding, end) {\n    /** @type {Array<Chunk>} */\n    const chunks = [];\n    /** @type {RegExpMatchArray | null} */\n    let match;\n    /** @type {number} */\n    let next;\n    /** @type {number} */\n    let startPosition;\n    /** @type {number} */\n    let endPosition;\n    /** @type {Code} */\n    let code;\n    value = buffer + (typeof value === 'string' ? value.toString() : new TextDecoder(encoding || undefined).decode(value));\n    startPosition = 0;\n    buffer = '';\n    if (start) {\n      // To do: `markdown-rs` actually parses BOMs (byte order mark).\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++;\n      }\n      start = undefined;\n    }\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition;\n      match = search.exec(value);\n      endPosition = match && match.index !== undefined ? match.index : value.length;\n      code = value.charCodeAt(endPosition);\n      if (!match) {\n        buffer = value.slice(startPosition);\n        break;\n      }\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3);\n        atCarriageReturn = undefined;\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5);\n          atCarriageReturn = undefined;\n        }\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition));\n          column += endPosition - startPosition;\n        }\n        switch (code) {\n          case 0:\n            {\n              chunks.push(65533);\n              column++;\n              break;\n            }\n          case 9:\n            {\n              next = Math.ceil(column / 4) * 4;\n              chunks.push(-2);\n              while (column++ < next) chunks.push(-1);\n              break;\n            }\n          case 10:\n            {\n              chunks.push(-4);\n              column = 1;\n              break;\n            }\n          default:\n            {\n              atCarriageReturn = true;\n              column = 1;\n            }\n        }\n      }\n      startPosition = endPosition + 1;\n    }\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5);\n      if (buffer) chunks.push(buffer);\n      chunks.push(null);\n    }\n    return chunks;\n  }\n}"],"names":["asciiAlpha","regexCheck","asciiAlphanumeric","asciiAtext","asciiControl","code","asciiDigit","asciiHexDigit","asciiPunctuation","markdownLineEnding","markdownLineEndingOrSpace","markdownSpace","unicodePunctuation","unicodeWhitespace","regex","test","String","fromCharCode","splice","list","start","remove","items","end","length","parameters","chunkStart","Array","from","unshift","slice","push","decodeNumericCharacterReference","value","base","Number","parseInt","fromCodePoint","characterEscapeOrReference","decodeString","replace","decode","$0","$1","$2","charCodeAt","head","hex","normalizeIdentifier","toLowerCase","toUpperCase","normalizeUri","result","index","skip","next","encodeURIComponent","join","SpliceBuffer","constructor","initial","this","left","right","get","RangeError","shift","setCursor","pop","stop","undefined","POSITIVE_INFINITY","reverse","concat","deleteCount","count","Math","trunc","removed","chunkedPush","item","pushMany","unshiftMany","n","subtokenize","eventsArray","jumps","event","lineIndex","otherIndex","otherEvent","subevents","more","events","type","_tokenizer","_isInFirstContentOfListItem","contentType","Object","assign","subcontent","_container","eventIndex","token","context","startPosition","startPositions","tokenizer","parser","childEvents","gaps","stream","previous","current","adjust","breaks","sliceStream","defineSkip","_gfmTasklistFirstContentOfListItem","write","line","hasOwnProperty","syntaxExtension","all","extension","hook","call","constructs","isArray","existing","before","add","factorySpace","effects","ok","max","limit","size","enter","prefix","consume","exit","content","tokenize","contentStart","attempt","contentInitial","lineStart","data","self","stack","childFlow","childToken","lineStartOffset","continued","containerState","continuation","documentContinue","checkNewContainers","_closeFlow","closeFlow","indexBeforeExits","point","indexBeforeFlow","exitContainers","documentContinued","currentConstruct","concrete","flowStart","interrupt","Boolean","_gfmTableDynamicInterruptHack","check","containerConstruct","thereIsANewContainer","thereIsNoNewContainer","lazy","now","offset","containerContinue","flow","flowContinue","writeToChild","endOfFile","seen","entry","nok","document","disable","null","includes","blankLine","partial","after","resolve","chunkInside","contentEnd","continuationConstruct","contentContinue","prefixed","tail","sliceSerialize","flowInitial","afterConstruct","resolver","resolveAll","createResolver","string","initializeFactory","field","resolveAllLineSuffixes","text","notText","atBreak","extraResolver","chunks","tabs","bufferIndex","chunk","_bufferIndex","_index","column","thematicBreak","name","marker","sequence","furtherBlankLines","initialBlankLine","notInCurrentItem","indentConstruct","initialSize","kind","atMarker","inside","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","blockQuote","contBefore","state","open","factoryDestination","literalType","literalMarkerType","rawType","stringType","balance","enclosedBefore","raw","enclosed","enclosedEscape","rawEscape","factoryLabel","markerType","labelInside","labelEscape","factoryTitle","begin","escape","factoryWhitespace","definition","identifier","labelAfter","markerAfter","destinationBefore","destinationAfter","titleBefore","afterWhitespace","defined","beforeMarker","titleAfter","titleAfterOptionalWhitespace","codeIndented","afterPrefix","furtherStart","headingAtx","sequenceOpen","sequenceFurther","setextUnderline","resolveTo","heading","paragraph","htmlBlockNames","htmlRawNames","htmlFlow","closingTag","buffer","markerB","declarationOpen","tagCloseStart","continuationDeclarationInside","tagName","commentOpenInside","cdataOpenInside","slash","basicSelfClosing","completeClosingTagAfter","completeAttributeNameBefore","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCdataInside","continuationStart","blankLineBefore","continuationAfter","nonLazyContinuationStart","continuationStartNonLazy","continuationBefore","continuationRawEndTag","nonLazyContinuation","codeFenced","closeStart","startBefore","beforeSequenceClose","sequenceClose","sizeOpen","sequenceCloseAfter","initialPrefix","beforeSequenceOpen","infoBefore","atNonLazyBreak","info","metaBefore","meta","contentBefore","beforeContentChunk","contentChunk","characterReference","numeric","characterEscape","lineEnding","called","labelEnd","newEvents","close","media","_inactive","_balanced","group","label","insideSpan","labelStart","labelEndNok","resourceConstruct","labelEndOk","referenceFullConstruct","referenceNotFull","referenceCollapsedConstruct","resourceBefore","resourceOpen","resourceEnd","resourceDestinationAfter","resourceDestinationMissing","resourceBetween","resourceTitleAfter","referenceFullAfter","referenceFullMissing","referenceCollapsedOpen","labelStartImage","classifyCharacter","attention","openingSequence","closingSequence","use","nextEvents","_close","_open","movePoint","attentionMarkers","autolink","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","htmlText","returnState","instruction","tagOpen","declaration","commentEnd","comment","commentClose","lineEndingBefore","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","lineEndingAfter","lineEndingAfterPrefix","labelStartLink","hardBreakEscape","codeText","tailExitIndex","headEnterIndex","between","createTokenizer","initialize","columnStart","resolveAllConstructs","consumed","constructFactory","construct","addResult","onsuccessfulcheck","accountForPotentialSkip","fields","expandTabs","atTab","serializeChunks","main","expectedCode","startIndex","startBufferIndex","endIndex","endBufferIndex","view","sliceChunks","chunkIndex","go","_","restore","onreturn","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","map","handleMapOfConstructs","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","store","create","parse","options","extensions","combineExtensions","postprocess","search","preprocess","atCarriageReturn","encoding","match","endPosition","toString","TextDecoder","lastIndex","exec","ceil"],"sourceRoot":""}