@finos/legend-application-pure-ide-deployment 11.11.0 → 11.12.0

package/dist/ide/144.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"144.js","mappings":"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","sources":["webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/mermaid/node_modules/mdast-util-to-string/lib/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-util-chunked/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-util-combine-extensions/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-util-character/lib/unicode-punctuation-regex.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-util-character/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-factory-space/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/lib/initialize/content.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/lib/initialize/document.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/blank-line.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark-util-subtokenize/node_modules/micromark-util-chunked/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark-util-subtokenize/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/content.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/lib/initialize/flow.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/lib/initialize/text.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-util-resolve-all/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/lib/create-tokenizer.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/thematic-break.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/list.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/block-quote.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark-factory-destination/node_modules/micromark-util-character/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark-factory-destination/node_modules/micromark-util-character/lib/unicode-punctuation-regex.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark-factory-destination/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark-factory-label/node_modules/micromark-util-character/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark-factory-label/node_modules/micromark-util-character/lib/unicode-punctuation-regex.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark-factory-label/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark-factory-title/node_modules/micromark-util-character/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark-factory-title/node_modules/micromark-util-character/lib/unicode-punctuation-regex.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark-factory-title/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark-factory-title/node_modules/micromark-factory-space/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark-factory-whitespace/node_modules/micromark-util-character/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark-factory-whitespace/node_modules/micromark-util-character/lib/unicode-punctuation-regex.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark-factory-whitespace/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark-factory-whitespace/node_modules/micromark-factory-space/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-util-normalize-identifier/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/definition.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/code-indented.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/heading-atx.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/setext-underline.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark-util-html-tag-name/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/html-flow.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/code-fenced.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/character-reference.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/character-escape.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/line-ending.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/label-end.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-util-classify-character/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/attention.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/html-text.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/code-text.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/lib/constructs.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/label-start-image.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/autolink.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/label-start-link.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/node_modules/micromark-core-commonmark/lib/hard-break-escape.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/lib/parse.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/lib/preprocess.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark-util-decode-numeric-character-reference/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/mermaid/node_modules/micromark-util-decode-string/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/mermaid/node_modules/micromark-util-normalize-identifier/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/mermaid/node_modules/unist-util-stringify-position/lib/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/mermaid/node_modules/mdast-util-from-markdown/lib/index.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/micromark/lib/postprocess.js","webpack://@finos/legend-application-pure-ide-deployment/../../node_modules/mermaid/dist/createText-b3507a77.js"],"sourcesContent":["/**\n * @typedef {import('mdast').Root|import('mdast').Content} Node\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [includeImageAlt=true]\n *   Whether to use `alt` for `image`s.\n * @property {boolean | null | undefined} [includeHtml=true]\n *   Whether to use `value` of HTML.\n */\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Get the text content of a node or list of nodes.\n *\n * Prefers the node’s plain-text fields, otherwise serializes its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} value\n *   Thing to serialize, typically `Node`.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {string}\n *   Serialized `value`.\n */\nexport function toString(value, options) {\n  const settings = options || emptyOptions\n  const includeImageAlt =\n    typeof settings.includeImageAlt === 'boolean'\n      ? settings.includeImageAlt\n      : true\n  const includeHtml =\n    typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true\n\n  return one(value, includeImageAlt, includeHtml)\n}\n\n/**\n * One node or several nodes.\n *\n * @param {unknown} value\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized node.\n */\nfunction one(value, includeImageAlt, includeHtml) {\n  if (node(value)) {\n    if ('value' in value) {\n      return value.type === 'html' && !includeHtml ? '' : value.value\n    }\n\n    if (includeImageAlt && 'alt' in value && value.alt) {\n      return value.alt\n    }\n\n    if ('children' in value) {\n      return all(value.children, includeImageAlt, includeHtml)\n    }\n  }\n\n  if (Array.isArray(value)) {\n    return all(value, includeImageAlt, includeHtml)\n  }\n\n  return ''\n}\n\n/**\n * Serialize a list of nodes.\n *\n * @param {Array<unknown>} values\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized nodes.\n */\nfunction all(values, includeImageAlt, includeHtml) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n\n  while (++index < values.length) {\n    result[index] = one(values[index], includeImageAlt, includeHtml)\n  }\n\n  return result.join('')\n}\n\n/**\n * Check if `value` looks like a node.\n *\n * @param {unknown} value\n *   Thing.\n * @returns {value is Node}\n *   Whether `value` is a node.\n */\nfunction node(value) {\n  return Boolean(value && typeof value === 'object')\n}\n","/**\n * Like `Array#splice`, but smarter for giant arrays.\n *\n * `Array#splice` takes all items to be inserted as individual argument which\n * causes a stack overflow in V8 when trying to insert 100k items for instance.\n *\n * Otherwise, this does not return the removed items, and takes `items` as an\n * array instead of rest parameters.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {number} start\n *   Index to remove/insert at (can be negative).\n * @param {number} remove\n *   Number of items to remove.\n * @param {Array<T>} items\n *   Items to inject into `list`.\n * @returns {void}\n *   Nothing.\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length\n  let chunkStart = 0\n  /** @type {Array<unknown>} */\n  let parameters\n\n  // Make start between zero and `end` (included).\n  if (start < 0) {\n    start = -start > end ? 0 : end + start\n  } else {\n    start = start > end ? end : start\n  }\n  remove = remove > 0 ? remove : 0\n\n  // No need to chunk the items if there’s only a couple (10k) items.\n  if (items.length < 10000) {\n    parameters = Array.from(items)\n    parameters.unshift(start, remove)\n    // @ts-expect-error Hush, it’s fine.\n    list.splice(...parameters)\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) list.splice(start, remove)\n\n    // Insert the items in chunks to not cause stack overflows.\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000)\n      parameters.unshift(start, 0)\n      // @ts-expect-error Hush, it’s fine.\n      list.splice(...parameters)\n      chunkStart += 10000\n      start += 10000\n    }\n  }\n}\n\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {Array<T>} items\n *   Items to add to `list`.\n * @returns {Array<T>}\n *   Either `list` or `items`.\n */\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items)\n    return list\n  }\n  return items\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Handles} Handles\n * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension\n * @typedef {import('micromark-util-types').NormalizedExtension} NormalizedExtension\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine multiple syntax extensions into one.\n *\n * @param {Array<Extension>} extensions\n *   List of syntax extensions.\n * @returns {NormalizedExtension}\n *   A single combined extension.\n */\nexport function combineExtensions(extensions) {\n  /** @type {NormalizedExtension} */\n  const all = {}\n  let index = -1\n\n  while (++index < extensions.length) {\n    syntaxExtension(all, extensions[index])\n  }\n\n  return all\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {NormalizedExtension} all\n *   Extension to merge into.\n * @param {Extension} extension\n *   Extension to merge.\n * @returns {void}\n */\nfunction syntaxExtension(all, extension) {\n  /** @type {keyof Extension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    /** @type {Record<string, unknown>} */\n    const left = maybe || (all[hook] = {})\n    /** @type {Record<string, unknown> | undefined} */\n    const right = extension[hook]\n    /** @type {string} */\n    let code\n\n    if (right) {\n      for (code in right) {\n        if (!hasOwnProperty.call(left, code)) left[code] = []\n        const value = right[code]\n        constructs(\n          // @ts-expect-error Looks like a list.\n          left[code],\n          Array.isArray(value) ? value : value ? [value] : []\n        )\n      }\n    }\n  }\n}\n\n/**\n * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {Array<unknown>} existing\n * @param {Array<unknown>} list\n * @returns {void}\n */\nfunction constructs(existing, list) {\n  let index = -1\n  /** @type {Array<unknown>} */\n  const before = []\n\n  while (++index < list.length) {\n    // @ts-expect-error Looks like an object.\n    ;(list[index].add === 'after' ? existing : before).push(list[index])\n  }\n\n  splice(existing, 0, 0, before)\n}\n\n/**\n * Combine multiple HTML extensions into one.\n *\n * @param {Array<HtmlExtension>} htmlExtensions\n *   List of HTML extensions.\n * @returns {HtmlExtension}\n *   A single combined HTML extension.\n */\nexport function combineHtmlExtensions(htmlExtensions) {\n  /** @type {HtmlExtension} */\n  const handlers = {}\n  let index = -1\n\n  while (++index < htmlExtensions.length) {\n    htmlExtension(handlers, htmlExtensions[index])\n  }\n\n  return handlers\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {HtmlExtension} all\n *   Extension to merge into.\n * @param {HtmlExtension} extension\n *   Extension to merge.\n * @returns {void}\n */\nfunction htmlExtension(all, extension) {\n  /** @type {keyof HtmlExtension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    const left = maybe || (all[hook] = {})\n    const right = extension[hook]\n    /** @type {keyof Handles} */\n    let type\n\n    if (right) {\n      for (type in right) {\n        // @ts-expect-error assume document vs regular handler are managed correctly.\n        left[type] = right[type]\n      }\n    }\n  }\n}\n","// This module is generated by `script/`.\n//\n// CommonMark handles attention (emphasis, strong) markers based on what comes\n// before or after them.\n// One such difference is if those characters are Unicode punctuation.\n// This script is generated from the Unicode data.\n\n/**\n * Regular expression that matches a unicode punctuation character.\n */\nexport const unicodePunctuationRegex =\n  /[!-\\/:-@\\[-`\\{-~\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061D-\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1B7D\\u1B7E\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52-\\u2E5D\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\n\nimport {unicodePunctuationRegex} from './lib/unicode-punctuation-regex.js'\n\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAlpha = regexCheck(/[A-Za-z]/)\n\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/)\n\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/)\n\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  )\n}\n\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiDigit = regexCheck(/\\d/)\n\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/)\n\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/)\n\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2\n}\n\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32)\n}\n\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32\n}\n\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodePunctuation = regexCheck(unicodePunctuationRegex)\n\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/)\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n * @returns {(code: Code) => boolean}\n */\nfunction regexCheck(regex) {\n  return check\n\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code\n   *   Character code.\n   * @returns {boolean}\n   *   Whether the character code matches the bound regex.\n   */\n  function check(code) {\n    return code !== null && regex.test(String.fromCharCode(code))\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {markdownSpace} from 'micromark-util-character'\n\n// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.\n\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   spaces in markdown are often optional, in which case this factory can be\n *     used and `ok` will be switched to whether spaces were found or not\n * *   one line ending or space can be detected with `markdownSpace(code)` right\n *     before using `factorySpace`\n *\n * ###### Examples\n *\n * Where `␉` represents a tab (plus how much it expands) and `␠` represents a\n * single space.\n *\n * ```markdown\n * ␉\n * ␠␠␠␠\n * ␉␠\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {TokenType} type\n *   Type (`' \\t'`).\n * @param {number | undefined} [max=Infinity]\n *   Max (exclusive).\n * @returns\n *   Start state.\n */\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Number.POSITIVE_INFINITY\n  let size = 0\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type)\n      return prefix(code)\n    }\n    return ok(code)\n  }\n\n  /** @type {State} */\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code)\n      return prefix\n    }\n    effects.exit(type)\n    return ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\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 * @type {Initializer}\n */\nfunction initializeContent(effects) {\n  const contentStart = effects.attempt(\n    this.parser.constructs.contentInitial,\n    afterContentStartConstruct,\n    paragraphInitial\n  )\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","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').ContainerState} ContainerState\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\n/**\n * @typedef {[Construct, ContainerState]} StackItem\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 * @type {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(\n        item[0].continuation,\n        documentContinue,\n        checkNewContainers\n      )(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 (\n          self.events[indexBeforeFlow][0] === 'exit' &&\n          self.events[indexBeforeFlow][1].type === 'chunkFlow'\n        ) {\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 = Object.assign({}, point)\n        index++\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(\n        self.events,\n        indexBeforeFlow + 1,\n        0,\n        self.events.slice(indexBeforeExits)\n      )\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(\n        childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack\n      )\n    }\n\n    // Check if there is a new container.\n    self.containerState = {}\n    return effects.check(\n      containerConstruct,\n      thereIsANewContainer,\n      thereIsNoNewContainer\n    )(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(\n      containerConstruct,\n      containerContinue,\n      flowStart\n    )(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      contentType: 'flow',\n      previous: childToken,\n      _tokenizer: childFlow\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   * @param {boolean | undefined} [eof]\n   * @returns {void}\n   */\n  function writeToChild(token, eof) {\n    const stream = self.sliceStream(token)\n    if (eof) 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        ) {\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 (\n          self.events[indexBeforeFlow][0] === 'exit' &&\n          self.events[indexBeforeFlow][1].type === 'chunkFlow'\n        ) {\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 = Object.assign({}, point)\n        index++\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(\n        self.events,\n        indexBeforeFlow + 1,\n        0,\n        self.events.slice(indexBeforeExits)\n      )\n\n      // Discard the duplicate exits.\n      self.events.length = index\n    }\n  }\n\n  /**\n   * @param {number} size\n   * @returns {void}\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 * @type {Tokenizer}\n */\nfunction tokenizeContainer(effects, ok, nok) {\n  // Always populated by defaults.\n\n  return factorySpace(\n    effects,\n    effects.attempt(this.parser.constructs.document, ok, nok),\n    'linePrefix',\n    this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4\n  )\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nexport const blankLine = {\n  tokenize: tokenizeBlankLine,\n  partial: true\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return start\n\n  /**\n   * Start of blank line.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *     ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    return markdownSpace(code)\n      ? factorySpace(effects, after, 'linePrefix')(code)\n      : after(code)\n  }\n\n  /**\n   * At eof/eol, after optional whitespace.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *       ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n","/**\n * Like `Array#splice`, but smarter for giant arrays.\n *\n * `Array#splice` takes all items to be inserted as individual argument which\n * causes a stack overflow in V8 when trying to insert 100k items for instance.\n *\n * Otherwise, this does not return the removed items, and takes `items` as an\n * array instead of rest parameters.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {number} start\n *   Index to remove/insert at (can be negative).\n * @param {number} remove\n *   Number of items to remove.\n * @param {Array<T>} items\n *   Items to inject into `list`.\n * @returns {void}\n *   Nothing.\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length\n  let chunkStart = 0\n  /** @type {Array<unknown>} */\n  let parameters\n\n  // Make start between zero and `end` (included).\n  if (start < 0) {\n    start = -start > end ? 0 : end + start\n  } else {\n    start = start > end ? end : start\n  }\n  remove = remove > 0 ? remove : 0\n\n  // No need to chunk the items if there’s only a couple (10k) items.\n  if (items.length < 10000) {\n    parameters = Array.from(items)\n    parameters.unshift(start, remove)\n    // @ts-expect-error Hush, it’s fine.\n    list.splice(...parameters)\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) list.splice(start, remove)\n\n    // Insert the items in chunks to not cause stack overflows.\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000)\n      parameters.unshift(start, 0)\n      // @ts-expect-error Hush, it’s fine.\n      list.splice(...parameters)\n      chunkStart += 10000\n      start += 10000\n    }\n  }\n}\n\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {Array<T>} items\n *   Items to add to `list`.\n * @returns {Array<T>}\n *   Either `list` or `items`.\n */\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items)\n    return list\n  }\n  return items\n}\n","/**\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Token} Token\n */\n\nimport {splice} from 'micromark-util-chunked'\n/**\n * Tokenize subcontent.\n *\n * @param {Array<Event>} events\n *   List of events.\n * @returns {boolean}\n *   Whether subtokens were found.\n */\nexport function subtokenize(events) {\n  /** @type {Record<string, number>} */\n  const jumps = {}\n  let index = -1\n  /** @type {Event} */\n  let event\n  /** @type {number | undefined} */\n  let lineIndex\n  /** @type {number} */\n  let otherIndex\n  /** @type {Event} */\n  let otherEvent\n  /** @type {Array<Event>} */\n  let parameters\n  /** @type {Array<Event>} */\n  let subevents\n  /** @type {boolean | undefined} */\n  let more\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index]\n    }\n    event = events[index]\n\n    // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n    if (\n      index &&\n      event[1].type === 'chunkFlow' &&\n      events[index - 1][1].type === 'listItemPrefix'\n    ) {\n      subevents = event[1]._tokenizer.events\n      otherIndex = 0\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'lineEndingBlank'\n      ) {\n        otherIndex += 2\n      }\n      if (\n        otherIndex < subevents.length &&\n        subevents[otherIndex][1].type === 'content'\n      ) {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === 'content') {\n            break\n          }\n          if (subevents[otherIndex][1].type === 'chunkText') {\n            subevents[otherIndex][1]._isInFirstContentOfListItem = true\n            otherIndex++\n          }\n        }\n      }\n    }\n\n    // Enter.\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        Object.assign(jumps, subcontent(events, index))\n        index = jumps[index]\n        more = true\n      }\n    }\n    // Exit.\n    else if (event[1]._container) {\n      otherIndex = index\n      lineIndex = undefined\n      while (otherIndex--) {\n        otherEvent = events[otherIndex]\n        if (\n          otherEvent[1].type === 'lineEnding' ||\n          otherEvent[1].type === 'lineEndingBlank'\n        ) {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events[lineIndex][1].type = 'lineEndingBlank'\n            }\n            otherEvent[1].type = 'lineEnding'\n            lineIndex = otherIndex\n          }\n        } else {\n          break\n        }\n      }\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = Object.assign({}, events[lineIndex][1].start)\n\n        // Switch container exit w/ line endings.\n        parameters = events.slice(lineIndex, index)\n        parameters.unshift(event)\n        splice(events, lineIndex, index - lineIndex + 1, parameters)\n      }\n    }\n  }\n  return !more\n}\n\n/**\n * Tokenize embedded tokens.\n *\n * @param {Array<Event>} events\n * @param {number} eventIndex\n * @returns {Record<string, number>}\n */\nfunction subcontent(events, eventIndex) {\n  const token = events[eventIndex][1]\n  const context = events[eventIndex][2]\n  let startPosition = eventIndex - 1\n  /** @type {Array<number>} */\n  const startPositions = []\n  const tokenizer =\n    token._tokenizer || context.parser[token.contentType](token.start)\n  const childEvents = tokenizer.events\n  /** @type {Array<[number, number]>} */\n  const jumps = []\n  /** @type {Record<string, number>} */\n  const gaps = {}\n  /** @type {Array<Chunk>} */\n  let stream\n  /** @type {Token | undefined} */\n  let previous\n  let index = -1\n  /** @type {Token | undefined} */\n  let current = token\n  let adjust = 0\n  let start = 0\n  const breaks = [start]\n\n  // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n  while (current) {\n    // Find the position of the event for this token.\n    while (events[++startPosition][1] !== current) {\n      // Empty.\n    }\n    startPositions.push(startPosition)\n    if (!current._tokenizer) {\n      stream = context.sliceStream(current)\n      if (!current.next) {\n        stream.push(null)\n      }\n      if (previous) {\n        tokenizer.defineSkip(current.start)\n      }\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true\n      }\n      tokenizer.write(stream)\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined\n      }\n    }\n\n    // Unravel the next token.\n    previous = current\n    current = current.next\n  }\n\n  // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n  current = token\n  while (++index < childEvents.length) {\n    if (\n      // Find a void token that includes a break.\n      childEvents[index][0] === 'exit' &&\n      childEvents[index - 1][0] === 'enter' &&\n      childEvents[index][1].type === childEvents[index - 1][1].type &&\n      childEvents[index][1].start.line !== childEvents[index][1].end.line\n    ) {\n      start = index + 1\n      breaks.push(start)\n      // Help GC.\n      current._tokenizer = undefined\n      current.previous = undefined\n      current = current.next\n    }\n  }\n\n  // Help GC.\n  tokenizer.events = []\n\n  // If there’s one more token (which is the cases for lines that end in an\n  // EOF), that’s perfect: the last point we found starts it.\n  // If there isn’t then make sure any remaining content is added to it.\n  if (current) {\n    // Help GC.\n    current._tokenizer = undefined\n    current.previous = undefined\n  } else {\n    breaks.pop()\n  }\n\n  // Now splice the events from the subtokenizer into the current events,\n  // moving back to front so that splice indices aren’t affected.\n  index = breaks.length\n  while (index--) {\n    const slice = childEvents.slice(breaks[index], breaks[index + 1])\n    const start = startPositions.pop()\n    jumps.unshift([start, start + slice.length - 1])\n    splice(events, start, 2, slice)\n  }\n  index = -1\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1]\n    adjust += jumps[index][1] - jumps[index][0] - 1\n  }\n  return gaps\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\nimport {subtokenize} from 'micromark-util-subtokenize'\n/**\n * No name because it must not be turned off.\n * @type {Construct}\n */\nexport const content = {\n  tokenize: tokenizeContent,\n  resolve: resolveContent\n}\n\n/** @type {Construct} */\nconst continuationConstruct = {\n  tokenize: tokenizeContinuation,\n  partial: true\n}\n\n/**\n * Content is transparent: it’s parsed right now. That way, definitions are also\n * parsed right now: before text in paragraphs (specifically, media) are parsed.\n *\n * @type {Resolver}\n */\nfunction resolveContent(events) {\n  subtokenize(events)\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeContent(effects, ok) {\n  /** @type {Token | undefined} */\n  let previous\n  return chunkStart\n\n  /**\n   * Before a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkStart(code) {\n    effects.enter('content')\n    previous = effects.enter('chunkContent', {\n      contentType: 'content'\n    })\n    return chunkInside(code)\n  }\n\n  /**\n   * In a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkInside(code) {\n    if (code === null) {\n      return contentEnd(code)\n    }\n\n    // To do: in `markdown-rs`, each line is parsed on its own, and everything\n    // is stitched together resolving.\n    if (markdownLineEnding(code)) {\n      return effects.check(\n        continuationConstruct,\n        contentContinue,\n        contentEnd\n      )(code)\n    }\n\n    // Data.\n    effects.consume(code)\n    return chunkInside\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentEnd(code) {\n    effects.exit('chunkContent')\n    effects.exit('content')\n    return ok(code)\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentContinue(code) {\n    effects.consume(code)\n    effects.exit('chunkContent')\n    previous.next = effects.enter('chunkContent', {\n      contentType: 'content',\n      previous\n    })\n    previous = previous.next\n    return chunkInside\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeContinuation(effects, ok, nok) {\n  const self = this\n  return startLookahead\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function startLookahead(code) {\n    effects.exit('chunkContent')\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, prefixed, 'linePrefix')\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n\n    // Always populated by defaults.\n\n    const tail = self.events[self.events.length - 1]\n    if (\n      !self.parser.constructs.disable.null.includes('codeIndented') &&\n      tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n    ) {\n      return ok(code)\n    }\n    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\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 * @type {Initializer}\n */\nfunction initializeFlow(effects) {\n  const self = this\n  const initial = effects.attempt(\n    // Try to parse a blank line.\n    blankLine,\n    atBlankEnding,\n    // Try to parse initial flow (essentially, only code).\n    effects.attempt(\n      this.parser.constructs.flowInitial,\n      afterConstruct,\n      factorySpace(\n        effects,\n        effects.attempt(\n          this.parser.constructs.flow,\n          afterConstruct,\n          effects.attempt(content, afterConstruct)\n        ),\n        'linePrefix'\n      )\n    )\n  )\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","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\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 * @returns {InitialConstruct}\n */\nfunction initializeFactory(field) {\n  return {\n    tokenize: initializeText,\n    resolveAll: createResolver(\n      field === 'text' ? resolveAllLineSuffixes : undefined\n    )\n  }\n\n  /**\n   * @this {TokenizeContext}\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     * @returns {boolean}\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 * @returns {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 (\n      (eventIndex === events.length ||\n        events[eventIndex][1].type === 'lineEnding') &&\n      events[eventIndex - 1][1].type === 'data'\n    ) {\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:\n            eventIndex === events.length || tabs || size < 2\n              ? 'lineSuffix'\n              : 'hardBreakTrailing',\n          start: {\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size,\n            _index: data.start._index + index,\n            _bufferIndex: index\n              ? bufferIndex\n              : data.start._bufferIndex + bufferIndex\n          },\n          end: Object.assign({}, data.end)\n        }\n        data.end = Object.assign({}, token.start)\n        if (data.start.offset === data.end.offset) {\n          Object.assign(data, token)\n        } else {\n          events.splice(\n            eventIndex,\n            0,\n            ['enter', token, context],\n            ['exit', token, context]\n          )\n          eventIndex += 2\n        }\n      }\n      eventIndex++\n    }\n  }\n  return events\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {Array<{resolveAll?: Resolver | undefined}>} constructs\n *   List of constructs, optionally with `resolveAll`s.\n * @param {Array<Event>} events\n *   List of events.\n * @param {TokenizeContext} context\n *   Context used by `tokenize`.\n * @returns {Array<Event>}\n *   Changed events.\n */\nexport function resolveAll(constructs, events, context) {\n  /** @type {Array<Resolver>} */\n  const called = []\n  let index = -1\n\n  while (++index < constructs.length) {\n    const resolve = constructs[index].resolveAll\n\n    if (resolve && !called.includes(resolve)) {\n      events = resolve(events, context)\n      called.push(resolve)\n    }\n  }\n\n  return events\n}\n","/**\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenType} TokenType\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n */\n\n/**\n * @callback Restore\n * @returns {void}\n *\n * @typedef Info\n * @property {Restore} restore\n * @property {number} from\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n * @param {Info} info\n * @returns {void}\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 * @param {InitialConstruct} initialize\n * @param {Omit<Point, '_bufferIndex' | '_index'> | undefined} [from]\n * @returns {TokenizeContext}\n */\nexport function createTokenizer(parser, initialize, from) {\n  /** @type {Point} */\n  let point = Object.assign(\n    from\n      ? Object.assign({}, from)\n      : {\n          line: 1,\n          column: 1,\n          offset: 0\n        },\n    {\n      _index: 0,\n      _bufferIndex: -1\n    }\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    consume,\n    enter,\n    exit,\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\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    previous: null,\n    code: null,\n    containerState: {},\n    events: [],\n    parser,\n    sliceStream,\n    sliceSerialize,\n    now,\n    defineSkip,\n    write\n  }\n\n  /**\n   * The state function.\n   *\n   * @type {State | void}\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 {line, column, offset, _index, _bufferIndex} = point\n    return {\n      line,\n      column,\n      offset,\n      _index,\n      _bufferIndex\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 {void}\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 (\n          point._index === chunkIndex &&\n          point._bufferIndex < chunk.length\n        ) {\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   * @returns {void}\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      // @ts-expect-error Points w/ non-negative `_bufferIndex` reference\n      // strings.\n      if (point._bufferIndex === 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   * @param {{interrupt?: boolean | undefined} | undefined} [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> | Construct | ConstructRecord} constructs\n     * @param {State} returnState\n     * @param {State | undefined} [bogusState]\n     * @returns {State}\n     */\n    function hook(constructs, returnState, bogusState) {\n      /** @type {Array<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)\n        : 'tokenize' in constructs\n        ? // @ts-expect-error Looks like a construct.\n          handleListOfConstructs([constructs])\n        : handleMapOfConstructs(constructs)\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       * @returns {State}\n       */\n      function handleMapOfConstructs(map) {\n        return start\n\n        /** @type {State} */\n        function start(code) {\n          const def = 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(def) ? def : def ? [def] : []),\n            ...(Array.isArray(all) ? all : all ? [all] : [])\n          ]\n          return handleListOfConstructs(list)(code)\n        }\n      }\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {Array<Construct>} list\n       * @returns {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       * @returns {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 (\n            construct.name &&\n            context.parser.constructs.disable.null.includes(construct.name)\n          ) {\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,\n            effects,\n            ok,\n            nok\n          )(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   * @param {number} from\n   * @returns {void}\n   */\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct)\n    }\n    if (construct.resolve) {\n      splice(\n        context.events,\n        from,\n        context.events.length - from,\n        construct.resolve(context.events.slice(from), context)\n      )\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   */\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      restore,\n      from: startEventsIndex\n    }\n\n    /**\n     * Restore state.\n     *\n     * @returns {void}\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 {void}\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 {Array<Chunk>} chunks\n * @param {Pick<Token, 'end' | 'start'>} token\n * @returns {Array<Chunk>}\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 {Array<Chunk>} chunks\n * @param {boolean | undefined} [expandTabs=false]\n * @returns {string}\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\n      switch (chunk) {\n        case -5: {\n          value = '\\r'\n          break\n        }\n        case -4: {\n          value = '\\n'\n          break\n        }\n        case -3: {\n          value = '\\r' + '\\n'\n          break\n        }\n        case -2: {\n          value = expandTabs ? ' ' : '\\t'\n          break\n        }\n        case -1: {\n          if (!expandTabs && atTab) continue\n          value = ' '\n          break\n        }\n        default: {\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","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nexport const thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  let size = 0\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n\n  /**\n   * Start of thematic break.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('thematicBreak')\n    // To do: parse indent like `markdown-rs`.\n    return before(code)\n  }\n\n  /**\n   * After optional whitespace, at marker.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    marker = code\n    return atBreak(code)\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter('thematicBreakSequence')\n      return sequence(code)\n    }\n    if (size >= 3 && (code === null || markdownLineEnding(code))) {\n      effects.exit('thematicBreak')\n      return ok(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code)\n      size++\n      return sequence\n    }\n    effects.exit('thematicBreakSequence')\n    return markdownSpace(code)\n      ? factorySpace(effects, atBreak, 'whitespace')(code)\n      : atBreak(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').ContainerState} ContainerState\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {asciiDigit, markdownSpace} from 'micromark-util-character'\nimport {blankLine} from './blank-line.js'\nimport {thematicBreak} from './thematic-break.js'\n\n/** @type {Construct} */\nexport const list = {\n  name: 'list',\n  tokenize: tokenizeListStart,\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd\n}\n\n/** @type {Construct} */\nconst listItemPrefixWhitespaceConstruct = {\n  tokenize: tokenizeListItemPrefixWhitespace,\n  partial: true\n}\n\n/** @type {Construct} */\nconst indentConstruct = {\n  tokenize: tokenizeIndent,\n  partial: true\n}\n\n// To do: `markdown-rs` parses list items on their own and later stitches them\n// together.\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeListStart(effects, ok, nok) {\n  const self = this\n  const tail = self.events[self.events.length - 1]\n  let initialSize =\n    tail && tail[1].type === 'linePrefix'\n      ? tail[2].sliceSerialize(tail[1], true).length\n      : 0\n  let size = 0\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    const kind =\n      self.containerState.type ||\n      (code === 42 || code === 43 || code === 45\n        ? 'listUnordered'\n        : 'listOrdered')\n    if (\n      kind === 'listUnordered'\n        ? !self.containerState.marker || code === self.containerState.marker\n        : asciiDigit(code)\n    ) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind\n        effects.enter(kind, {\n          _container: true\n        })\n      }\n      if (kind === 'listUnordered') {\n        effects.enter('listItemPrefix')\n        return code === 42 || code === 45\n          ? effects.check(thematicBreak, nok, atMarker)(code)\n          : atMarker(code)\n      }\n      if (!self.interrupt || code === 49) {\n        effects.enter('listItemPrefix')\n        effects.enter('listItemValue')\n        return inside(code)\n      }\n    }\n    return nok(code)\n  }\n\n  /** @type {State} */\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code)\n      return inside\n    }\n    if (\n      (!self.interrupt || size < 2) &&\n      (self.containerState.marker\n        ? code === self.containerState.marker\n        : code === 41 || code === 46)\n    ) {\n      effects.exit('listItemValue')\n      return atMarker(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * @type {State}\n   **/\n  function atMarker(code) {\n    effects.enter('listItemMarker')\n    effects.consume(code)\n    effects.exit('listItemMarker')\n    self.containerState.marker = self.containerState.marker || code\n    return effects.check(\n      blankLine,\n      // Can’t be empty when interrupting.\n      self.interrupt ? nok : onBlank,\n      effects.attempt(\n        listItemPrefixWhitespaceConstruct,\n        endOfPrefix,\n        otherPrefix\n      )\n    )\n  }\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true\n    initialSize++\n    return endOfPrefix(code)\n  }\n\n  /** @type {State} */\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter('listItemPrefixWhitespace')\n      effects.consume(code)\n      effects.exit('listItemPrefixWhitespace')\n      return endOfPrefix\n    }\n    return nok(code)\n  }\n\n  /** @type {State} */\n  function endOfPrefix(code) {\n    self.containerState.size =\n      initialSize +\n      self.sliceSerialize(effects.exit('listItemPrefix'), true).length\n    return ok(code)\n  }\n}\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeListContinuation(effects, ok, nok) {\n  const self = this\n  self.containerState._closeFlow = undefined\n  return effects.check(blankLine, onBlank, notBlank)\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.furtherBlankLines =\n      self.containerState.furtherBlankLines ||\n      self.containerState.initialBlankLine\n\n    // We have a blank line.\n    // Still, try to consume at most the items size.\n    return factorySpace(\n      effects,\n      ok,\n      'listItemIndent',\n      self.containerState.size + 1\n    )(code)\n  }\n\n  /** @type {State} */\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = undefined\n      self.containerState.initialBlankLine = undefined\n      return notInCurrentItem(code)\n    }\n    self.containerState.furtherBlankLines = undefined\n    self.containerState.initialBlankLine = undefined\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code)\n  }\n\n  /** @type {State} */\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true\n    // As we’re closing flow, we’re no longer interrupting.\n    self.interrupt = undefined\n    // Always populated by defaults.\n\n    return factorySpace(\n      effects,\n      effects.attempt(list, ok, nok),\n      'linePrefix',\n      self.parser.constructs.disable.null.includes('codeIndented')\n        ? undefined\n        : 4\n    )(code)\n  }\n}\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemIndent',\n    self.containerState.size + 1\n  )\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'listItemIndent' &&\n      tail[2].sliceSerialize(tail[1], true).length === self.containerState.size\n      ? ok(code)\n      : nok(code)\n  }\n}\n\n/**\n * @type {Exiter}\n * @this {TokenizeContext}\n */\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type)\n}\n\n/**\n * @type {Tokenizer}\n * @this {TokenizeContext}\n */\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  const self = this\n\n  // Always populated by defaults.\n\n  return factorySpace(\n    effects,\n    afterPrefix,\n    'listItemPrefixWhitespace',\n    self.parser.constructs.disable.null.includes('codeIndented')\n      ? undefined\n      : 4 + 1\n  )\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return !markdownSpace(code) &&\n      tail &&\n      tail[1].type === 'listItemPrefixWhitespace'\n      ? ok(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nexport const blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  const self = this\n  return start\n\n  /**\n   * Start of block quote.\n   *\n   * ```markdown\n   * > | > a\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 62) {\n      const state = self.containerState\n      if (!state.open) {\n        effects.enter('blockQuote', {\n          _container: true\n        })\n        state.open = true\n      }\n      effects.enter('blockQuotePrefix')\n      effects.enter('blockQuoteMarker')\n      effects.consume(code)\n      effects.exit('blockQuoteMarker')\n      return after\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `>`, before optional whitespace.\n   *\n   * ```markdown\n   * > | > a\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter('blockQuotePrefixWhitespace')\n      effects.consume(code)\n      effects.exit('blockQuotePrefixWhitespace')\n      effects.exit('blockQuotePrefix')\n      return ok\n    }\n    effects.exit('blockQuotePrefix')\n    return ok(code)\n  }\n}\n\n/**\n * Start of block quote continuation.\n *\n * ```markdown\n *   | > a\n * > | > b\n *     ^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  const self = this\n  return contStart\n\n  /**\n   * Start of block quote continuation.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contStart(code) {\n    if (markdownSpace(code)) {\n      // Always populated by defaults.\n\n      return factorySpace(\n        effects,\n        contBefore,\n        'linePrefix',\n        self.parser.constructs.disable.null.includes('codeIndented')\n          ? undefined\n          : 4\n      )(code)\n    }\n    return contBefore(code)\n  }\n\n  /**\n   * At `>`, after optional whitespace.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contBefore(code) {\n    return effects.attempt(blockQuote, ok, nok)(code)\n  }\n}\n\n/** @type {Exiter} */\nfunction exit(effects) {\n  effects.exit('blockQuote')\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\n\nimport {unicodePunctuationRegex} from './lib/unicode-punctuation-regex.js'\n\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAlpha = regexCheck(/[A-Za-z]/)\n\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/)\n\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/)\n\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  )\n}\n\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiDigit = regexCheck(/\\d/)\n\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/)\n\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/)\n\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2\n}\n\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32)\n}\n\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32\n}\n\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodePunctuation = regexCheck(unicodePunctuationRegex)\n\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/)\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n * @returns {(code: Code) => boolean}\n */\nfunction regexCheck(regex) {\n  return check\n\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code\n   *   Character code.\n   * @returns {boolean}\n   *   Whether the character code matches the bound regex.\n   */\n  function check(code) {\n    return code !== null && regex.test(String.fromCharCode(code))\n  }\n}\n","// This module is generated by `script/`.\n//\n// CommonMark handles attention (emphasis, strong) markers based on what comes\n// before or after them.\n// One such difference is if those characters are Unicode punctuation.\n// This script is generated from the Unicode data.\n\n/**\n * Regular expression that matches a unicode punctuation character.\n */\nexport const unicodePunctuationRegex =\n  /[!-\\/:-@\\[-`\\{-~\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061D-\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1B7D\\u1B7E\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52-\\u2E5D\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {\n  asciiControl,\n  markdownLineEndingOrSpace,\n  markdownLineEnding\n} from 'micromark-util-character'\n/**\n * Parse destinations.\n *\n * ###### Examples\n *\n * ```markdown\n * <a>\n * <a\\>b>\n * <a b>\n * <a)>\n * a\n * a\\)b\n * a(b)c\n * a(b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type for whole (`<a>` or `b`).\n * @param {TokenType} literalType\n *   Type when enclosed (`<a>`).\n * @param {TokenType} literalMarkerType\n *   Type for enclosing (`<` and `>`).\n * @param {TokenType} rawType\n *   Type when not enclosed (`b`).\n * @param {TokenType} stringType\n *   Type for the value (`a` or `b`).\n * @param {number | undefined} [max=Infinity]\n *   Depth of nested parens (inclusive).\n * @returns {State}\n *   Start state.\n */ // eslint-disable-next-line max-params\nexport function factoryDestination(\n  effects,\n  ok,\n  nok,\n  type,\n  literalType,\n  literalMarkerType,\n  rawType,\n  stringType,\n  max\n) {\n  const limit = max || Number.POSITIVE_INFINITY\n  let balance = 0\n  return start\n\n  /**\n   * Start of destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *     ^\n   * > | aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type)\n      effects.enter(literalType)\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      return enclosedBefore\n    }\n\n    // ASCII control, space, closing paren.\n    if (code === null || code === 32 || code === 41 || asciiControl(code)) {\n      return nok(code)\n    }\n    effects.enter(type)\n    effects.enter(rawType)\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return raw(code)\n  }\n\n  /**\n   * After `<`, at an enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType)\n      effects.consume(code)\n      effects.exit(literalMarkerType)\n      effects.exit(literalType)\n      effects.exit(type)\n      return ok\n    }\n    effects.enter(stringType)\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return enclosed(code)\n  }\n\n  /**\n   * In enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      return enclosedBefore(code)\n    }\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return code === 92 ? enclosedEscape : enclosed\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | <a\\*a>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code)\n      return enclosed\n    }\n    return enclosed(code)\n  }\n\n  /**\n   * In raw destination.\n   *\n   * ```markdown\n   * > | aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function raw(code) {\n    if (\n      !balance &&\n      (code === null || code === 41 || markdownLineEndingOrSpace(code))\n    ) {\n      effects.exit('chunkString')\n      effects.exit(stringType)\n      effects.exit(rawType)\n      effects.exit(type)\n      return ok(code)\n    }\n    if (balance < limit && code === 40) {\n      effects.consume(code)\n      balance++\n      return raw\n    }\n    if (code === 41) {\n      effects.consume(code)\n      balance--\n      return raw\n    }\n\n    // ASCII control (but *not* `\\0`) and space and `(`.\n    // Note: in `markdown-rs`, `\\0` exists in codes, in `micromark-js` it\n    // doesn’t.\n    if (code === null || code === 32 || code === 40 || asciiControl(code)) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return code === 92 ? rawEscape : raw\n  }\n\n  /**\n   * After `\\`, at special character.\n   *\n   * ```markdown\n   * > | a\\*a\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function rawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code)\n      return raw\n    }\n    return raw(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\n\nimport {unicodePunctuationRegex} from './lib/unicode-punctuation-regex.js'\n\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAlpha = regexCheck(/[A-Za-z]/)\n\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/)\n\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/)\n\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  )\n}\n\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiDigit = regexCheck(/\\d/)\n\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/)\n\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/)\n\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2\n}\n\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32)\n}\n\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32\n}\n\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodePunctuation = regexCheck(unicodePunctuationRegex)\n\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/)\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n * @returns {(code: Code) => boolean}\n */\nfunction regexCheck(regex) {\n  return check\n\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code\n   *   Character code.\n   * @returns {boolean}\n   *   Whether the character code matches the bound regex.\n   */\n  function check(code) {\n    return code !== null && regex.test(String.fromCharCode(code))\n  }\n}\n","// This module is generated by `script/`.\n//\n// CommonMark handles attention (emphasis, strong) markers based on what comes\n// before or after them.\n// One such difference is if those characters are Unicode punctuation.\n// This script is generated from the Unicode data.\n\n/**\n * Regular expression that matches a unicode punctuation character.\n */\nexport const unicodePunctuationRegex =\n  /[!-\\/:-@\\[-`\\{-~\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061D-\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1B7D\\u1B7E\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52-\\u2E5D\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/**\n * Parse labels.\n *\n * > 👉 **Note**: labels in markdown are capped at 999 characters in the string.\n *\n * ###### Examples\n *\n * ```markdown\n * [a]\n * [a\n * b]\n * [a\\]b]\n * ```\n *\n * @this {TokenizeContext}\n *   Tokenize context.\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole label (`[a]`).\n * @param {TokenType} markerType\n *   Type for the markers (`[` and `]`).\n * @param {TokenType} stringType\n *   Type for the identifier (`a`).\n * @returns {State}\n *   Start state.\n */ // eslint-disable-next-line max-params\nexport function factoryLabel(effects, ok, nok, type, markerType, stringType) {\n  const self = this\n  let size = 0\n  /** @type {boolean} */\n  let seen\n  return start\n\n  /**\n   * Start of label.\n   *\n   * ```markdown\n   * > | [a]\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(type)\n    effects.enter(markerType)\n    effects.consume(code)\n    effects.exit(markerType)\n    effects.enter(stringType)\n    return atBreak\n  }\n\n  /**\n   * In label, at something, before something else.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (\n      size > 999 ||\n      code === null ||\n      code === 91 ||\n      (code === 93 && !seen) ||\n      // To do: remove in the future once we’ve switched from\n      // `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n      // which doesn’t need this.\n      // Hidden footnotes hook.\n      /* c8 ignore next 3 */\n      (code === 94 &&\n        !size &&\n        '_hiddenFootnoteSupport' in self.parser.constructs)\n    ) {\n      return nok(code)\n    }\n    if (code === 93) {\n      effects.exit(stringType)\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n\n    // To do: indent? Link chunks and EOLs together?\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return atBreak\n    }\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return labelInside(code)\n  }\n\n  /**\n   * In label, in text.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelInside(code) {\n    if (\n      code === null ||\n      code === 91 ||\n      code === 93 ||\n      markdownLineEnding(code) ||\n      size++ > 999\n    ) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n    effects.consume(code)\n    if (!seen) seen = !markdownSpace(code)\n    return code === 92 ? labelEscape : labelInside\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | [a\\*a]\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code)\n      size++\n      return labelInside\n    }\n    return labelInside(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\n\nimport {unicodePunctuationRegex} from './lib/unicode-punctuation-regex.js'\n\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAlpha = regexCheck(/[A-Za-z]/)\n\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/)\n\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/)\n\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  )\n}\n\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiDigit = regexCheck(/\\d/)\n\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/)\n\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/)\n\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2\n}\n\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32)\n}\n\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32\n}\n\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodePunctuation = regexCheck(unicodePunctuationRegex)\n\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/)\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n * @returns {(code: Code) => boolean}\n */\nfunction regexCheck(regex) {\n  return check\n\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code\n   *   Character code.\n   * @returns {boolean}\n   *   Whether the character code matches the bound regex.\n   */\n  function check(code) {\n    return code !== null && regex.test(String.fromCharCode(code))\n  }\n}\n","// This module is generated by `script/`.\n//\n// CommonMark handles attention (emphasis, strong) markers based on what comes\n// before or after them.\n// One such difference is if those characters are Unicode punctuation.\n// This script is generated from the Unicode data.\n\n/**\n * Regular expression that matches a unicode punctuation character.\n */\nexport const unicodePunctuationRegex =\n  /[!-\\/:-@\\[-`\\{-~\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061D-\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1B7D\\u1B7E\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52-\\u2E5D\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n/**\n * Parse titles.\n *\n * ###### Examples\n *\n * ```markdown\n * \"a\"\n * 'b'\n * (c)\n * \"a\n * b\"\n * 'a\n *     b'\n * (a\\)b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole title (`\"a\"`, `'b'`, `(c)`).\n * @param {TokenType} markerType\n *   Type for the markers (`\"`, `'`, `(`, and `)`).\n * @param {TokenType} stringType\n *   Type for the value (`a`).\n * @returns {State}\n *   Start state.\n */ // eslint-disable-next-line max-params\nexport function factoryTitle(effects, ok, nok, type, markerType, stringType) {\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n\n  /**\n   * Start of title.\n   *\n   * ```markdown\n   * > | \"a\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      effects.enter(type)\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      marker = code === 40 ? 41 : code\n      return begin\n    }\n    return nok(code)\n  }\n\n  /**\n   * After opening marker.\n   *\n   * This is also used at the closing marker.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function begin(code) {\n    if (code === marker) {\n      effects.enter(markerType)\n      effects.consume(code)\n      effects.exit(markerType)\n      effects.exit(type)\n      return ok\n    }\n    effects.enter(stringType)\n    return atBreak(code)\n  }\n\n  /**\n   * At something, before something else.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType)\n      return begin(marker)\n    }\n    if (code === null) {\n      return nok(code)\n    }\n\n    // Note: blank lines can’t exist in content.\n    if (markdownLineEnding(code)) {\n      // To do: use `space_or_tab_eol_with_options`, connect.\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return factorySpace(effects, atBreak, 'linePrefix')\n    }\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return inside(code)\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      return atBreak(code)\n    }\n    effects.consume(code)\n    return code === 92 ? escape : inside\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | \"a\\*b\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function escape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code)\n      return inside\n    }\n    return inside(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {markdownSpace} from 'micromark-util-character'\n\n// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.\n\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   spaces in markdown are often optional, in which case this factory can be\n *     used and `ok` will be switched to whether spaces were found or not\n * *   one line ending or space can be detected with `markdownSpace(code)` right\n *     before using `factorySpace`\n *\n * ###### Examples\n *\n * Where `␉` represents a tab (plus how much it expands) and `␠` represents a\n * single space.\n *\n * ```markdown\n * ␉\n * ␠␠␠␠\n * ␉␠\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {TokenType} type\n *   Type (`' \\t'`).\n * @param {number | undefined} [max=Infinity]\n *   Max (exclusive).\n * @returns\n *   Start state.\n */\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Number.POSITIVE_INFINITY\n  let size = 0\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type)\n      return prefix(code)\n    }\n    return ok(code)\n  }\n\n  /** @type {State} */\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code)\n      return prefix\n    }\n    effects.exit(type)\n    return ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\n\nimport {unicodePunctuationRegex} from './lib/unicode-punctuation-regex.js'\n\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAlpha = regexCheck(/[A-Za-z]/)\n\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/)\n\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/)\n\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  )\n}\n\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiDigit = regexCheck(/\\d/)\n\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/)\n\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/)\n\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2\n}\n\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32)\n}\n\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32\n}\n\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodePunctuation = regexCheck(unicodePunctuationRegex)\n\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/)\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n * @returns {(code: Code) => boolean}\n */\nfunction regexCheck(regex) {\n  return check\n\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code\n   *   Character code.\n   * @returns {boolean}\n   *   Whether the character code matches the bound regex.\n   */\n  function check(code) {\n    return code !== null && regex.test(String.fromCharCode(code))\n  }\n}\n","// This module is generated by `script/`.\n//\n// CommonMark handles attention (emphasis, strong) markers based on what comes\n// before or after them.\n// One such difference is if those characters are Unicode punctuation.\n// This script is generated from the Unicode data.\n\n/**\n * Regular expression that matches a unicode punctuation character.\n */\nexport const unicodePunctuationRegex =\n  /[!-\\/:-@\\[-`\\{-~\\xA1\\xA7\\xAB\\xB6\\xB7\\xBB\\xBF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061D-\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1B7D\\u1B7E\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52-\\u2E5D\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   line endings or spaces in markdown are often optional, in which case this\n *     factory can be used and `ok` will be switched to whether spaces were found\n *     or not\n * *   one line ending or space can be detected with\n *     `markdownLineEndingOrSpace(code)` right before using `factoryWhitespace`\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @returns\n *   Start state.\n */\nexport function factoryWhitespace(effects, ok) {\n  /** @type {boolean} */\n  let seen\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      seen = true\n      return start\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(\n        effects,\n        start,\n        seen ? 'linePrefix' : 'lineSuffix'\n      )(code)\n    }\n    return ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenType} TokenType\n */\n\nimport {markdownSpace} from 'micromark-util-character'\n\n// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.\n\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   spaces in markdown are often optional, in which case this factory can be\n *     used and `ok` will be switched to whether spaces were found or not\n * *   one line ending or space can be detected with `markdownSpace(code)` right\n *     before using `factorySpace`\n *\n * ###### Examples\n *\n * Where `␉` represents a tab (plus how much it expands) and `␠` represents a\n * single space.\n *\n * ```markdown\n * ␉\n * ␠␠␠␠\n * ␉␠\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {TokenType} type\n *   Type (`' \\t'`).\n * @param {number | undefined} [max=Infinity]\n *   Max (exclusive).\n * @returns\n *   Start state.\n */\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Number.POSITIVE_INFINITY\n  let size = 0\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type)\n      return prefix(code)\n    }\n    return ok(code)\n  }\n\n  /** @type {State} */\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code)\n      return prefix\n    }\n    effects.exit(type)\n    return ok(code)\n  }\n}\n","/**\n * Normalize an identifier (as found in references, definitions).\n *\n * Collapses markdown whitespace, trim, and then lower- and uppercase.\n *\n * Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their\n * lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different\n * uppercase character (U+0398 (`Θ`)).\n * So, to get a canonical form, we perform both lower- and uppercase.\n *\n * Using uppercase last makes sure keys will never interact with default\n * prototypal values (such as `constructor`): nothing in the prototype of\n * `Object` is uppercase.\n *\n * @param {string} value\n *   Identifier to normalize.\n * @returns {string}\n *   Normalized identifier.\n */\nexport function normalizeIdentifier(value) {\n  return (\n    value\n      // Collapse markdown whitespace.\n      .replace(/[\\t\\n\\r ]+/g, ' ')\n      // Trim.\n      .replace(/^ | $/g, '')\n      // Some characters are considered “uppercase”, but if their lowercase\n      // counterpart is uppercased will result in a different uppercase\n      // character.\n      // Hence, to get that form, we perform both lower- and uppercase.\n      // Upper case makes sure keys will not interact with default prototypal\n      // methods: no method is uppercase.\n      .toLowerCase()\n      .toUpperCase()\n  )\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factoryDestination} from 'micromark-factory-destination'\nimport {factoryLabel} from 'micromark-factory-label'\nimport {factorySpace} from 'micromark-factory-space'\nimport {factoryTitle} from 'micromark-factory-title'\nimport {factoryWhitespace} from 'micromark-factory-whitespace'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\n/** @type {Construct} */\nexport const definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n}\n\n/** @type {Construct} */\nconst titleBefore = {\n  tokenize: tokenizeTitleBefore,\n  partial: true\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinition(effects, ok, nok) {\n  const self = this\n  /** @type {string} */\n  let identifier\n  return start\n\n  /**\n   * At start of a definition.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // Do not interrupt paragraphs (but do follow definitions).\n    // To do: do `interrupt` the way `markdown-rs` does.\n    // To do: parse whitespace the way `markdown-rs` does.\n    effects.enter('definition')\n    return before(code)\n  }\n\n  /**\n   * After optional whitespace, at `[`.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    // To do: parse whitespace the way `markdown-rs` does.\n\n    return factoryLabel.call(\n      self,\n      effects,\n      labelAfter,\n      // Note: we don’t need to reset the way `markdown-rs` does.\n      nok,\n      'definitionLabel',\n      'definitionLabelMarker',\n      'definitionLabelString'\n    )(code)\n  }\n\n  /**\n   * After label.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(\n      self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n    )\n    if (code === 58) {\n      effects.enter('definitionMarker')\n      effects.consume(code)\n      effects.exit('definitionMarker')\n      return markerAfter\n    }\n    return nok(code)\n  }\n\n  /**\n   * After marker.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function markerAfter(code) {\n    // Note: whitespace is optional.\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, destinationBefore)(code)\n      : destinationBefore(code)\n  }\n\n  /**\n   * Before destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationBefore(code) {\n    return factoryDestination(\n      effects,\n      destinationAfter,\n      // Note: we don’t need to reset the way `markdown-rs` does.\n      nok,\n      'definitionDestination',\n      'definitionDestinationLiteral',\n      'definitionDestinationLiteralMarker',\n      'definitionDestinationRaw',\n      'definitionDestinationString'\n    )(code)\n  }\n\n  /**\n   * After destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationAfter(code) {\n    return effects.attempt(titleBefore, after, after)(code)\n  }\n\n  /**\n   * After definition.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return markdownSpace(code)\n      ? factorySpace(effects, afterWhitespace, 'whitespace')(code)\n      : afterWhitespace(code)\n  }\n\n  /**\n   * After definition, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterWhitespace(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('definition')\n\n      // Note: we don’t care about uniqueness.\n      // It’s likely that that doesn’t happen very frequently.\n      // It is more likely that it wastes precious time.\n      self.parser.defined.push(identifier)\n\n      // To do: `markdown-rs` interrupt.\n      // // You’d be interrupting.\n      // tokenizer.interrupt = true\n      return ok(code)\n    }\n    return nok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTitleBefore(effects, ok, nok) {\n  return titleBefore\n\n  /**\n   * After destination, at whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleBefore(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, beforeMarker)(code)\n      : nok(code)\n  }\n\n  /**\n   * At title.\n   *\n   * ```markdown\n   *   | [a]: b\n   * > | \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeMarker(code) {\n    return factoryTitle(\n      effects,\n      titleAfter,\n      nok,\n      'definitionTitle',\n      'definitionTitleMarker',\n      'definitionTitleString'\n    )(code)\n  }\n\n  /**\n   * After title.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfter(code) {\n    return markdownSpace(code)\n      ? factorySpace(effects, titleAfterOptionalWhitespace, 'whitespace')(code)\n      : titleAfterOptionalWhitespace(code)\n  }\n\n  /**\n   * After title, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfterOptionalWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nexport const codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented\n}\n\n/** @type {Construct} */\nconst furtherStart = {\n  tokenize: tokenizeFurtherStart,\n  partial: true\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  const self = this\n  return start\n\n  /**\n   * Start of code (indented).\n   *\n   * > **Parsing note**: it is not needed to check if this first line is a\n   * > filled line (that it has a non-whitespace character), because blank lines\n   * > are parsed already, so we never run into that.\n   *\n   * ```markdown\n   * > |     aaa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: manually check if interrupting like `markdown-rs`.\n\n    effects.enter('codeIndented')\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)(code)\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n      ? atBreak(code)\n      : nok(code)\n  }\n\n  /**\n   * At a break.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === null) {\n      return after(code)\n    }\n    if (markdownLineEnding(code)) {\n      return effects.attempt(furtherStart, atBreak, after)(code)\n    }\n    effects.enter('codeFlowValue')\n    return inside(code)\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return atBreak(code)\n    }\n    effects.consume(code)\n    return inside\n  }\n\n  /** @type {State} */\n  function after(code) {\n    effects.exit('codeIndented')\n    // To do: allow interrupting like `markdown-rs`.\n    // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    return ok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeFurtherStart(effects, ok, nok) {\n  const self = this\n  return furtherStart\n\n  /**\n   * At eol, trying to parse another indent.\n   *\n   * ```markdown\n   * > |     aaa\n   *            ^\n   *   |     bbb\n   * ```\n   *\n   * @type {State}\n   */\n  function furtherStart(code) {\n    // To do: improve `lazy` / `pierce` handling.\n    // If this is a lazy line, it can’t be code.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code)\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return furtherStart\n    }\n\n    // To do: the code here in `micromark-js` is a bit different from\n    // `markdown-rs` because there it can attempt spaces.\n    // We can’t yet.\n    //\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)(code)\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1]\n    return tail &&\n      tail[1].type === 'linePrefix' &&\n      tail[2].sliceSerialize(tail[1], true).length >= 4\n      ? ok(code)\n      : markdownLineEnding(code)\n      ? furtherStart(code)\n      : nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {splice} from 'micromark-util-chunked'\n/** @type {Construct} */\nexport const headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\n}\n\n/** @type {Resolver} */\nfunction resolveHeadingAtx(events, context) {\n  let contentEnd = events.length - 2\n  let contentStart = 3\n  /** @type {Token} */\n  let content\n  /** @type {Token} */\n  let text\n\n  // Prefix whitespace, part of the opening.\n  if (events[contentStart][1].type === 'whitespace') {\n    contentStart += 2\n  }\n\n  // Suffix whitespace, part of the closing.\n  if (\n    contentEnd - 2 > contentStart &&\n    events[contentEnd][1].type === 'whitespace'\n  ) {\n    contentEnd -= 2\n  }\n  if (\n    events[contentEnd][1].type === 'atxHeadingSequence' &&\n    (contentStart === contentEnd - 1 ||\n      (contentEnd - 4 > contentStart &&\n        events[contentEnd - 2][1].type === 'whitespace'))\n  ) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4\n  }\n  if (contentEnd > contentStart) {\n    content = {\n      type: 'atxHeadingText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end\n    }\n    text = {\n      type: 'chunkText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end,\n      contentType: 'text'\n    }\n    splice(events, contentStart, contentEnd - contentStart + 1, [\n      ['enter', content, context],\n      ['enter', text, context],\n      ['exit', text, context],\n      ['exit', content, context]\n    ])\n  }\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  let size = 0\n  return start\n\n  /**\n   * Start of a heading (atx).\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    effects.enter('atxHeading')\n    return before(code)\n  }\n\n  /**\n   * After optional whitespace, at `#`.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter('atxHeadingSequence')\n    return sequenceOpen(code)\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code)\n      return sequenceOpen\n    }\n\n    // Always at least one `#`.\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingSequence')\n      return atBreak(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ## aa\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === 35) {\n      effects.enter('atxHeadingSequence')\n      return sequenceFurther(code)\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('atxHeading')\n      // To do: interrupt like `markdown-rs`.\n      // // Feel free to interrupt.\n      // tokenizer.interrupt = false\n      return ok(code)\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, 'whitespace')(code)\n    }\n\n    // To do: generate `data` tokens, add the `text` token later.\n    // Needs edit map, see: `markdown.rs`.\n    effects.enter('atxHeadingText')\n    return data(code)\n  }\n\n  /**\n   * In further sequence (after whitespace).\n   *\n   * Could be normal “visible” hashes in the heading or a final sequence.\n   *\n   * ```markdown\n   * > | ## aa ##\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceFurther(code) {\n    if (code === 35) {\n      effects.consume(code)\n      return sequenceFurther\n    }\n    effects.exit('atxHeadingSequence')\n    return atBreak(code)\n  }\n\n  /**\n   * In text.\n   *\n   * ```markdown\n   * > | ## aa\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingText')\n      return atBreak(code)\n    }\n    effects.consume(code)\n    return data\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nexport const setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\n}\n\n/** @type {Resolver} */\nfunction resolveToSetextUnderline(events, context) {\n  // To do: resolve like `markdown-rs`.\n  let index = events.length\n  /** @type {number | undefined} */\n  let content\n  /** @type {number | undefined} */\n  let text\n  /** @type {number | undefined} */\n  let definition\n\n  // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === 'content') {\n        content = index\n        break\n      }\n      if (events[index][1].type === 'paragraph') {\n        text = index\n      }\n    }\n    // Exit\n    else {\n      if (events[index][1].type === 'content') {\n        // Remove the content end (if needed we’ll add it later)\n        events.splice(index, 1)\n      }\n      if (!definition && events[index][1].type === 'definition') {\n        definition = index\n      }\n    }\n  }\n  const heading = {\n    type: 'setextHeading',\n    start: Object.assign({}, events[text][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  }\n\n  // Change the paragraph to setext heading text.\n  events[text][1].type = 'setextHeadingText'\n\n  // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context])\n    events.splice(definition + 1, 0, ['exit', events[content][1], context])\n    events[content][1].end = Object.assign({}, events[definition][1].end)\n  } else {\n    events[content][1] = heading\n  }\n\n  // Add the heading exit at the end.\n  events.push(['exit', heading, context])\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  const self = this\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n\n  /**\n   * At start of heading (setext) underline.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    let index = self.events.length\n    /** @type {boolean | undefined} */\n    let paragraph\n    // Find an opening.\n    while (index--) {\n      // Skip enter/exit of line ending, line prefix, and content.\n      // We can now either have a definition or a paragraph.\n      if (\n        self.events[index][1].type !== 'lineEnding' &&\n        self.events[index][1].type !== 'linePrefix' &&\n        self.events[index][1].type !== 'content'\n      ) {\n        paragraph = self.events[index][1].type === 'paragraph'\n        break\n      }\n    }\n\n    // To do: handle lazy/pierce like `markdown-rs`.\n    // To do: parse indent like `markdown-rs`.\n    if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {\n      effects.enter('setextHeadingLine')\n      marker = code\n      return before(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * After optional whitespace, at `-` or `=`.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter('setextHeadingLineSequence')\n    return inside(code)\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return inside\n    }\n    effects.exit('setextHeadingLineSequence')\n    return markdownSpace(code)\n      ? factorySpace(effects, after, 'lineSuffix')(code)\n      : after(code)\n  }\n\n  /**\n   * After sequence, after optional whitespace.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('setextHeadingLine')\n      return ok(code)\n    }\n    return nok(code)\n  }\n}\n","/**\n * List of lowercase HTML “block” tag names.\n *\n * The list, when parsing HTML (flow), results in more relaxed rules (condition\n * 6).\n * Because they are known blocks, the HTML-like syntax doesn’t have to be\n * strictly parsed.\n * For tag names not in this list, a more strict algorithm (condition 7) is used\n * to detect whether the HTML-like syntax is seen as HTML (flow) or not.\n *\n * This is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `search` was added in `CommonMark@0.31`.\n */\nexport const htmlBlockNames = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'search',\n  'section',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n]\n\n/**\n * List of lowercase HTML “raw” tag names.\n *\n * The list, when parsing HTML (flow), results in HTML that can include lines\n * without exiting, until a closing tag also in this list is found (condition\n * 1).\n *\n * This module is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `textarea` was added in `CommonMark@0.30`.\n */\nexport const htmlRawNames = ['pre', 'script', 'style', 'textarea']\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\nimport {htmlBlockNames, htmlRawNames} from 'micromark-util-html-tag-name'\nimport {blankLine} from './blank-line.js'\n\n/** @type {Construct} */\nexport const htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n}\n\n/** @type {Construct} */\nconst blankLineBefore = {\n  tokenize: tokenizeBlankLineBefore,\n  partial: true\n}\nconst nonLazyContinuationStart = {\n  tokenize: tokenizeNonLazyContinuationStart,\n  partial: true\n}\n\n/** @type {Resolver} */\nfunction resolveToHtmlFlow(events) {\n  let index = events.length\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {\n      break\n    }\n  }\n  if (index > 1 && events[index - 2][1].type === 'linePrefix') {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start\n    // Add the prefix start to the HTML line token.\n    events[index + 1][1].start = events[index - 2][1].start\n    // Remove the line prefix.\n    events.splice(index - 2, 2)\n  }\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  const self = this\n  /** @type {number} */\n  let marker\n  /** @type {boolean} */\n  let closingTag\n  /** @type {string} */\n  let buffer\n  /** @type {number} */\n  let index\n  /** @type {Code} */\n  let markerB\n  return start\n\n  /**\n   * Start of HTML (flow).\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    return before(code)\n  }\n\n  /**\n   * At `<`, after optional whitespace.\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter('htmlFlow')\n    effects.enter('htmlFlowData')\n    effects.consume(code)\n    return open\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | <x />\n   *      ^\n   * > | <!doctype>\n   *      ^\n   * > | <!--xxx-->\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationOpen\n    }\n    if (code === 47) {\n      effects.consume(code)\n      closingTag = true\n      return tagCloseStart\n    }\n    if (code === 63) {\n      effects.consume(code)\n      marker = 3\n      // To do:\n      // tokenizer.concrete = true\n      // To do: use `markdown-rs` style interrupt.\n      // While we’re in an instruction instead of a declaration, we’re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      // @ts-expect-error: not null.\n      buffer = String.fromCharCode(code)\n      return tagName\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *       ^\n   * > | <!--xxx-->\n   *       ^\n   * > | <![CDATA[>&<]]>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      marker = 2\n      return commentOpenInside\n    }\n    if (code === 91) {\n      effects.consume(code)\n      marker = 5\n      index = 0\n      return cdataOpenInside\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      marker = 4\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `<!-`, inside a comment, at another `-`.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `<![`, inside CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *        ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = 'CDATA['\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code)\n      if (index === value.length) {\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok : continuation\n      }\n      return cdataOpenInside\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | </x>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      // @ts-expect-error: not null.\n      buffer = String.fromCharCode(code)\n      return tagName\n    }\n    return nok(code)\n  }\n\n  /**\n   * In tag name.\n   *\n   * ```markdown\n   * > | <ab>\n   *      ^^\n   * > | </ab>\n   *       ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagName(code) {\n    if (\n      code === null ||\n      code === 47 ||\n      code === 62 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      const slash = code === 47\n      const name = buffer.toLowerCase()\n      if (!slash && !closingTag && htmlRawNames.includes(name)) {\n        marker = 1\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n      if (htmlBlockNames.includes(buffer.toLowerCase())) {\n        marker = 6\n        if (slash) {\n          effects.consume(code)\n          return basicSelfClosing\n        }\n\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code)\n      }\n      marker = 7\n      // Do not support complete HTML when interrupting.\n      return self.interrupt && !self.parser.lazy[self.now().line]\n        ? nok(code)\n        : closingTag\n        ? completeClosingTagAfter(code)\n        : completeAttributeNameBefore(code)\n    }\n\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      buffer += String.fromCharCode(code)\n      return tagName\n    }\n    return nok(code)\n  }\n\n  /**\n   * After closing slash of a basic tag name.\n   *\n   * ```markdown\n   * > | <div/>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code)\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuation\n    }\n    return nok(code)\n  }\n\n  /**\n   * After closing slash of a complete tag name.\n   *\n   * ```markdown\n   * > | <x/>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeClosingTagAfter\n    }\n    return completeEnd(code)\n  }\n\n  /**\n   * At an attribute name.\n   *\n   * At first, this state is used after a complete tag name, after whitespace,\n   * where it expects optional attributes or the end of the tag.\n   * It is also reused after attributes, when expecting more optional\n   * attributes.\n   *\n   * ```markdown\n   * > | <a />\n   *        ^\n   * > | <a :b>\n   *        ^\n   * > | <a _b>\n   *        ^\n   * > | <a b>\n   *        ^\n   * > | <a >\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return completeEnd\n    }\n\n    // ASCII alphanumerical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameBefore\n    }\n    return completeEnd(code)\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | <a :b>\n   *         ^\n   * > | <a _b>\n   *         ^\n   * > | <a b>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeName(code) {\n    // ASCII alphanumerical and `-`, `.`, `:`, and `_`.\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return completeAttributeName\n    }\n    return completeAttributeNameAfter(code)\n  }\n\n  /**\n   * After attribute name, at an optional initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b>\n   *         ^\n   * > | <a b=c>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeNameAfter\n    }\n    return completeAttributeNameBefore(code)\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * > | <a b=\"c\">\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      markerB = code\n      return completeAttributeValueQuoted\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAttributeValueBefore\n    }\n    return completeAttributeValueUnquoted(code)\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *           ^\n   * > | <a b='c'>\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuoted(code) {\n    if (code === markerB) {\n      effects.consume(code)\n      markerB = null\n      return completeAttributeValueQuotedAfter\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return completeAttributeValueQuoted\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 47 ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96 ||\n      markdownLineEndingOrSpace(code)\n    ) {\n      return completeAttributeNameAfter(code)\n    }\n    effects.consume(code)\n    return completeAttributeValueUnquoted\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the\n   * end of the tag.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * In certain circumstances of a complete tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return completeAfter\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `>` in a complete tag.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return continuation(code)\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return completeAfter\n    }\n    return nok(code)\n  }\n\n  /**\n   * In continuation of any HTML kind.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuation(code) {\n    if (code === 45 && marker === 2) {\n      effects.consume(code)\n      return continuationCommentInside\n    }\n    if (code === 60 && marker === 1) {\n      effects.consume(code)\n      return continuationRawTagOpen\n    }\n    if (code === 62 && marker === 4) {\n      effects.consume(code)\n      return continuationClose\n    }\n    if (code === 63 && marker === 3) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n    if (code === 93 && marker === 5) {\n      effects.consume(code)\n      return continuationCdataInside\n    }\n    if (markdownLineEnding(code) && (marker === 6 || marker === 7)) {\n      effects.exit('htmlFlowData')\n      return effects.check(\n        blankLineBefore,\n        continuationAfter,\n        continuationStart\n      )(code)\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData')\n      return continuationStart(code)\n    }\n    effects.consume(code)\n    return continuation\n  }\n\n  /**\n   * In continuation, at eol.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStart(code) {\n    return effects.check(\n      nonLazyContinuationStart,\n      continuationStartNonLazy,\n      continuationAfter\n    )(code)\n  }\n\n  /**\n   * In continuation, at eol, before non-lazy content.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStartNonLazy(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return continuationBefore\n  }\n\n  /**\n   * In continuation, before non-lazy content.\n   *\n   * ```markdown\n   *   | <x>\n   * > | asd\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return continuationStart(code)\n    }\n    effects.enter('htmlFlowData')\n    return continuation(code)\n  }\n\n  /**\n   * In comment continuation, after one `-`, expecting another.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n    return continuation(code)\n  }\n\n  /**\n   * In raw continuation, after `<`, at `/`.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code)\n      buffer = ''\n      return continuationRawEndTag\n    }\n    return continuation(code)\n  }\n\n  /**\n   * In raw continuation, after `</`, in a raw tag name.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                             ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawEndTag(code) {\n    if (code === 62) {\n      const name = buffer.toLowerCase()\n      if (htmlRawNames.includes(name)) {\n        effects.consume(code)\n        return continuationClose\n      }\n      return continuation(code)\n    }\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code)\n      // @ts-expect-error: not null.\n      buffer += String.fromCharCode(code)\n      return continuationRawEndTag\n    }\n    return continuation(code)\n  }\n\n  /**\n   * In cdata continuation, after `]`, expecting `]>`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *                  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCdataInside(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n    return continuation(code)\n  }\n\n  /**\n   * In declaration or instruction continuation, at `>`.\n   *\n   * ```markdown\n   * > | <!-->\n   *         ^\n   * > | <?>\n   *       ^\n   * > | <!q>\n   *        ^\n   * > | <!--ab-->\n   *             ^\n   * > | <![CDATA[>&<]]>\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code)\n      return continuationClose\n    }\n\n    // More dashes.\n    if (code === 45 && marker === 2) {\n      effects.consume(code)\n      return continuationDeclarationInside\n    }\n    return continuation(code)\n  }\n\n  /**\n   * In closed continuation: everything we get until the eol/eof is part of it.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData')\n      return continuationAfter(code)\n    }\n    effects.consume(code)\n    return continuationClose\n  }\n\n  /**\n   * Done.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationAfter(code) {\n    effects.exit('htmlFlow')\n    // // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    // // No longer concrete.\n    // tokenizer.concrete = false\n    return ok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuationStart(effects, ok, nok) {\n  const self = this\n  return start\n\n  /**\n   * At eol, before continuation.\n   *\n   * ```markdown\n   * > | * ```js\n   *            ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return after\n    }\n    return nok(code)\n  }\n\n  /**\n   * A continuation.\n   *\n   * ```markdown\n   *   | * ```js\n   * > | b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLineBefore(effects, ok, nok) {\n  return start\n\n  /**\n   * Before eol, expecting blank line.\n   *\n   * ```markdown\n   * > | <div>\n   *          ^\n   *   |\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return effects.attempt(blankLine, ok, nok)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding, markdownSpace} from 'micromark-util-character'\n/** @type {Construct} */\nconst nonLazyContinuation = {\n  tokenize: tokenizeNonLazyContinuation,\n  partial: true\n}\n\n/** @type {Construct} */\nexport const codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  const self = this\n  /** @type {Construct} */\n  const closeStart = {\n    tokenize: tokenizeCloseStart,\n    partial: true\n  }\n  let initialPrefix = 0\n  let sizeOpen = 0\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n\n  /**\n   * Start of code.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse whitespace like `markdown-rs`.\n    return beforeSequenceOpen(code)\n  }\n\n  /**\n   * In opening fence, after prefix, at sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeSequenceOpen(code) {\n    const tail = self.events[self.events.length - 1]\n    initialPrefix =\n      tail && tail[1].type === 'linePrefix'\n        ? tail[2].sliceSerialize(tail[1], true).length\n        : 0\n    marker = code\n    effects.enter('codeFenced')\n    effects.enter('codeFencedFence')\n    effects.enter('codeFencedFenceSequence')\n    return sequenceOpen(code)\n  }\n\n  /**\n   * In opening fence sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *      ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === marker) {\n      sizeOpen++\n      effects.consume(code)\n      return sequenceOpen\n    }\n    if (sizeOpen < 3) {\n      return nok(code)\n    }\n    effects.exit('codeFencedFenceSequence')\n    return markdownSpace(code)\n      ? factorySpace(effects, infoBefore, 'whitespace')(code)\n      : infoBefore(code)\n  }\n\n  /**\n   * In opening fence, after the sequence (and optional whitespace), before info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function infoBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFencedFence')\n      return self.interrupt\n        ? ok(code)\n        : effects.check(nonLazyContinuation, atNonLazyBreak, after)(code)\n    }\n    effects.enter('codeFencedFenceInfo')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return info(code)\n  }\n\n  /**\n   * In info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function info(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceInfo')\n      return infoBefore(code)\n    }\n    if (markdownSpace(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceInfo')\n      return factorySpace(effects, metaBefore, 'whitespace')(code)\n    }\n    if (code === 96 && code === marker) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return info\n  }\n\n  /**\n   * In opening fence, after info and whitespace, before meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function metaBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return infoBefore(code)\n    }\n    effects.enter('codeFencedFenceMeta')\n    effects.enter('chunkString', {\n      contentType: 'string'\n    })\n    return meta(code)\n  }\n\n  /**\n   * In meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString')\n      effects.exit('codeFencedFenceMeta')\n      return infoBefore(code)\n    }\n    if (code === 96 && code === marker) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return meta\n  }\n\n  /**\n   * At eol/eof in code, before a non-lazy closing fence or content.\n   *\n   * ```markdown\n   * > | ~~~js\n   *          ^\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function atNonLazyBreak(code) {\n    return effects.attempt(closeStart, after, contentBefore)(code)\n  }\n\n  /**\n   * Before code content, not a closing fence, at eol.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentBefore(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return contentStart\n  }\n\n  /**\n   * Before code content, not a closing fence.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentStart(code) {\n    return initialPrefix > 0 && markdownSpace(code)\n      ? factorySpace(\n          effects,\n          beforeContentChunk,\n          'linePrefix',\n          initialPrefix + 1\n        )(code)\n      : beforeContentChunk(code)\n  }\n\n  /**\n   * Before code content, after optional prefix.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeContentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return effects.check(nonLazyContinuation, atNonLazyBreak, after)(code)\n    }\n    effects.enter('codeFlowValue')\n    return contentChunk(code)\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^^^^^^^^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue')\n      return beforeContentChunk(code)\n    }\n    effects.consume(code)\n    return contentChunk\n  }\n\n  /**\n   * After code.\n   *\n   * ```markdown\n   *   | ~~~js\n   *   | alert(1)\n   * > | ~~~\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    effects.exit('codeFenced')\n    return ok(code)\n  }\n\n  /**\n   * @this {TokenizeContext}\n   * @type {Tokenizer}\n   */\n  function tokenizeCloseStart(effects, ok, nok) {\n    let size = 0\n    return startBefore\n\n    /**\n     *\n     *\n     * @type {State}\n     */\n    function startBefore(code) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return start\n    }\n\n    /**\n     * Before closing fence, at optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function start(code) {\n      // Always populated by defaults.\n\n      // To do: `enter` here or in next state?\n      effects.enter('codeFencedFence')\n      return markdownSpace(code)\n        ? factorySpace(\n            effects,\n            beforeSequenceClose,\n            'linePrefix',\n            self.parser.constructs.disable.null.includes('codeIndented')\n              ? undefined\n              : 4\n          )(code)\n        : beforeSequenceClose(code)\n    }\n\n    /**\n     * In closing fence, after optional whitespace, at sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function beforeSequenceClose(code) {\n      if (code === marker) {\n        effects.enter('codeFencedFenceSequence')\n        return sequenceClose(code)\n      }\n      return nok(code)\n    }\n\n    /**\n     * In closing fence sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceClose(code) {\n      if (code === marker) {\n        size++\n        effects.consume(code)\n        return sequenceClose\n      }\n      if (size >= sizeOpen) {\n        effects.exit('codeFencedFenceSequence')\n        return markdownSpace(code)\n          ? factorySpace(effects, sequenceCloseAfter, 'whitespace')(code)\n          : sequenceCloseAfter(code)\n      }\n      return nok(code)\n    }\n\n    /**\n     * After closing fence sequence, after optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *        ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceCloseAfter(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit('codeFencedFence')\n        return ok(code)\n      }\n      return nok(code)\n    }\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuation(effects, ok, nok) {\n  const self = this\n  return start\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === null) {\n      return nok(code)\n    }\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return lineStart\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function lineStart(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {\n  asciiAlphanumeric,\n  asciiDigit,\n  asciiHexDigit\n} from 'micromark-util-character'\n/** @type {Construct} */\nexport const characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  const self = this\n  let size = 0\n  /** @type {number} */\n  let max\n  /** @type {(code: Code) => boolean} */\n  let test\n  return start\n\n  /**\n   * Start of character reference.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *      ^\n   * > | a&#123;b\n   *      ^\n   * > | a&#x9;b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('characterReference')\n    effects.enter('characterReferenceMarker')\n    effects.consume(code)\n    effects.exit('characterReferenceMarker')\n    return open\n  }\n\n  /**\n   * After `&`, at `#` for numeric references or alphanumeric for named\n   * references.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^\n   * > | a&#123;b\n   *       ^\n   * > | a&#x9;b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 35) {\n      effects.enter('characterReferenceMarkerNumeric')\n      effects.consume(code)\n      effects.exit('characterReferenceMarkerNumeric')\n      return numeric\n    }\n    effects.enter('characterReferenceValue')\n    max = 31\n    test = asciiAlphanumeric\n    return value(code)\n  }\n\n  /**\n   * After `#`, at `x` for hexadecimals or digit for decimals.\n   *\n   * ```markdown\n   * > | a&#123;b\n   *        ^\n   * > | a&#x9;b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter('characterReferenceMarkerHexadecimal')\n      effects.consume(code)\n      effects.exit('characterReferenceMarkerHexadecimal')\n      effects.enter('characterReferenceValue')\n      max = 6\n      test = asciiHexDigit\n      return value\n    }\n    effects.enter('characterReferenceValue')\n    max = 7\n    test = asciiDigit\n    return value(code)\n  }\n\n  /**\n   * After markers (`&#x`, `&#`, or `&`), in value, before `;`.\n   *\n   * The character reference kind defines what and how many characters are\n   * allowed.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^^^\n   * > | a&#123;b\n   *        ^^^\n   * > | a&#x9;b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function value(code) {\n    if (code === 59 && size) {\n      const token = effects.exit('characterReferenceValue')\n      if (\n        test === asciiAlphanumeric &&\n        !decodeNamedCharacterReference(self.sliceSerialize(token))\n      ) {\n        return nok(code)\n      }\n\n      // To do: `markdown-rs` uses a different name:\n      // `CharacterReferenceMarkerSemi`.\n      effects.enter('characterReferenceMarker')\n      effects.consume(code)\n      effects.exit('characterReferenceMarker')\n      effects.exit('characterReference')\n      return ok\n    }\n    if (test(code) && size++ < max) {\n      effects.consume(code)\n      return value\n    }\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {asciiPunctuation} from 'micromark-util-character'\n/** @type {Construct} */\nexport const characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start\n\n  /**\n   * Start of character escape.\n   *\n   * ```markdown\n   * > | a\\*b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('characterEscape')\n    effects.enter('escapeMarker')\n    effects.consume(code)\n    effects.exit('escapeMarker')\n    return inside\n  }\n\n  /**\n   * After `\\`, at punctuation.\n   *\n   * ```markdown\n   * > | a\\*b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    // ASCII punctuation.\n    if (asciiPunctuation(code)) {\n      effects.enter('characterEscapeValue')\n      effects.consume(code)\n      effects.exit('characterEscapeValue')\n      effects.exit('characterEscape')\n      return ok\n    }\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {markdownLineEnding} from 'micromark-util-character'\n/** @type {Construct} */\nexport const lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLineEnding(effects, ok) {\n  return start\n\n  /** @type {State} */\n  function start(code) {\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return factorySpace(effects, ok, 'linePrefix')\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factoryDestination} from 'micromark-factory-destination'\nimport {factoryLabel} from 'micromark-factory-label'\nimport {factoryTitle} from 'micromark-factory-title'\nimport {factoryWhitespace} from 'micromark-factory-whitespace'\nimport {markdownLineEndingOrSpace} from 'micromark-util-character'\nimport {push, splice} from 'micromark-util-chunked'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {resolveAll} from 'micromark-util-resolve-all'\n/** @type {Construct} */\nexport const labelEnd = {\n  name: 'labelEnd',\n  tokenize: tokenizeLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  resolveAll: resolveAllLabelEnd\n}\n\n/** @type {Construct} */\nconst resourceConstruct = {\n  tokenize: tokenizeResource\n}\n/** @type {Construct} */\nconst referenceFullConstruct = {\n  tokenize: tokenizeReferenceFull\n}\n/** @type {Construct} */\nconst referenceCollapsedConstruct = {\n  tokenize: tokenizeReferenceCollapsed\n}\n\n/** @type {Resolver} */\nfunction resolveAllLabelEnd(events) {\n  let index = -1\n  while (++index < events.length) {\n    const token = events[index][1]\n    if (\n      token.type === 'labelImage' ||\n      token.type === 'labelLink' ||\n      token.type === 'labelEnd'\n    ) {\n      // Remove the marker.\n      events.splice(index + 1, token.type === 'labelImage' ? 4 : 2)\n      token.type = 'data'\n      index++\n    }\n  }\n  return events\n}\n\n/** @type {Resolver} */\nfunction resolveToLabelEnd(events, context) {\n  let index = events.length\n  let offset = 0\n  /** @type {Token} */\n  let token\n  /** @type {number | undefined} */\n  let open\n  /** @type {number | undefined} */\n  let close\n  /** @type {Array<Event>} */\n  let media\n\n  // Find an opening.\n  while (index--) {\n    token = events[index][1]\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (\n        token.type === 'link' ||\n        (token.type === 'labelLink' && token._inactive)\n      ) {\n        break\n      }\n\n      // Mark other link openings as inactive, as we can’t have links in\n      // links.\n      if (events[index][0] === 'enter' && token.type === 'labelLink') {\n        token._inactive = true\n      }\n    } else if (close) {\n      if (\n        events[index][0] === 'enter' &&\n        (token.type === 'labelImage' || token.type === 'labelLink') &&\n        !token._balanced\n      ) {\n        open = index\n        if (token.type !== 'labelLink') {\n          offset = 2\n          break\n        }\n      }\n    } else if (token.type === 'labelEnd') {\n      close = index\n    }\n  }\n  const group = {\n    type: events[open][1].type === 'labelLink' ? 'link' : 'image',\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  }\n  const label = {\n    type: 'label',\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[close][1].end)\n  }\n  const text = {\n    type: 'labelText',\n    start: Object.assign({}, events[open + offset + 2][1].end),\n    end: Object.assign({}, events[close - 2][1].start)\n  }\n  media = [\n    ['enter', group, context],\n    ['enter', label, context]\n  ]\n\n  // Opening marker.\n  media = push(media, events.slice(open + 1, open + offset + 3))\n\n  // Text open.\n  media = push(media, [['enter', text, context]])\n\n  // Always populated by defaults.\n\n  // Between.\n  media = push(\n    media,\n    resolveAll(\n      context.parser.constructs.insideSpan.null,\n      events.slice(open + offset + 4, close - 3),\n      context\n    )\n  )\n\n  // Text close, marker close, label close.\n  media = push(media, [\n    ['exit', text, context],\n    events[close - 2],\n    events[close - 1],\n    ['exit', label, context]\n  ])\n\n  // Reference, resource, or so.\n  media = push(media, events.slice(close + 1))\n\n  // Media close.\n  media = push(media, [['exit', group, context]])\n  splice(events, open, events.length, media)\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  const self = this\n  let index = self.events.length\n  /** @type {Token} */\n  let labelStart\n  /** @type {boolean} */\n  let defined\n\n  // Find an opening.\n  while (index--) {\n    if (\n      (self.events[index][1].type === 'labelImage' ||\n        self.events[index][1].type === 'labelLink') &&\n      !self.events[index][1]._balanced\n    ) {\n      labelStart = self.events[index][1]\n      break\n    }\n  }\n  return start\n\n  /**\n   * Start of label end.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // If there is not an okay opening.\n    if (!labelStart) {\n      return nok(code)\n    }\n\n    // If the corresponding label (link) start is marked as inactive,\n    // it means we’d be wrapping a link, like this:\n    //\n    // ```markdown\n    // > | a [b [c](d) e](f) g.\n    //                  ^\n    // ```\n    //\n    // We can’t have that, so it’s just balanced brackets.\n    if (labelStart._inactive) {\n      return labelEndNok(code)\n    }\n    defined = self.parser.defined.includes(\n      normalizeIdentifier(\n        self.sliceSerialize({\n          start: labelStart.end,\n          end: self.now()\n        })\n      )\n    )\n    effects.enter('labelEnd')\n    effects.enter('labelMarker')\n    effects.consume(code)\n    effects.exit('labelMarker')\n    effects.exit('labelEnd')\n    return after\n  }\n\n  /**\n   * After `]`.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // Note: `markdown-rs` also parses GFM footnotes here, which for us is in\n    // an extension.\n\n    // Resource (`[asd](fgh)`)?\n    if (code === 40) {\n      return effects.attempt(\n        resourceConstruct,\n        labelEndOk,\n        defined ? labelEndOk : labelEndNok\n      )(code)\n    }\n\n    // Full (`[asd][fgh]`) or collapsed (`[asd][]`) reference?\n    if (code === 91) {\n      return effects.attempt(\n        referenceFullConstruct,\n        labelEndOk,\n        defined ? referenceNotFull : labelEndNok\n      )(code)\n    }\n\n    // Shortcut (`[asd]`) reference?\n    return defined ? labelEndOk(code) : labelEndNok(code)\n  }\n\n  /**\n   * After `]`, at `[`, but not at a full reference.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] b\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceNotFull(code) {\n    return effects.attempt(\n      referenceCollapsedConstruct,\n      labelEndOk,\n      labelEndNok\n    )(code)\n  }\n\n  /**\n   * Done, we found something.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *           ^\n   * > | [a][b] c\n   *           ^\n   * > | [a][] b\n   *          ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndOk(code) {\n    // Note: `markdown-rs` does a bunch of stuff here.\n    return ok(code)\n  }\n\n  /**\n   * Done, it’s nothing.\n   *\n   * There was an okay opening, but we didn’t match anything.\n   *\n   * ```markdown\n   * > | [a](b c\n   *        ^\n   * > | [a][b c\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndNok(code) {\n    labelStart._balanced = true\n    return nok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeResource(effects, ok, nok) {\n  return resourceStart\n\n  /**\n   * At a resource.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceStart(code) {\n    effects.enter('resource')\n    effects.enter('resourceMarker')\n    effects.consume(code)\n    effects.exit('resourceMarker')\n    return resourceBefore\n  }\n\n  /**\n   * In resource, after `(`, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBefore(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, resourceOpen)(code)\n      : resourceOpen(code)\n  }\n\n  /**\n   * In resource, after optional whitespace, at `)` or a destination.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceOpen(code) {\n    if (code === 41) {\n      return resourceEnd(code)\n    }\n    return factoryDestination(\n      effects,\n      resourceDestinationAfter,\n      resourceDestinationMissing,\n      'resourceDestination',\n      'resourceDestinationLiteral',\n      'resourceDestinationLiteralMarker',\n      'resourceDestinationRaw',\n      'resourceDestinationString',\n      32\n    )(code)\n  }\n\n  /**\n   * In resource, after destination, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationAfter(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, resourceBetween)(code)\n      : resourceEnd(code)\n  }\n\n  /**\n   * At invalid destination.\n   *\n   * ```markdown\n   * > | [a](<<) b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationMissing(code) {\n    return nok(code)\n  }\n\n  /**\n   * In resource, after destination and whitespace, at `(` or title.\n   *\n   * ```markdown\n   * > | [a](b ) c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBetween(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(\n        effects,\n        resourceTitleAfter,\n        nok,\n        'resourceTitle',\n        'resourceTitleMarker',\n        'resourceTitleString'\n      )(code)\n    }\n    return resourceEnd(code)\n  }\n\n  /**\n   * In resource, after title, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b \"c\") d\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceTitleAfter(code) {\n    return markdownLineEndingOrSpace(code)\n      ? factoryWhitespace(effects, resourceEnd)(code)\n      : resourceEnd(code)\n  }\n\n  /**\n   * In resource, at `)`.\n   *\n   * ```markdown\n   * > | [a](b) d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceEnd(code) {\n    if (code === 41) {\n      effects.enter('resourceMarker')\n      effects.consume(code)\n      effects.exit('resourceMarker')\n      effects.exit('resource')\n      return ok\n    }\n    return nok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceFull(effects, ok, nok) {\n  const self = this\n  return referenceFull\n\n  /**\n   * In a reference (full), at the `[`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFull(code) {\n    return factoryLabel.call(\n      self,\n      effects,\n      referenceFullAfter,\n      referenceFullMissing,\n      'reference',\n      'referenceMarker',\n      'referenceString'\n    )(code)\n  }\n\n  /**\n   * In a reference (full), after `]`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullAfter(code) {\n    return self.parser.defined.includes(\n      normalizeIdentifier(\n        self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)\n      )\n    )\n      ? ok(code)\n      : nok(code)\n  }\n\n  /**\n   * In reference (full) that was missing.\n   *\n   * ```markdown\n   * > | [a][b d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullMissing(code) {\n    return nok(code)\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceCollapsed(effects, ok, nok) {\n  return referenceCollapsedStart\n\n  /**\n   * In reference (collapsed), at `[`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceCollapsedStart(code) {\n    // We only attempt a collapsed label if there’s a `[`.\n\n    effects.enter('reference')\n    effects.enter('referenceMarker')\n    effects.consume(code)\n    effects.exit('referenceMarker')\n    return referenceCollapsedOpen\n  }\n\n  /**\n   * In reference (collapsed), at `]`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *         ^\n   * ```\n   *\n   *  @type {State}\n   */\n  function referenceCollapsedOpen(code) {\n    if (code === 93) {\n      effects.enter('referenceMarker')\n      effects.consume(code)\n      effects.exit('referenceMarker')\n      effects.exit('reference')\n      return ok\n    }\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\n\nimport {\n  markdownLineEndingOrSpace,\n  unicodePunctuation,\n  unicodeWhitespace\n} from 'micromark-util-character'\n/**\n * Classify whether a code represents whitespace, punctuation, or something\n * else.\n *\n * Used for attention (emphasis, strong), whose sequences can open or close\n * based on the class of surrounding characters.\n *\n * > 👉 **Note**: eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n *   Code.\n * @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined}\n *   Group.\n */\nexport function classifyCharacter(code) {\n  if (\n    code === null ||\n    markdownLineEndingOrSpace(code) ||\n    unicodeWhitespace(code)\n  ) {\n    return 1\n  }\n  if (unicodePunctuation(code)) {\n    return 2\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {push, splice} from 'micromark-util-chunked'\nimport {classifyCharacter} from 'micromark-util-classify-character'\nimport {resolveAll} from 'micromark-util-resolve-all'\n/** @type {Construct} */\nexport const attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\n}\n\n/**\n * Take all events and resolve attention to emphasis or strong.\n *\n * @type {Resolver}\n */\nfunction resolveAllAttention(events, context) {\n  let index = -1\n  /** @type {number} */\n  let open\n  /** @type {Token} */\n  let group\n  /** @type {Token} */\n  let text\n  /** @type {Token} */\n  let openingSequence\n  /** @type {Token} */\n  let closingSequence\n  /** @type {number} */\n  let use\n  /** @type {Array<Event>} */\n  let nextEvents\n  /** @type {number} */\n  let offset\n\n  // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it’s\n  // a bottleneck for malicious stuff.\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (\n      events[index][0] === 'enter' &&\n      events[index][1].type === 'attentionSequence' &&\n      events[index][1]._close\n    ) {\n      open = index\n\n      // Now walk back to find an opener.\n      while (open--) {\n        // Find a token that can open the closer.\n        if (\n          events[open][0] === 'exit' &&\n          events[open][1].type === 'attentionSequence' &&\n          events[open][1]._open &&\n          // If the markers are the same:\n          context.sliceSerialize(events[open][1]).charCodeAt(0) ===\n            context.sliceSerialize(events[index][1]).charCodeAt(0)\n        ) {\n          // If the opening can close or the closing can open,\n          // and the close size *is not* a multiple of three,\n          // but the sum of the opening and closing size *is* multiple of three,\n          // then don’t match.\n          if (\n            (events[open][1]._close || events[index][1]._open) &&\n            (events[index][1].end.offset - events[index][1].start.offset) % 3 &&\n            !(\n              (events[open][1].end.offset -\n                events[open][1].start.offset +\n                events[index][1].end.offset -\n                events[index][1].start.offset) %\n              3\n            )\n          ) {\n            continue\n          }\n\n          // Number of markers to use from the sequence.\n          use =\n            events[open][1].end.offset - events[open][1].start.offset > 1 &&\n            events[index][1].end.offset - events[index][1].start.offset > 1\n              ? 2\n              : 1\n          const start = Object.assign({}, events[open][1].end)\n          const end = Object.assign({}, events[index][1].start)\n          movePoint(start, -use)\n          movePoint(end, use)\n          openingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start,\n            end: Object.assign({}, events[open][1].end)\n          }\n          closingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: Object.assign({}, events[index][1].start),\n            end\n          }\n          text = {\n            type: use > 1 ? 'strongText' : 'emphasisText',\n            start: Object.assign({}, events[open][1].end),\n            end: Object.assign({}, events[index][1].start)\n          }\n          group = {\n            type: use > 1 ? 'strong' : 'emphasis',\n            start: Object.assign({}, openingSequence.start),\n            end: Object.assign({}, closingSequence.end)\n          }\n          events[open][1].end = Object.assign({}, openingSequence.start)\n          events[index][1].start = Object.assign({}, closingSequence.end)\n          nextEvents = []\n\n          // If there are more markers in the opening, add them before.\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = push(nextEvents, [\n              ['enter', events[open][1], context],\n              ['exit', events[open][1], context]\n            ])\n          }\n\n          // Opening.\n          nextEvents = push(nextEvents, [\n            ['enter', group, context],\n            ['enter', openingSequence, context],\n            ['exit', openingSequence, context],\n            ['enter', text, context]\n          ])\n\n          // Always populated by defaults.\n\n          // Between.\n          nextEvents = push(\n            nextEvents,\n            resolveAll(\n              context.parser.constructs.insideSpan.null,\n              events.slice(open + 1, index),\n              context\n            )\n          )\n\n          // Closing.\n          nextEvents = push(nextEvents, [\n            ['exit', text, context],\n            ['enter', closingSequence, context],\n            ['exit', closingSequence, context],\n            ['exit', group, context]\n          ])\n\n          // If there are more markers in the closing, add them after.\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2\n            nextEvents = push(nextEvents, [\n              ['enter', events[index][1], context],\n              ['exit', events[index][1], context]\n            ])\n          } else {\n            offset = 0\n          }\n          splice(events, open - 1, index - open + 3, nextEvents)\n          index = open + nextEvents.length - offset - 2\n          break\n        }\n      }\n    }\n  }\n\n  // Remove remaining sequences.\n  index = -1\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data'\n    }\n  }\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeAttention(effects, ok) {\n  const attentionMarkers = this.parser.constructs.attentionMarkers.null\n  const previous = this.previous\n  const before = classifyCharacter(previous)\n\n  /** @type {NonNullable<Code>} */\n  let marker\n  return start\n\n  /**\n   * Before a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    marker = code\n    effects.enter('attentionSequence')\n    return inside(code)\n  }\n\n  /**\n   * In a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code)\n      return inside\n    }\n    const token = effects.exit('attentionSequence')\n\n    // To do: next major: move this to resolver, just like `markdown-rs`.\n    const after = classifyCharacter(code)\n\n    // Always populated by defaults.\n\n    const open =\n      !after || (after === 2 && before) || attentionMarkers.includes(code)\n    const close =\n      !before || (before === 2 && after) || attentionMarkers.includes(previous)\n    token._open = Boolean(marker === 42 ? open : open && (before || !close))\n    token._close = Boolean(marker === 42 ? close : close && (after || !open))\n    return ok(code)\n  }\n}\n\n/**\n * Move a point a bit.\n *\n * Note: `move` only works inside lines! It’s not possible to move past other\n * chunks (replacement characters, tabs, or line endings).\n *\n * @param {Point} point\n * @param {number} offset\n * @returns {void}\n */\nfunction movePoint(point, offset) {\n  point.column += offset\n  point.offset += offset\n  point._bufferIndex += offset\n}\n","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {factorySpace} from 'micromark-factory-space'\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  markdownLineEnding,\n  markdownLineEndingOrSpace,\n  markdownSpace\n} from 'micromark-util-character'\n/** @type {Construct} */\nexport const htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlText(effects, ok, nok) {\n  const self = this\n  /** @type {NonNullable<Code> | undefined} */\n  let marker\n  /** @type {number} */\n  let index\n  /** @type {State} */\n  let returnState\n  return start\n\n  /**\n   * Start of HTML (text).\n   *\n   * ```markdown\n   * > | a <b> c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('htmlText')\n    effects.enter('htmlTextData')\n    effects.consume(code)\n    return open\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | a <b> c\n   *        ^\n   * > | a <!doctype> c\n   *        ^\n   * > | a <!--b--> c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code)\n      return declarationOpen\n    }\n    if (code === 47) {\n      effects.consume(code)\n      return tagCloseStart\n    }\n    if (code === 63) {\n      effects.consume(code)\n      return instruction\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | a <!doctype> c\n   *         ^\n   * > | a <!--b--> c\n   *         ^\n   * > | a <![CDATA[>&<]]> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentOpenInside\n    }\n    if (code === 91) {\n      effects.consume(code)\n      index = 0\n      return cdataOpenInside\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return declaration\n    }\n    return nok(code)\n  }\n\n  /**\n   * In a comment, after `<!-`, at another `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentEnd\n    }\n    return nok(code)\n  }\n\n  /**\n   * In comment.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function comment(code) {\n    if (code === null) {\n      return nok(code)\n    }\n    if (code === 45) {\n      effects.consume(code)\n      return commentClose\n    }\n    if (markdownLineEnding(code)) {\n      returnState = comment\n      return lineEndingBefore(code)\n    }\n    effects.consume(code)\n    return comment\n  }\n\n  /**\n   * In comment, after `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code)\n      return commentEnd\n    }\n    return comment(code)\n  }\n\n  /**\n   * In comment, after `--`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentEnd(code) {\n    return code === 62\n      ? end(code)\n      : code === 45\n      ? commentClose(code)\n      : comment(code)\n  }\n\n  /**\n   * After `<![`, in CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *          ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = 'CDATA['\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code)\n      return index === value.length ? cdata : cdataOpenInside\n    }\n    return nok(code)\n  }\n\n  /**\n   * In CDATA.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdata(code) {\n    if (code === null) {\n      return nok(code)\n    }\n    if (code === 93) {\n      effects.consume(code)\n      return cdataClose\n    }\n    if (markdownLineEnding(code)) {\n      returnState = cdata\n      return lineEndingBefore(code)\n    }\n    effects.consume(code)\n    return cdata\n  }\n\n  /**\n   * In CDATA, after `]`, at another `]`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n    return cdata(code)\n  }\n\n  /**\n   * In CDATA, after `]]`, at `>`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code)\n    }\n    if (code === 93) {\n      effects.consume(code)\n      return cdataEnd\n    }\n    return cdata(code)\n  }\n\n  /**\n   * In declaration.\n   *\n   * ```markdown\n   * > | a <!b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code)\n    }\n    if (markdownLineEnding(code)) {\n      returnState = declaration\n      return lineEndingBefore(code)\n    }\n    effects.consume(code)\n    return declaration\n  }\n\n  /**\n   * In instruction.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instruction(code) {\n    if (code === null) {\n      return nok(code)\n    }\n    if (code === 63) {\n      effects.consume(code)\n      return instructionClose\n    }\n    if (markdownLineEnding(code)) {\n      returnState = instruction\n      return lineEndingBefore(code)\n    }\n    effects.consume(code)\n    return instruction\n  }\n\n  /**\n   * In instruction, after `?`, at `>`.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code)\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `</x`, in a tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagClose(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagClose\n    }\n    return tagCloseBetween(code)\n  }\n\n  /**\n   * In closing tag, after tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween\n      return lineEndingBefore(code)\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagCloseBetween\n    }\n    return end(code)\n  }\n\n  /**\n   * After `<x`, in opening tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpen(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code)\n      return tagOpen\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * In opening tag, after tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code)\n      return end\n    }\n\n    // ASCII alphabetical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween\n      return lineEndingBefore(code)\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenBetween\n    }\n    return end(code)\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeName(code) {\n    // ASCII alphabetical and `-`, `.`, `:`, and `_`.\n    if (\n      code === 45 ||\n      code === 46 ||\n      code === 58 ||\n      code === 95 ||\n      asciiAlphanumeric(code)\n    ) {\n      effects.consume(code)\n      return tagOpenAttributeName\n    }\n    return tagOpenAttributeNameAfter(code)\n  }\n\n  /**\n   * After attribute name, before initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter\n      return lineEndingBefore(code)\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeNameAfter\n    }\n    return tagOpenBetween(code)\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueBefore(code) {\n    if (\n      code === null ||\n      code === 60 ||\n      code === 61 ||\n      code === 62 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code)\n      marker = code\n      return tagOpenAttributeValueQuoted\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore\n      return lineEndingBefore(code)\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code)\n      return tagOpenAttributeValueBefore\n    }\n    effects.consume(code)\n    return tagOpenAttributeValueUnquoted\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code)\n      marker = undefined\n      return tagOpenAttributeValueQuotedAfter\n    }\n    if (code === null) {\n      return nok(code)\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted\n      return lineEndingBefore(code)\n    }\n    effects.consume(code)\n    return tagOpenAttributeValueQuoted\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueUnquoted(code) {\n    if (\n      code === null ||\n      code === 34 ||\n      code === 39 ||\n      code === 60 ||\n      code === 61 ||\n      code === 96\n    ) {\n      return nok(code)\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n    effects.consume(code)\n    return tagOpenAttributeValueUnquoted\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the end\n   * of the tag.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code)\n    }\n    return nok(code)\n  }\n\n  /**\n   * In certain circumstances of a tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function end(code) {\n    if (code === 62) {\n      effects.consume(code)\n      effects.exit('htmlTextData')\n      effects.exit('htmlText')\n      return ok\n    }\n    return nok(code)\n  }\n\n  /**\n   * At eol.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   * > | a <!--a\n   *            ^\n   *   | b-->\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingBefore(code) {\n    effects.exit('htmlTextData')\n    effects.enter('lineEnding')\n    effects.consume(code)\n    effects.exit('lineEnding')\n    return lineEndingAfter\n  }\n\n  /**\n   * After eol, at optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfter(code) {\n    // Always populated by defaults.\n\n    return markdownSpace(code)\n      ? factorySpace(\n          effects,\n          lineEndingAfterPrefix,\n          'linePrefix',\n          self.parser.constructs.disable.null.includes('codeIndented')\n            ? undefined\n            : 4\n        )(code)\n      : lineEndingAfterPrefix(code)\n  }\n\n  /**\n   * After eol, after optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfterPrefix(code) {\n    effects.enter('htmlTextData')\n    return returnState(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Previous} Previous\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {markdownLineEnding} from 'micromark-util-character'\n/** @type {Construct} */\nexport const codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous\n}\n\n// To do: next major: don’t resolve, like `markdown-rs`.\n/** @type {Resolver} */\nfunction resolveCodeText(events) {\n  let tailExitIndex = events.length - 4\n  let headEnterIndex = 3\n  /** @type {number} */\n  let index\n  /** @type {number | undefined} */\n  let enter\n\n  // If we start and end with an EOL or a space.\n  if (\n    (events[headEnterIndex][1].type === 'lineEnding' ||\n      events[headEnterIndex][1].type === 'space') &&\n    (events[tailExitIndex][1].type === 'lineEnding' ||\n      events[tailExitIndex][1].type === 'space')\n  ) {\n    index = headEnterIndex\n\n    // And we have data.\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === 'codeTextData') {\n        // Then we have padding.\n        events[headEnterIndex][1].type = 'codeTextPadding'\n        events[tailExitIndex][1].type = 'codeTextPadding'\n        headEnterIndex += 2\n        tailExitIndex -= 2\n        break\n      }\n    }\n  }\n\n  // Merge adjacent spaces and data.\n  index = headEnterIndex - 1\n  tailExitIndex++\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== 'lineEnding') {\n        enter = index\n      }\n    } else if (\n      index === tailExitIndex ||\n      events[index][1].type === 'lineEnding'\n    ) {\n      events[enter][1].type = 'codeTextData'\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end\n        events.splice(enter + 2, index - enter - 2)\n        tailExitIndex -= index - enter - 2\n        index = enter + 2\n      }\n      enter = undefined\n    }\n  }\n  return events\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Previous}\n */\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return (\n    code !== 96 ||\n    this.events[this.events.length - 1][1].type === 'characterEscape'\n  )\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeCodeText(effects, ok, nok) {\n  const self = this\n  let sizeOpen = 0\n  /** @type {number} */\n  let size\n  /** @type {Token} */\n  let token\n  return start\n\n  /**\n   * Start of code (text).\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * > | \\`a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('codeText')\n    effects.enter('codeTextSequence')\n    return sequenceOpen(code)\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 96) {\n      effects.consume(code)\n      sizeOpen++\n      return sequenceOpen\n    }\n    effects.exit('codeTextSequence')\n    return between(code)\n  }\n\n  /**\n   * Between something and something else.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function between(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code)\n    }\n\n    // To do: next major: don’t do spaces in resolve, but when compiling,\n    // like `markdown-rs`.\n    // Tabs don’t work, and virtual spaces don’t make sense.\n    if (code === 32) {\n      effects.enter('space')\n      effects.consume(code)\n      effects.exit('space')\n      return between\n    }\n\n    // Closing fence? Could also be data.\n    if (code === 96) {\n      token = effects.enter('codeTextSequence')\n      size = 0\n      return sequenceClose(code)\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding')\n      effects.consume(code)\n      effects.exit('lineEnding')\n      return between\n    }\n\n    // Data.\n    effects.enter('codeTextData')\n    return data(code)\n  }\n\n  /**\n   * In data.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (\n      code === null ||\n      code === 32 ||\n      code === 96 ||\n      markdownLineEnding(code)\n    ) {\n      effects.exit('codeTextData')\n      return between(code)\n    }\n    effects.consume(code)\n    return data\n  }\n\n  /**\n   * In closing sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceClose(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code)\n      size++\n      return sequenceClose\n    }\n\n    // Done!\n    if (size === sizeOpen) {\n      effects.exit('codeTextSequence')\n      effects.exit('codeText')\n      return ok(code)\n    }\n\n    // More or less accents: mark as data.\n    token.type = 'codeTextData'\n    return data(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n */\n\nimport {\n  attention,\n  autolink,\n  blockQuote,\n  characterEscape,\n  characterReference,\n  codeFenced,\n  codeIndented,\n  codeText,\n  definition,\n  hardBreakEscape,\n  headingAtx,\n  htmlFlow,\n  htmlText,\n  labelEnd,\n  labelStartImage,\n  labelStartLink,\n  lineEnding,\n  list,\n  setextUnderline,\n  thematicBreak\n} 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","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {labelEnd} from './label-end.js'\n\n/** @type {Construct} */\nexport const labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  const self = this\n  return start\n\n  /**\n   * Start of label (image) start.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('labelImage')\n    effects.enter('labelImageMarker')\n    effects.consume(code)\n    effects.exit('labelImageMarker')\n    return open\n  }\n\n  /**\n   * After `!`, at `[`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 91) {\n      effects.enter('labelMarker')\n      effects.consume(code)\n      effects.exit('labelMarker')\n      effects.exit('labelImage')\n      return after\n    }\n    return nok(code)\n  }\n\n  /**\n   * After `![`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *         ^\n   * ```\n   *\n   * This is needed in because, when GFM footnotes are enabled, images never\n   * form when started with a `^`.\n   * Instead, links form:\n   *\n   * ```markdown\n   * ![^a](b)\n   *\n   * ![^a][b]\n   *\n   * [b]: c\n   * ```\n   *\n   * ```html\n   * <p>!<a href=\\\"b\\\">^a</a></p>\n   * <p>!<a href=\\\"c\\\">^a</a></p>\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // To do: use a new field to do this, this is still needed for\n    // `micromark-extension-gfm-footnote`, but the `label-start-link`\n    // behavior isn’t.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs\n      ? nok(code)\n      : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {\n  asciiAlpha,\n  asciiAlphanumeric,\n  asciiAtext,\n  asciiControl\n} from 'micromark-util-character'\n/** @type {Construct} */\nexport const autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeAutolink(effects, ok, nok) {\n  let size = 0\n  return start\n\n  /**\n   * Start of an autolink.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *      ^\n   * > | a<user@example.com>b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('autolink')\n    effects.enter('autolinkMarker')\n    effects.consume(code)\n    effects.exit('autolinkMarker')\n    effects.enter('autolinkProtocol')\n    return open\n  }\n\n  /**\n   * After `<`, at protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *       ^\n   * > | a<user@example.com>b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code)\n      return schemeOrEmailAtext\n    }\n    return emailAtext(code)\n  }\n\n  /**\n   * At second byte of protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeOrEmailAtext(code) {\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) {\n      // Count the previous alphabetical from `open` too.\n      size = 1\n      return schemeInsideOrEmailAtext(code)\n    }\n    return emailAtext(code)\n  }\n\n  /**\n   * In ambiguous protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code)\n      size = 0\n      return urlInside\n    }\n\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if (\n      (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) &&\n      size++ < 32\n    ) {\n      effects.consume(code)\n      return schemeInsideOrEmailAtext\n    }\n    size = 0\n    return emailAtext(code)\n  }\n\n  /**\n   * After protocol, in URL.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit('autolinkProtocol')\n      effects.enter('autolinkMarker')\n      effects.consume(code)\n      effects.exit('autolinkMarker')\n      effects.exit('autolink')\n      return ok\n    }\n\n    // ASCII control, space, or `<`.\n    if (code === null || code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code)\n    }\n    effects.consume(code)\n    return urlInside\n  }\n\n  /**\n   * In email atext.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code)\n      return emailAtSignOrDot\n    }\n    if (asciiAtext(code)) {\n      effects.consume(code)\n      return emailAtext\n    }\n    return nok(code)\n  }\n\n  /**\n   * In label, after at-sign or dot.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                 ^       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code)\n  }\n\n  /**\n   * In label, where `.` and `>` are allowed.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code)\n      size = 0\n      return emailAtSignOrDot\n    }\n    if (code === 62) {\n      // Exit, then change the token type.\n      effects.exit('autolinkProtocol').type = 'autolinkEmail'\n      effects.enter('autolinkMarker')\n      effects.consume(code)\n      effects.exit('autolinkMarker')\n      effects.exit('autolink')\n      return ok\n    }\n    return emailValue(code)\n  }\n\n  /**\n   * In label, where `.` and `>` are *not* allowed.\n   *\n   * Though, this is also used in `emailLabel` to parse other values.\n   *\n   * ```markdown\n   * > | a<user.name@ex-ample.com>b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailValue(code) {\n    // ASCII alphanumeric or `-`.\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      const next = code === 45 ? emailValue : emailLabel\n      effects.consume(code)\n      return next\n    }\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {labelEnd} from './label-end.js'\n\n/** @type {Construct} */\nexport const labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  const self = this\n  return start\n\n  /**\n   * Start of label (link) start.\n   *\n   * ```markdown\n   * > | a [b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('labelLink')\n    effects.enter('labelMarker')\n    effects.consume(code)\n    effects.exit('labelMarker')\n    effects.exit('labelLink')\n    return after\n  }\n\n  /** @type {State} */\n  function after(code) {\n    // To do: this isn’t needed in `micromark-extension-gfm-footnote`,\n    // remove.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs\n      ? nok(code)\n      : ok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n */\n\nimport {markdownLineEnding} from 'micromark-util-character'\n/** @type {Construct} */\nexport const hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start\n\n  /**\n   * Start of a hard break (escape).\n   *\n   * ```markdown\n   * > | a\\\n   *      ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('hardBreakEscape')\n    effects.consume(code)\n    return after\n  }\n\n  /**\n   * After `\\`, at eol.\n   *\n   * ```markdown\n   * > | a\\\n   *       ^\n   *   | b\n   * ```\n   *\n   *  @type {State}\n   */\n  function after(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit('hardBreakEscape')\n      return ok(code)\n    }\n    return nok(code)\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Create} Create\n * @typedef {import('micromark-util-types').FullNormalizedExtension} FullNormalizedExtension\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\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 {text, string} from './initialize/text.js'\nimport {createTokenizer} from './create-tokenizer.js'\nimport * as defaultConstructs from './constructs.js'\n\n/**\n * @param {ParseOptions | null | undefined} [options]\n * @returns {ParseContext}\n */\nexport function parse(options) {\n  const settings = options || {}\n  const constructs =\n    /** @type {FullNormalizedExtension} */\n    combineExtensions([defaultConstructs, ...(settings.extensions || [])])\n\n  /** @type {ParseContext} */\n  const parser = {\n    defined: [],\n    lazy: {},\n    constructs,\n    content: create(content),\n    document: create(document),\n    flow: create(flow),\n    string: create(string),\n    text: create(text)\n  }\n  return parser\n\n  /**\n   * @param {InitialConstruct} initial\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","/**\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Value} Value\n */\n\n/**\n * @callback Preprocessor\n * @param {Value} value\n * @param {Encoding | null | undefined} [encoding]\n * @param {boolean | null | undefined} [end=false]\n * @returns {Array<Chunk>}\n */\n\nconst search = /[\\0\\t\\n\\r]/g\n\n/**\n * @returns {Preprocessor}\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  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\n    // @ts-expect-error `Buffer` does allow an encoding.\n    value = buffer + value.toString(encoding)\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 =\n        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            chunks.push(65533)\n            column++\n            break\n          }\n          case 9: {\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            chunks.push(-4)\n            column = 1\n            break\n          }\n          default: {\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}\n","/**\n * Turn the number (in string form as either hexa- or plain decimal) coming from\n * a numeric character reference into a character.\n *\n * Sort of like `String.fromCharCode(Number.parseInt(value, base))`, but makes\n * non-characters and control characters safe.\n *\n * @param {string} value\n *   Value to decode.\n * @param {number} base\n *   Numeric base.\n * @returns {string}\n *   Character.\n */\nexport function decodeNumericCharacterReference(value, base) {\n  const code = Number.parseInt(value, base)\n  if (\n    // C0 except for HT, LF, FF, CR, space.\n    code < 9 ||\n    code === 11 ||\n    (code > 13 && code < 32) ||\n    // Control character (DEL) of C0, and C1 controls.\n    (code > 126 && code < 160) ||\n    // Lone high surrogates and low surrogates.\n    (code > 55295 && code < 57344) ||\n    // Noncharacters.\n    (code > 64975 && code < 65008) /* eslint-disable no-bitwise */ ||\n    (code & 65535) === 65535 ||\n    (code & 65535) === 65534 /* eslint-enable no-bitwise */ ||\n    // Out of range\n    code > 1114111\n  ) {\n    return '\\uFFFD'\n  }\n  return String.fromCharCode(code)\n}\n","import {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {decodeNumericCharacterReference} from 'micromark-util-decode-numeric-character-reference'\nconst characterEscapeOrReference =\n  /\\\\([!-/:-@[-`{-~])|&(#(?:\\d{1,7}|x[\\da-f]{1,6})|[\\da-z]{1,31});/gi\n\n/**\n * Decode markdown strings (which occur in places such as fenced code info\n * strings, destinations, labels, and titles).\n *\n * The “string” content type allows character escapes and -references.\n * This decodes those.\n *\n * @param {string} value\n *   Value to decode.\n * @returns {string}\n *   Decoded value.\n */\nexport function decodeString(value) {\n  return value.replace(characterEscapeOrReference, decode)\n}\n\n/**\n * @param {string} $0\n * @param {string} $1\n * @param {string} $2\n * @returns {string}\n */\nfunction decode($0, $1, $2) {\n  if ($1) {\n    // Escape.\n    return $1\n  }\n\n  // Reference.\n  const head = $2.charCodeAt(0)\n  if (head === 35) {\n    const head = $2.charCodeAt(1)\n    const hex = head === 120 || head === 88\n    return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10)\n  }\n  return decodeNamedCharacterReference($2) || $0\n}\n","/**\n * Normalize an identifier (as found in references, definitions).\n *\n * Collapses markdown whitespace, trim, and then lower- and uppercase.\n *\n * Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their\n * lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different\n * uppercase character (U+0398 (`Θ`)).\n * So, to get a canonical form, we perform both lower- and uppercase.\n *\n * Using uppercase last makes sure keys will never interact with default\n * prototypal values (such as `constructor`): nothing in the prototype of\n * `Object` is uppercase.\n *\n * @param {string} value\n *   Identifier to normalize.\n * @returns {string}\n *   Normalized identifier.\n */\nexport function normalizeIdentifier(value) {\n  return (\n    value\n      // Collapse markdown whitespace.\n      .replace(/[\\t\\n\\r ]+/g, ' ')\n      // Trim.\n      .replace(/^ | $/g, '')\n      // Some characters are considered “uppercase”, but if their lowercase\n      // counterpart is uppercased will result in a different uppercase\n      // character.\n      // Hence, to get that form, we perform both lower- and uppercase.\n      // Upper case makes sure keys will not interact with default prototypal\n      // methods: no method is uppercase.\n      .toLowerCase()\n      .toUpperCase()\n  )\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef NodeLike\n * @property {string} type\n * @property {PositionLike | null | undefined} [position]\n *\n * @typedef PositionLike\n * @property {PointLike | null | undefined} [start]\n * @property {PointLike | null | undefined} [end]\n *\n * @typedef PointLike\n * @property {number | null | undefined} [line]\n * @property {number | null | undefined} [column]\n * @property {number | null | undefined} [offset]\n */\n\n/**\n * Serialize the positional info of a point, position (start and end points),\n * or node.\n *\n * @param {Node | NodeLike | Position | PositionLike | Point | PointLike | null | undefined} [value]\n *   Node, position, or point.\n * @returns {string}\n *   Pretty printed positional info of a node (`string`).\n *\n *   In the format of a range `ls:cs-le:ce` (when given `node` or `position`)\n *   or a point `l:c` (when given `point`), where `l` stands for line, `c` for\n *   column, `s` for `start`, and `e` for end.\n *   An empty string (`''`) is returned if the given value is neither `node`,\n *   `position`, nor `point`.\n */\nexport function stringifyPosition(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return ''\n  }\n\n  // Node.\n  if ('position' in value || 'type' in value) {\n    return position(value.position)\n  }\n\n  // Position.\n  if ('start' in value || 'end' in value) {\n    return position(value)\n  }\n\n  // Point.\n  if ('line' in value || 'column' in value) {\n    return point(value)\n  }\n\n  // ?\n  return ''\n}\n\n/**\n * @param {Point | PointLike | null | undefined} point\n * @returns {string}\n */\nfunction point(point) {\n  return index(point && point.line) + ':' + index(point && point.column)\n}\n\n/**\n * @param {Position | PositionLike | null | undefined} pos\n * @returns {string}\n */\nfunction position(pos) {\n  return point(pos && pos.start) + '-' + point(pos && pos.end)\n}\n\n/**\n * @param {number | null | undefined} value\n * @returns {number}\n */\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1\n}\n","/**\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Value} Value\n *\n * @typedef {import('unist').Parent} UnistParent\n * @typedef {import('unist').Point} Point\n *\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n * @typedef {import('mdast').StaticPhrasingContent} StaticPhrasingContent\n * @typedef {import('mdast').Content} Content\n * @typedef {import('mdast').Break} Break\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('mdast').Code} Code\n * @typedef {import('mdast').Definition} Definition\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('mdast').HTML} HTML\n * @typedef {import('mdast').Image} Image\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('mdast').Link} Link\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('mdast').List} List\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('mdast').Text} Text\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n * @typedef {import('mdast').ReferenceType} ReferenceType\n * @typedef {import('../index.js').CompileData} CompileData\n */\n\n/**\n * @typedef {Root | Content} Node\n * @typedef {Extract<Node, UnistParent>} Parent\n *\n * @typedef {Omit<UnistParent, 'type' | 'children'> & {type: 'fragment', children: Array<PhrasingContent>}} Fragment\n */\n\n/**\n * @callback Transform\n *   Extra transform, to change the AST afterwards.\n * @param {Root} tree\n *   Tree to transform.\n * @returns {Root | undefined | null | void}\n *   New tree or nothing (in which case the current tree is used).\n *\n * @callback Handle\n *   Handle a token.\n * @param {CompileContext} this\n *   Context.\n * @param {Token} token\n *   Current token.\n * @returns {void}\n *   Nothing.\n *\n * @typedef {Record<string, Handle>} Handles\n *   Token types mapping to handles\n *\n * @callback OnEnterError\n *   Handle the case where the `right` token is open, but it is closed (by the\n *   `left` token) or because we reached the end of the document.\n * @param {Omit<CompileContext, 'sliceSerialize'>} this\n *   Context.\n * @param {Token | undefined} left\n *   Left token.\n * @param {Token} right\n *   Right token.\n * @returns {void}\n *   Nothing.\n *\n * @callback OnExitError\n *   Handle the case where the `right` token is open but it is closed by\n *   exiting the `left` token.\n * @param {Omit<CompileContext, 'sliceSerialize'>} this\n *   Context.\n * @param {Token} left\n *   Left token.\n * @param {Token} right\n *   Right token.\n * @returns {void}\n *   Nothing.\n *\n * @typedef {[Token, OnEnterError | undefined]} TokenTuple\n *   Open token on the stack, with an optional error handler for when\n *   that token isn’t closed properly.\n */\n\n/**\n * @typedef Config\n *   Configuration.\n *\n *   We have our defaults, but extensions will add more.\n * @property {Array<string>} canContainEols\n *   Token types where line endings are used.\n * @property {Handles} enter\n *   Opening handles.\n * @property {Handles} exit\n *   Closing handles.\n * @property {Array<Transform>} transforms\n *   Tree transforms.\n *\n * @typedef {Partial<Config>} Extension\n *   Change how markdown tokens from micromark are turned into mdast.\n *\n * @typedef CompileContext\n *   mdast compiler context.\n * @property {Array<Node | Fragment>} stack\n *   Stack of nodes.\n * @property {Array<TokenTuple>} tokenStack\n *   Stack of tokens.\n * @property {<Key extends keyof CompileData>(key: Key) => CompileData[Key]} getData\n *   Get data from the key/value store.\n * @property {<Key extends keyof CompileData>(key: Key, value?: CompileData[Key]) => void} setData\n *   Set data into the key/value store.\n * @property {(this: CompileContext) => void} buffer\n *   Capture some of the output data.\n * @property {(this: CompileContext) => string} resume\n *   Stop capturing and access the output data.\n * @property {<Kind extends Node>(this: CompileContext, node: Kind, token: Token, onError?: OnEnterError) => Kind} enter\n *   Enter a token.\n * @property {(this: CompileContext, token: Token, onError?: OnExitError) => Node} exit\n *   Exit a token.\n * @property {TokenizeContext['sliceSerialize']} sliceSerialize\n *   Get the string value of a token.\n * @property {Config} config\n *   Configuration.\n *\n * @typedef FromMarkdownOptions\n *   Configuration for how to build mdast.\n * @property {Array<Extension | Array<Extension>> | null | undefined} [mdastExtensions]\n *   Extensions for this utility to change how tokens are turned into a tree.\n *\n * @typedef {ParseOptions & FromMarkdownOptions} Options\n *   Configuration.\n */\n\n// To do: micromark: create a registry of tokens?\n// To do: next major: don’t return given `Node` from `enter`.\n// To do: next major: remove setter/getter.\n\nimport {toString} from 'mdast-util-to-string'\nimport {parse} from 'micromark/lib/parse.js'\nimport {preprocess} from 'micromark/lib/preprocess.js'\nimport {postprocess} from 'micromark/lib/postprocess.js'\nimport {decodeNumericCharacterReference} from 'micromark-util-decode-numeric-character-reference'\nimport {decodeString} from 'micromark-util-decode-string'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\nimport {decodeNamedCharacterReference} from 'decode-named-character-reference'\nimport {stringifyPosition} from 'unist-util-stringify-position'\nconst own = {}.hasOwnProperty\n\n/**\n * @param value\n *   Markdown to parse.\n * @param encoding\n *   Character encoding for when `value` is `Buffer`.\n * @param options\n *   Configuration.\n * @returns\n *   mdast tree.\n */\nexport const fromMarkdown =\n  /**\n   * @type {(\n   *   ((value: Value, encoding: Encoding, options?: Options | null | undefined) => Root) &\n   *   ((value: Value, options?: Options | null | undefined) => Root)\n   * )}\n   */\n\n  /**\n   * @param {Value} value\n   * @param {Encoding | Options | null | undefined} [encoding]\n   * @param {Options | null | undefined} [options]\n   * @returns {Root}\n   */\n  function (value, encoding, options) {\n    if (typeof encoding !== 'string') {\n      options = encoding\n      encoding = undefined\n    }\n    return compiler(options)(\n      postprocess(\n        parse(options).document().write(preprocess()(value, encoding, true))\n      )\n    )\n  }\n\n/**\n * Note this compiler only understand complete buffering, not streaming.\n *\n * @param {Options | null | undefined} [options]\n */\nfunction compiler(options) {\n  /** @type {Config} */\n  const config = {\n    transforms: [],\n    canContainEols: ['emphasis', 'fragment', 'heading', 'paragraph', 'strong'],\n    enter: {\n      autolink: opener(link),\n      autolinkProtocol: onenterdata,\n      autolinkEmail: onenterdata,\n      atxHeading: opener(heading),\n      blockQuote: opener(blockQuote),\n      characterEscape: onenterdata,\n      characterReference: onenterdata,\n      codeFenced: opener(codeFlow),\n      codeFencedFenceInfo: buffer,\n      codeFencedFenceMeta: buffer,\n      codeIndented: opener(codeFlow, buffer),\n      codeText: opener(codeText, buffer),\n      codeTextData: onenterdata,\n      data: onenterdata,\n      codeFlowValue: onenterdata,\n      definition: opener(definition),\n      definitionDestinationString: buffer,\n      definitionLabelString: buffer,\n      definitionTitleString: buffer,\n      emphasis: opener(emphasis),\n      hardBreakEscape: opener(hardBreak),\n      hardBreakTrailing: opener(hardBreak),\n      htmlFlow: opener(html, buffer),\n      htmlFlowData: onenterdata,\n      htmlText: opener(html, buffer),\n      htmlTextData: onenterdata,\n      image: opener(image),\n      label: buffer,\n      link: opener(link),\n      listItem: opener(listItem),\n      listItemValue: onenterlistitemvalue,\n      listOrdered: opener(list, onenterlistordered),\n      listUnordered: opener(list),\n      paragraph: opener(paragraph),\n      reference: onenterreference,\n      referenceString: buffer,\n      resourceDestinationString: buffer,\n      resourceTitleString: buffer,\n      setextHeading: opener(heading),\n      strong: opener(strong),\n      thematicBreak: opener(thematicBreak)\n    },\n    exit: {\n      atxHeading: closer(),\n      atxHeadingSequence: onexitatxheadingsequence,\n      autolink: closer(),\n      autolinkEmail: onexitautolinkemail,\n      autolinkProtocol: onexitautolinkprotocol,\n      blockQuote: closer(),\n      characterEscapeValue: onexitdata,\n      characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,\n      characterReferenceMarkerNumeric: onexitcharacterreferencemarker,\n      characterReferenceValue: onexitcharacterreferencevalue,\n      codeFenced: closer(onexitcodefenced),\n      codeFencedFence: onexitcodefencedfence,\n      codeFencedFenceInfo: onexitcodefencedfenceinfo,\n      codeFencedFenceMeta: onexitcodefencedfencemeta,\n      codeFlowValue: onexitdata,\n      codeIndented: closer(onexitcodeindented),\n      codeText: closer(onexitcodetext),\n      codeTextData: onexitdata,\n      data: onexitdata,\n      definition: closer(),\n      definitionDestinationString: onexitdefinitiondestinationstring,\n      definitionLabelString: onexitdefinitionlabelstring,\n      definitionTitleString: onexitdefinitiontitlestring,\n      emphasis: closer(),\n      hardBreakEscape: closer(onexithardbreak),\n      hardBreakTrailing: closer(onexithardbreak),\n      htmlFlow: closer(onexithtmlflow),\n      htmlFlowData: onexitdata,\n      htmlText: closer(onexithtmltext),\n      htmlTextData: onexitdata,\n      image: closer(onexitimage),\n      label: onexitlabel,\n      labelText: onexitlabeltext,\n      lineEnding: onexitlineending,\n      link: closer(onexitlink),\n      listItem: closer(),\n      listOrdered: closer(),\n      listUnordered: closer(),\n      paragraph: closer(),\n      referenceString: onexitreferencestring,\n      resourceDestinationString: onexitresourcedestinationstring,\n      resourceTitleString: onexitresourcetitlestring,\n      resource: onexitresource,\n      setextHeading: closer(onexitsetextheading),\n      setextHeadingLineSequence: onexitsetextheadinglinesequence,\n      setextHeadingText: onexitsetextheadingtext,\n      strong: closer(),\n      thematicBreak: closer()\n    }\n  }\n  configure(config, (options || {}).mdastExtensions || [])\n\n  /** @type {CompileData} */\n  const data = {}\n  return compile\n\n  /**\n   * Turn micromark events into an mdast tree.\n   *\n   * @param {Array<Event>} events\n   *   Events.\n   * @returns {Root}\n   *   mdast tree.\n   */\n  function compile(events) {\n    /** @type {Root} */\n    let tree = {\n      type: 'root',\n      children: []\n    }\n    /** @type {Omit<CompileContext, 'sliceSerialize'>} */\n    const context = {\n      stack: [tree],\n      tokenStack: [],\n      config,\n      enter,\n      exit,\n      buffer,\n      resume,\n      setData,\n      getData\n    }\n    /** @type {Array<number>} */\n    const listStack = []\n    let index = -1\n    while (++index < events.length) {\n      // We preprocess lists to add `listItem` tokens, and to infer whether\n      // items the list itself are spread out.\n      if (\n        events[index][1].type === 'listOrdered' ||\n        events[index][1].type === 'listUnordered'\n      ) {\n        if (events[index][0] === 'enter') {\n          listStack.push(index)\n        } else {\n          const tail = listStack.pop()\n          index = prepareList(events, tail, index)\n        }\n      }\n    }\n    index = -1\n    while (++index < events.length) {\n      const handler = config[events[index][0]]\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(\n          Object.assign(\n            {\n              sliceSerialize: events[index][2].sliceSerialize\n            },\n            context\n          ),\n          events[index][1]\n        )\n      }\n    }\n\n    // Handle tokens still being open.\n    if (context.tokenStack.length > 0) {\n      const tail = context.tokenStack[context.tokenStack.length - 1]\n      const handler = tail[1] || defaultOnError\n      handler.call(context, undefined, tail[0])\n    }\n\n    // Figure out `root` position.\n    tree.position = {\n      start: point(\n        events.length > 0\n          ? events[0][1].start\n          : {\n              line: 1,\n              column: 1,\n              offset: 0\n            }\n      ),\n      end: point(\n        events.length > 0\n          ? events[events.length - 2][1].end\n          : {\n              line: 1,\n              column: 1,\n              offset: 0\n            }\n      )\n    }\n\n    // Call transforms.\n    index = -1\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree\n    }\n    return tree\n  }\n\n  /**\n   * @param {Array<Event>} events\n   * @param {number} start\n   * @param {number} length\n   * @returns {number}\n   */\n  function prepareList(events, start, length) {\n    let index = start - 1\n    let containerBalance = -1\n    let listSpread = false\n    /** @type {Token | undefined} */\n    let listItem\n    /** @type {number | undefined} */\n    let lineIndex\n    /** @type {number | undefined} */\n    let firstBlankLineIndex\n    /** @type {boolean | undefined} */\n    let atMarker\n    while (++index <= length) {\n      const event = events[index]\n      if (\n        event[1].type === 'listUnordered' ||\n        event[1].type === 'listOrdered' ||\n        event[1].type === 'blockQuote'\n      ) {\n        if (event[0] === 'enter') {\n          containerBalance++\n        } else {\n          containerBalance--\n        }\n        atMarker = undefined\n      } else if (event[1].type === 'lineEndingBlank') {\n        if (event[0] === 'enter') {\n          if (\n            listItem &&\n            !atMarker &&\n            !containerBalance &&\n            !firstBlankLineIndex\n          ) {\n            firstBlankLineIndex = index\n          }\n          atMarker = undefined\n        }\n      } else if (\n        event[1].type === 'linePrefix' ||\n        event[1].type === 'listItemValue' ||\n        event[1].type === 'listItemMarker' ||\n        event[1].type === 'listItemPrefix' ||\n        event[1].type === 'listItemPrefixWhitespace'\n      ) {\n        // Empty.\n      } else {\n        atMarker = undefined\n      }\n      if (\n        (!containerBalance &&\n          event[0] === 'enter' &&\n          event[1].type === 'listItemPrefix') ||\n        (containerBalance === -1 &&\n          event[0] === 'exit' &&\n          (event[1].type === 'listUnordered' ||\n            event[1].type === 'listOrdered'))\n      ) {\n        if (listItem) {\n          let tailIndex = index\n          lineIndex = undefined\n          while (tailIndex--) {\n            const tailEvent = events[tailIndex]\n            if (\n              tailEvent[1].type === 'lineEnding' ||\n              tailEvent[1].type === 'lineEndingBlank'\n            ) {\n              if (tailEvent[0] === 'exit') continue\n              if (lineIndex) {\n                events[lineIndex][1].type = 'lineEndingBlank'\n                listSpread = true\n              }\n              tailEvent[1].type = 'lineEnding'\n              lineIndex = tailIndex\n            } else if (\n              tailEvent[1].type === 'linePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefix' ||\n              tailEvent[1].type === 'blockQuotePrefixWhitespace' ||\n              tailEvent[1].type === 'blockQuoteMarker' ||\n              tailEvent[1].type === 'listItemIndent'\n            ) {\n              // Empty\n            } else {\n              break\n            }\n          }\n          if (\n            firstBlankLineIndex &&\n            (!lineIndex || firstBlankLineIndex < lineIndex)\n          ) {\n            listItem._spread = true\n          }\n\n          // Fix position.\n          listItem.end = Object.assign(\n            {},\n            lineIndex ? events[lineIndex][1].start : event[1].end\n          )\n          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]])\n          index++\n          length++\n        }\n\n        // Create a new list item.\n        if (event[1].type === 'listItemPrefix') {\n          listItem = {\n            type: 'listItem',\n            _spread: false,\n            start: Object.assign({}, event[1].start),\n            // @ts-expect-error: we’ll add `end` in a second.\n            end: undefined\n          }\n          // @ts-expect-error: `listItem` is most definitely defined, TS...\n          events.splice(index, 0, ['enter', listItem, event[2]])\n          index++\n          length++\n          firstBlankLineIndex = undefined\n          atMarker = true\n        }\n      }\n    }\n    events[start][1]._spread = listSpread\n    return length\n  }\n\n  /**\n   * Set data.\n   *\n   * @template {keyof CompileData} Key\n   *   Field type.\n   * @param {Key} key\n   *   Key of field.\n   * @param {CompileData[Key]} [value]\n   *   New value.\n   * @returns {void}\n   *   Nothing.\n   */\n  function setData(key, value) {\n    data[key] = value\n  }\n\n  /**\n   * Get data.\n   *\n   * @template {keyof CompileData} Key\n   *   Field type.\n   * @param {Key} key\n   *   Key of field.\n   * @returns {CompileData[Key]}\n   *   Value.\n   */\n  function getData(key) {\n    return data[key]\n  }\n\n  /**\n   * Create an opener handle.\n   *\n   * @param {(token: Token) => Node} create\n   *   Create a node.\n   * @param {Handle} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function opener(create, and) {\n    return open\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {void}\n     */\n    function open(token) {\n      enter.call(this, create(token), token)\n      if (and) and.call(this, token)\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @returns {void}\n   */\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    })\n  }\n\n  /**\n   * @template {Node} Kind\n   *   Node type.\n   * @this {CompileContext}\n   *   Context.\n   * @param {Kind} node\n   *   Node to enter.\n   * @param {Token} token\n   *   Corresponding token.\n   * @param {OnEnterError | undefined} [errorHandler]\n   *   Handle the case where this token is open, but it is closed by something else.\n   * @returns {Kind}\n   *   The given node.\n   */\n  function enter(node, token, errorHandler) {\n    const parent = this.stack[this.stack.length - 1]\n    // @ts-expect-error: Assume `Node` can exist as a child of `parent`.\n    parent.children.push(node)\n    this.stack.push(node)\n    this.tokenStack.push([token, errorHandler])\n    // @ts-expect-error: `end` will be patched later.\n    node.position = {\n      start: point(token.start)\n    }\n    return node\n  }\n\n  /**\n   * Create a closer handle.\n   *\n   * @param {Handle} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function closer(and) {\n    return close\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {void}\n     */\n    function close(token) {\n      if (and) and.call(this, token)\n      exit.call(this, token)\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   *   Context.\n   * @param {Token} token\n   *   Corresponding token.\n   * @param {OnExitError | undefined} [onExitError]\n   *   Handle the case where another token is open.\n   * @returns {Node}\n   *   The closed node.\n   */\n  function exit(token, onExitError) {\n    const node = this.stack.pop()\n    const open = this.tokenStack.pop()\n    if (!open) {\n      throw new Error(\n        'Cannot close `' +\n          token.type +\n          '` (' +\n          stringifyPosition({\n            start: token.start,\n            end: token.end\n          }) +\n          '): it’s not open'\n      )\n    } else if (open[0].type !== token.type) {\n      if (onExitError) {\n        onExitError.call(this, token, open[0])\n      } else {\n        const handler = open[1] || defaultOnError\n        handler.call(this, token, open[0])\n      }\n    }\n    node.position.end = point(token.end)\n    return node\n  }\n\n  /**\n   * @this {CompileContext}\n   * @returns {string}\n   */\n  function resume() {\n    return toString(this.stack.pop())\n  }\n\n  //\n  // Handlers.\n  //\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistordered() {\n    setData('expectingFirstListItemValue', true)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistitemvalue(token) {\n    if (getData('expectingFirstListItemValue')) {\n      const ancestor = this.stack[this.stack.length - 2]\n      ancestor.start = Number.parseInt(this.sliceSerialize(token), 10)\n      setData('expectingFirstListItemValue')\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfenceinfo() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.lang = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfencemeta() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.meta = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (getData('flowCodeInside')) return\n    this.buffer()\n    setData('flowCodeInside', true)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefenced() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '')\n    setData('flowCodeInside')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodeindented() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.value = data.replace(/(\\r?\\n|\\r)$/g, '')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitionlabelstring(token) {\n    const label = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.label = label\n    node.identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiontitlestring() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.title = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiondestinationstring() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.url = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitatxheadingsequence(token) {\n    const node = this.stack[this.stack.length - 1]\n    if (!node.depth) {\n      const depth = this.sliceSerialize(token).length\n      node.depth = depth\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadingtext() {\n    setData('setextHeadingSlurpLineEnding', true)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadinglinesequence(token) {\n    const node = this.stack[this.stack.length - 1]\n    node.depth = this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheading() {\n    setData('setextHeadingSlurpLineEnding')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterdata(token) {\n    const node = this.stack[this.stack.length - 1]\n    let tail = node.children[node.children.length - 1]\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text()\n      // @ts-expect-error: we’ll add `end` later.\n      tail.position = {\n        start: point(token.start)\n      }\n      // @ts-expect-error: Assume `parent` accepts `text`.\n      node.children.push(tail)\n    }\n    this.stack.push(tail)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitdata(token) {\n    const tail = this.stack.pop()\n    tail.value += this.sliceSerialize(token)\n    tail.position.end = point(token.end)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlineending(token) {\n    const context = this.stack[this.stack.length - 1]\n    // If we’re at a hard break, include the line ending in there.\n    if (getData('atHardBreak')) {\n      const tail = context.children[context.children.length - 1]\n      tail.position.end = point(token.end)\n      setData('atHardBreak')\n      return\n    }\n    if (\n      !getData('setextHeadingSlurpLineEnding') &&\n      config.canContainEols.includes(context.type)\n    ) {\n      onenterdata.call(this, token)\n      onexitdata.call(this, token)\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithardbreak() {\n    setData('atHardBreak', true)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmlflow() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.value = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmltext() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.value = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcodetext() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.value = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlink() {\n    const node = this.stack[this.stack.length - 1]\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n    // To do: clean.\n    if (getData('inReference')) {\n      /** @type {ReferenceType} */\n      const referenceType = getData('referenceType') || 'shortcut'\n      node.type += 'Reference'\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType\n      // @ts-expect-error: mutate.\n      delete node.url\n      delete node.title\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier\n      // @ts-expect-error: mutate.\n      delete node.label\n    }\n    setData('referenceType')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitimage() {\n    const node = this.stack[this.stack.length - 1]\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n    // To do: clean.\n    if (getData('inReference')) {\n      /** @type {ReferenceType} */\n      const referenceType = getData('referenceType') || 'shortcut'\n      node.type += 'Reference'\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType\n      // @ts-expect-error: mutate.\n      delete node.url\n      delete node.title\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier\n      // @ts-expect-error: mutate.\n      delete node.label\n    }\n    setData('referenceType')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabeltext(token) {\n    const string = this.sliceSerialize(token)\n    const ancestor = this.stack[this.stack.length - 2]\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    ancestor.label = decodeString(string)\n    // @ts-expect-error: same as above.\n    ancestor.identifier = normalizeIdentifier(string).toLowerCase()\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabel() {\n    const fragment = this.stack[this.stack.length - 1]\n    const value = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    // Assume a reference.\n    setData('inReference', true)\n    if (node.type === 'link') {\n      /** @type {Array<StaticPhrasingContent>} */\n      // @ts-expect-error: Assume static phrasing content.\n      const children = fragment.children\n      node.children = children\n    } else {\n      node.alt = value\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcedestinationstring() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.url = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcetitlestring() {\n    const data = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    node.title = data\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresource() {\n    setData('inReference')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterreference() {\n    setData('referenceType', 'collapsed')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitreferencestring(token) {\n    const label = this.resume()\n    const node = this.stack[this.stack.length - 1]\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    node.label = label\n    // @ts-expect-error: same as above.\n    node.identifier = normalizeIdentifier(\n      this.sliceSerialize(token)\n    ).toLowerCase()\n    setData('referenceType', 'full')\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcharacterreferencemarker(token) {\n    setData('characterReferenceType', token.type)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcharacterreferencevalue(token) {\n    const data = this.sliceSerialize(token)\n    const type = getData('characterReferenceType')\n    /** @type {string} */\n    let value\n    if (type) {\n      value = decodeNumericCharacterReference(\n        data,\n        type === 'characterReferenceMarkerNumeric' ? 10 : 16\n      )\n      setData('characterReferenceType')\n    } else {\n      const result = decodeNamedCharacterReference(data)\n      value = result\n    }\n    const tail = this.stack.pop()\n    tail.value += value\n    tail.position.end = point(token.end)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token)\n    const node = this.stack[this.stack.length - 1]\n    node.url = this.sliceSerialize(token)\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token)\n    const node = this.stack[this.stack.length - 1]\n    node.url = 'mailto:' + this.sliceSerialize(token)\n  }\n\n  //\n  // Creaters.\n  //\n\n  /** @returns {Blockquote} */\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    }\n  }\n\n  /** @returns {Code} */\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    }\n  }\n\n  /** @returns {InlineCode} */\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    }\n  }\n\n  /** @returns {Definition} */\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    }\n  }\n\n  /** @returns {Emphasis} */\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    }\n  }\n\n  /** @returns {Heading} */\n  function heading() {\n    // @ts-expect-error `depth` will be set later.\n    return {\n      type: 'heading',\n      depth: undefined,\n      children: []\n    }\n  }\n\n  /** @returns {Break} */\n  function hardBreak() {\n    return {\n      type: 'break'\n    }\n  }\n\n  /** @returns {HTML} */\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    }\n  }\n\n  /** @returns {Image} */\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    }\n  }\n\n  /** @returns {Link} */\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      children: []\n    }\n  }\n\n  /**\n   * @param {Token} token\n   * @returns {List}\n   */\n  function list(token) {\n    return {\n      type: 'list',\n      ordered: token.type === 'listOrdered',\n      start: null,\n      spread: token._spread,\n      children: []\n    }\n  }\n\n  /**\n   * @param {Token} token\n   * @returns {ListItem}\n   */\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      spread: token._spread,\n      checked: null,\n      children: []\n    }\n  }\n\n  /** @returns {Paragraph} */\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    }\n  }\n\n  /** @returns {Strong} */\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    }\n  }\n\n  /** @returns {Text} */\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    }\n  }\n\n  /** @returns {ThematicBreak} */\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    }\n  }\n}\n\n/**\n * Copy a point-like value.\n *\n * @param {Point} d\n *   Point-like value.\n * @returns {Point}\n *   unist point.\n */\nfunction point(d) {\n  return {\n    line: d.line,\n    column: d.column,\n    offset: d.offset\n  }\n}\n\n/**\n * @param {Config} combined\n * @param {Array<Extension | Array<Extension>>} extensions\n * @returns {void}\n */\nfunction configure(combined, extensions) {\n  let index = -1\n  while (++index < extensions.length) {\n    const value = extensions[index]\n    if (Array.isArray(value)) {\n      configure(combined, value)\n    } else {\n      extension(combined, value)\n    }\n  }\n}\n\n/**\n * @param {Config} combined\n * @param {Extension} extension\n * @returns {void}\n */\nfunction extension(combined, extension) {\n  /** @type {keyof Extension} */\n  let key\n  for (key in extension) {\n    if (own.call(extension, key)) {\n      if (key === 'canContainEols') {\n        const right = extension[key]\n        if (right) {\n          combined[key].push(...right)\n        }\n      } else if (key === 'transforms') {\n        const right = extension[key]\n        if (right) {\n          combined[key].push(...right)\n        }\n      } else if (key === 'enter' || key === 'exit') {\n        const right = extension[key]\n        if (right) {\n          Object.assign(combined[key], right)\n        }\n      }\n    }\n  }\n}\n\n/** @type {OnEnterError} */\nfunction defaultOnError(left, right) {\n  if (left) {\n    throw new Error(\n      'Cannot close `' +\n        left.type +\n        '` (' +\n        stringifyPosition({\n          start: left.start,\n          end: left.end\n        }) +\n        '): a different token (`' +\n        right.type +\n        '`, ' +\n        stringifyPosition({\n          start: right.start,\n          end: right.end\n        }) +\n        ') is open'\n    )\n  } else {\n    throw new Error(\n      'Cannot close document, a token (`' +\n        right.type +\n        '`, ' +\n        stringifyPosition({\n          start: right.start,\n          end: right.end\n        }) +\n        ') is still open'\n    )\n  }\n}\n","/**\n * @typedef {import('micromark-util-types').Event} Event\n */\n\nimport {subtokenize} from 'micromark-util-subtokenize'\n\n/**\n * @param {Array<Event>} events\n * @returns {Array<Event>}\n */\nexport function postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n  return events\n}\n","import { l as log, J as decodeEntities } from \"./mermaid-485fd1a4.js\";\nimport { fromMarkdown } from \"mdast-util-from-markdown\";\nimport { dedent } from \"ts-dedent\";\nfunction preprocessMarkdown(markdown) {\n  const withoutMultipleNewlines = markdown.replace(/\\n{2,}/g, \"\\n\");\n  const withoutExtraSpaces = dedent(withoutMultipleNewlines);\n  return withoutExtraSpaces;\n}\nfunction markdownToLines(markdown) {\n  const preprocessedMarkdown = preprocessMarkdown(markdown);\n  const { children } = fromMarkdown(preprocessedMarkdown);\n  const lines = [[]];\n  let currentLine = 0;\n  function processNode(node, parentType = \"normal\") {\n    if (node.type === \"text\") {\n      const textLines = node.value.split(\"\\n\");\n      textLines.forEach((textLine, index) => {\n        if (index !== 0) {\n          currentLine++;\n          lines.push([]);\n        }\n        textLine.split(\" \").forEach((word) => {\n          if (word) {\n            lines[currentLine].push({ content: word, type: parentType });\n          }\n        });\n      });\n    } else if (node.type === \"strong\" || node.type === \"emphasis\") {\n      node.children.forEach((contentNode) => {\n        processNode(contentNode, node.type);\n      });\n    }\n  }\n  children.forEach((treeNode) => {\n    if (treeNode.type === \"paragraph\") {\n      treeNode.children.forEach((contentNode) => {\n        processNode(contentNode);\n      });\n    }\n  });\n  return lines;\n}\nfunction markdownToHTML(markdown) {\n  const { children } = fromMarkdown(markdown);\n  function output(node) {\n    if (node.type === \"text\") {\n      return node.value.replace(/\\n/g, \"<br/>\");\n    } else if (node.type === \"strong\") {\n      return `<strong>${node.children.map(output).join(\"\")}</strong>`;\n    } else if (node.type === \"emphasis\") {\n      return `<em>${node.children.map(output).join(\"\")}</em>`;\n    } else if (node.type === \"paragraph\") {\n      return `<p>${node.children.map(output).join(\"\")}</p>`;\n    }\n    return `Unsupported markdown: ${node.type}`;\n  }\n  return children.map(output).join(\"\");\n}\nfunction splitTextToChars(text) {\n  if (Intl.Segmenter) {\n    return [...new Intl.Segmenter().segment(text)].map((s) => s.segment);\n  }\n  return [...text];\n}\nfunction splitWordToFitWidth(checkFit, word) {\n  const characters = splitTextToChars(word.content);\n  return splitWordToFitWidthRecursion(checkFit, [], characters, word.type);\n}\nfunction splitWordToFitWidthRecursion(checkFit, usedChars, remainingChars, type) {\n  if (remainingChars.length === 0) {\n    return [\n      { content: usedChars.join(\"\"), type },\n      { content: \"\", type }\n    ];\n  }\n  const [nextChar, ...rest] = remainingChars;\n  const newWord = [...usedChars, nextChar];\n  if (checkFit([{ content: newWord.join(\"\"), type }])) {\n    return splitWordToFitWidthRecursion(checkFit, newWord, rest, type);\n  }\n  if (usedChars.length === 0 && nextChar) {\n    usedChars.push(nextChar);\n    remainingChars.shift();\n  }\n  return [\n    { content: usedChars.join(\"\"), type },\n    { content: remainingChars.join(\"\"), type }\n  ];\n}\nfunction splitLineToFitWidth(line, checkFit) {\n  if (line.some(({ content }) => content.includes(\"\\n\"))) {\n    throw new Error(\"splitLineToFitWidth does not support newlines in the line\");\n  }\n  return splitLineToFitWidthRecursion(line, checkFit);\n}\nfunction splitLineToFitWidthRecursion(words, checkFit, lines = [], newLine = []) {\n  if (words.length === 0) {\n    if (newLine.length > 0) {\n      lines.push(newLine);\n    }\n    return lines.length > 0 ? lines : [];\n  }\n  let joiner = \"\";\n  if (words[0].content === \" \") {\n    joiner = \" \";\n    words.shift();\n  }\n  const nextWord = words.shift() ?? { content: \" \", type: \"normal\" };\n  const lineWithNextWord = [...newLine];\n  if (joiner !== \"\") {\n    lineWithNextWord.push({ content: joiner, type: \"normal\" });\n  }\n  lineWithNextWord.push(nextWord);\n  if (checkFit(lineWithNextWord)) {\n    return splitLineToFitWidthRecursion(words, checkFit, lines, lineWithNextWord);\n  }\n  if (newLine.length > 0) {\n    lines.push(newLine);\n    words.unshift(nextWord);\n  } else if (nextWord.content) {\n    const [line, rest] = splitWordToFitWidth(checkFit, nextWord);\n    lines.push([line]);\n    if (rest.content) {\n      words.unshift(rest);\n    }\n  }\n  return splitLineToFitWidthRecursion(words, checkFit, lines);\n}\nfunction applyStyle(dom, styleFn) {\n  if (styleFn) {\n    dom.attr(\"style\", styleFn);\n  }\n}\nfunction addHtmlSpan(element, node, width, classes, addBackground = false) {\n  const fo = element.append(\"foreignObject\");\n  const div = fo.append(\"xhtml:div\");\n  const label = node.label;\n  const labelClass = node.isNode ? \"nodeLabel\" : \"edgeLabel\";\n  div.html(\n    `\n    <span class=\"${labelClass} ${classes}\" ` + (node.labelStyle ? 'style=\"' + node.labelStyle + '\"' : \"\") + \">\" + label + \"</span>\"\n  );\n  applyStyle(div, node.labelStyle);\n  div.style(\"display\", \"table-cell\");\n  div.style(\"white-space\", \"nowrap\");\n  div.style(\"max-width\", width + \"px\");\n  div.attr(\"xmlns\", \"http://www.w3.org/1999/xhtml\");\n  if (addBackground) {\n    div.attr(\"class\", \"labelBkg\");\n  }\n  let bbox = div.node().getBoundingClientRect();\n  if (bbox.width === width) {\n    div.style(\"display\", \"table\");\n    div.style(\"white-space\", \"break-spaces\");\n    div.style(\"width\", width + \"px\");\n    bbox = div.node().getBoundingClientRect();\n  }\n  fo.style(\"width\", bbox.width);\n  fo.style(\"height\", bbox.height);\n  return fo.node();\n}\nfunction createTspan(textElement, lineIndex, lineHeight) {\n  return textElement.append(\"tspan\").attr(\"class\", \"text-outer-tspan\").attr(\"x\", 0).attr(\"y\", lineIndex * lineHeight - 0.1 + \"em\").attr(\"dy\", lineHeight + \"em\");\n}\nfunction computeWidthOfText(parentNode, lineHeight, line) {\n  const testElement = parentNode.append(\"text\");\n  const testSpan = createTspan(testElement, 1, lineHeight);\n  updateTextContentAndStyles(testSpan, line);\n  const textLength = testSpan.node().getComputedTextLength();\n  testElement.remove();\n  return textLength;\n}\nfunction createFormattedText(width, g, structuredText, addBackground = false) {\n  const lineHeight = 1.1;\n  const labelGroup = g.append(\"g\");\n  const bkg = labelGroup.insert(\"rect\").attr(\"class\", \"background\");\n  const textElement = labelGroup.append(\"text\").attr(\"y\", \"-10.1\");\n  let lineIndex = 0;\n  for (const line of structuredText) {\n    const checkWidth = (line2) => computeWidthOfText(labelGroup, lineHeight, line2) <= width;\n    const linesUnderWidth = checkWidth(line) ? [line] : splitLineToFitWidth(line, checkWidth);\n    for (const preparedLine of linesUnderWidth) {\n      const tspan = createTspan(textElement, lineIndex, lineHeight);\n      updateTextContentAndStyles(tspan, preparedLine);\n      lineIndex++;\n    }\n  }\n  if (addBackground) {\n    const bbox = textElement.node().getBBox();\n    const padding = 2;\n    bkg.attr(\"x\", -padding).attr(\"y\", -padding).attr(\"width\", bbox.width + 2 * padding).attr(\"height\", bbox.height + 2 * padding);\n    return labelGroup.node();\n  } else {\n    return textElement.node();\n  }\n}\nfunction updateTextContentAndStyles(tspan, wrappedLine) {\n  tspan.text(\"\");\n  wrappedLine.forEach((word, index) => {\n    const innerTspan = tspan.append(\"tspan\").attr(\"font-style\", word.type === \"emphasis\" ? \"italic\" : \"normal\").attr(\"class\", \"text-inner-tspan\").attr(\"font-weight\", word.type === \"strong\" ? \"bold\" : \"normal\");\n    if (index === 0) {\n      innerTspan.text(word.content);\n    } else {\n      innerTspan.text(\" \" + word.content);\n    }\n  });\n}\nconst createText = (el, text = \"\", {\n  style = \"\",\n  isTitle = false,\n  classes = \"\",\n  useHtmlLabels = true,\n  isNode = true,\n  width = 200,\n  addSvgBackground = false\n} = {}) => {\n  log.info(\"createText\", text, style, isTitle, classes, useHtmlLabels, isNode, addSvgBackground);\n  if (useHtmlLabels) {\n    const htmlText = markdownToHTML(text);\n    const node = {\n      isNode,\n      label: decodeEntities(htmlText).replace(\n        /fa[blrs]?:fa-[\\w-]+/g,\n        (s) => `<i class='${s.replace(\":\", \" \")}'></i>`\n      ),\n      labelStyle: style.replace(\"fill:\", \"color:\")\n    };\n    const vertexNode = addHtmlSpan(el, node, width, classes, addSvgBackground);\n    return vertexNode;\n  } else {\n    const structuredText = markdownToLines(text);\n    const svgLabel = createFormattedText(width, el, structuredText, addSvgBackground);\n    return svgLabel;\n  }\n};\nexport {\n  createText as c\n};\n"],"names":["emptyOptions","one","value","includeImageAlt","includeHtml","Boolean","node","type","alt","children","Array","isArray","values","result","index","length","join","splice","list","start","remove","items","end","parameters","chunkStart","from","unshift","slice","push","hasOwnProperty","syntaxExtension","all","extension","hook","left","call","undefined","right","code","constructs","existing","before","add","asciiAlpha","regexCheck","asciiAlphanumeric","asciiAtext","asciiDigit","asciiHexDigit","asciiPunctuation","markdownLineEnding","markdownLineEndingOrSpace","markdownSpace","unicodePunctuation","unicodeWhitespace","regex","test","String","fromCharCode","factorySpace","effects","ok","max","limit","Number","POSITIVE_INFINITY","size","enter","prefix","consume","exit","content","tokenize","contentStart","attempt","this","parser","contentInitial","lineStart","previous","token","contentType","next","data","self","stack","childFlow","childToken","lineStartOffset","continued","item","containerState","continuation","documentContinue","checkNewContainers","_closeFlow","closeFlow","indexBeforeExits","events","point","indexBeforeFlow","exitContainers","Object","assign","documentContinued","currentConstruct","concrete","flowStart","interrupt","_gfmTableDynamicInterruptHack","check","containerConstruct","thereIsANewContainer","thereIsNoNewContainer","lazy","now","line","offset","containerContinue","flow","_tokenizer","flowContinue","writeToChild","eof","stream","sliceStream","defineSkip","write","seen","entry","nok","document","disable","null","includes","blankLine","after","partial","subtokenize","jumps","event","lineIndex","otherIndex","otherEvent","subevents","more","_isInFirstContentOfListItem","subcontent","_container","eventIndex","context","startPosition","startPositions","tokenizer","childEvents","gaps","current","adjust","breaks","_gfmTasklistFirstContentOfListItem","pop","chunkInside","contentEnd","continuationConstruct","contentContinue","resolve","prefixed","tail","sliceSerialize","initial","flowInitial","afterConstruct","resolver","resolveAll","createResolver","string","initializeFactory","field","text","notText","atBreak","resolveAllLineSuffixes","extraResolver","chunks","tabs","bufferIndex","chunk","charCodeAt","column","_index","_bufferIndex","called","createTokenizer","initialize","columnStart","resolveAllConstructs","consumed","accountForPotentialSkip","fields","constructFactory","construct","info","addResult","onsuccessfulcheck","expandTabs","atTab","serializeChunks","main","expectedCode","state","startIndex","startBufferIndex","endIndex","endBufferIndex","view","head","shift","sliceChunks","chunkIndex","go","_","restore","onreturn","returnState","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","map","def","handleMapOfConstructs","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","store","name","create","resolveTo","thematicBreak","marker","sequence","initialSize","kind","atMarker","inside","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","furtherBlankLines","notInCurrentItem","indentConstruct","blockQuote","open","contBefore","factoryDestination","literalType","literalMarkerType","rawType","stringType","balance","enclosedBefore","raw","enclosed","enclosedEscape","rawEscape","factoryLabel","markerType","labelInside","labelEscape","factoryTitle","begin","escape","factoryWhitespace","normalizeIdentifier","replace","toLowerCase","toUpperCase","definition","identifier","labelAfter","markerAfter","destinationBefore","destinationAfter","titleBefore","afterWhitespace","defined","beforeMarker","titleAfter","titleAfterOptionalWhitespace","codeIndented","afterPrefix","furtherStart","headingAtx","sequenceOpen","sequenceFurther","setextUnderline","paragraph","heading","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","metaBefore","meta","contentBefore","beforeContentChunk","contentChunk","characterReference","numeric","decodeNamedCharacterReference","characterEscape","lineEnding","labelEnd","labelStart","_balanced","_inactive","labelEndNok","resourceConstruct","labelEndOk","referenceFullConstruct","referenceNotFull","referenceCollapsedConstruct","close","media","group","label","insideSpan","resourceBefore","resourceOpen","resourceEnd","resourceDestinationAfter","resourceDestinationMissing","resourceBetween","resourceTitleAfter","referenceFullAfter","referenceFullMissing","referenceCollapsedOpen","classifyCharacter","attention","attentionMarkers","_open","_close","openingSequence","closingSequence","use","nextEvents","movePoint","htmlText","instruction","tagOpen","declaration","commentEnd","comment","commentClose","lineEndingBefore","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","lineEndingAfter","lineEndingAfterPrefix","codeText","between","tailExitIndex","headEnterIndex","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","asciiControl","emailAtSignOrDot","emailLabel","emailValue","parse","options","extensions","combineExtensions","search","decodeNumericCharacterReference","base","parseInt","characterEscapeOrReference","decode","$0","$1","$2","hex","stringifyPosition","position","pos","own","fromMarkdown","encoding","config","transforms","canContainEols","autolink","opener","link","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","codeFlow","codeFencedFenceInfo","codeFencedFenceMeta","codeTextData","codeFlowValue","definitionDestinationString","definitionLabelString","definitionTitleString","emphasis","hardBreakEscape","hardBreak","hardBreakTrailing","html","htmlFlowData","htmlTextData","image","listItem","listItemValue","onenterlistitemvalue","listOrdered","onenterlistordered","listUnordered","reference","onenterreference","referenceString","resourceDestinationString","resourceTitleString","setextHeading","strong","closer","atxHeadingSequence","onexitatxheadingsequence","onexitautolinkemail","onexitautolinkprotocol","characterEscapeValue","onexitdata","characterReferenceMarkerHexadecimal","onexitcharacterreferencemarker","characterReferenceMarkerNumeric","characterReferenceValue","onexitcharacterreferencevalue","onexitcodefenced","codeFencedFence","onexitcodefencedfence","onexitcodefencedfenceinfo","onexitcodefencedfencemeta","onexitcodeindented","onexitcodetext","onexitdefinitiondestinationstring","onexitdefinitionlabelstring","onexitdefinitiontitlestring","onexithardbreak","onexithtmlflow","onexithtmltext","onexitimage","onexitlabel","labelText","onexitlabeltext","onexitlineending","onexitlink","onexitreferencestring","onexitresourcedestinationstring","onexitresourcetitlestring","resource","onexitresource","onexitsetextheading","setextHeadingLineSequence","onexitsetextheadinglinesequence","setextHeadingText","onexitsetextheadingtext","configure","mdastExtensions","compile","tree","tokenStack","resume","setData","getData","listStack","prepareList","handler","defaultOnError","firstBlankLineIndex","containerBalance","listSpread","tailIndex","tailEvent","_spread","key","and","errorHandler","onExitError","Error","settings","lang","title","url","depth","referenceType","ancestor","decodeString","fragment","ordered","spread","checked","compiler","postprocess","atCarriageReturn","match","endPosition","toString","lastIndex","exec","Math","ceil","preprocess","d","combined","markdownToLines","markdown","preprocessedMarkdown","withoutMultipleNewlines","dedent","preprocessMarkdown","lines","currentLine","processNode","parentType","split","forEach","textLine","word","contentNode","treeNode","splitWordToFitWidth","checkFit","splitWordToFitWidthRecursion","Intl","Segmenter","segment","s","usedChars","remainingChars","nextChar","rest","newWord","splitLineToFitWidth","some","splitLineToFitWidthRecursion","words","newLine","joiner","nextWord","lineWithNextWord","createTspan","textElement","lineHeight","append","attr","computeWidthOfText","parentNode","testElement","testSpan","updateTextContentAndStyles","textLength","getComputedTextLength","tspan","wrappedLine","innerTspan","createText","el","style","isTitle","classes","useHtmlLabels","isNode","width","addSvgBackground","l","output","markdownToHTML","vertexNode","element","addBackground","fo","div","labelClass","dom","styleFn","labelStyle","bbox","getBoundingClientRect","height","addHtmlSpan","svgLabel","g","structuredText","labelGroup","bkg","insert","checkWidth","line2","linesUnderWidth","preparedLine","getBBox","padding","createFormattedText"],"sourceRoot":""}