@easyv/biz-components 1.0.29 → 2.1.0

package/dist/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-fenced.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"code-fenced.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-fenced.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nconst nonLazyContinuation = {\n  partial: true,\n  tokenize: tokenizeNonLazyContinuation\n};\n\n/** @type {Construct} */\nexport const codeFenced = {\n  concrete: true,\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  const self = this;\n  /** @type {Construct} */\n  const closeStart = {\n    partial: true,\n    tokenize: tokenizeCloseStart\n  };\n  let initialPrefix = 0;\n  let sizeOpen = 0;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of code.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse whitespace like `markdown-rs`.\n    return beforeSequenceOpen(code);\n  }\n\n  /**\n   * In opening fence, after prefix, at sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeSequenceOpen(code) {\n    const tail = self.events[self.events.length - 1];\n    initialPrefix = tail && tail[1].type === \"linePrefix\" ? tail[2].sliceSerialize(tail[1], true).length : 0;\n    marker = code;\n    effects.enter(\"codeFenced\");\n    effects.enter(\"codeFencedFence\");\n    effects.enter(\"codeFencedFenceSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening fence sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *      ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === marker) {\n      sizeOpen++;\n      effects.consume(code);\n      return sequenceOpen;\n    }\n    if (sizeOpen < 3) {\n      return nok(code);\n    }\n    effects.exit(\"codeFencedFenceSequence\");\n    return markdownSpace(code) ? factorySpace(effects, infoBefore, \"whitespace\")(code) : infoBefore(code);\n  }\n\n  /**\n   * In opening fence, after the sequence (and optional whitespace), before info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function infoBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFencedFence\");\n      return self.interrupt ? ok(code) : effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);\n    }\n    effects.enter(\"codeFencedFenceInfo\");\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return info(code);\n  }\n\n  /**\n   * In info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function info(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceInfo\");\n      return infoBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceInfo\");\n      return factorySpace(effects, metaBefore, \"whitespace\")(code);\n    }\n    if (code === 96 && code === marker) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return info;\n  }\n\n  /**\n   * In opening fence, after info and whitespace, before meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function metaBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return infoBefore(code);\n    }\n    effects.enter(\"codeFencedFenceMeta\");\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return meta(code);\n  }\n\n  /**\n   * In meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceMeta\");\n      return infoBefore(code);\n    }\n    if (code === 96 && code === marker) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return meta;\n  }\n\n  /**\n   * At eol/eof in code, before a non-lazy closing fence or content.\n   *\n   * ```markdown\n   * > | ~~~js\n   *          ^\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function atNonLazyBreak(code) {\n    return effects.attempt(closeStart, after, contentBefore)(code);\n  }\n\n  /**\n   * Before code content, not a closing fence, at eol.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentBefore(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return contentStart;\n  }\n\n  /**\n   * Before code content, not a closing fence.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentStart(code) {\n    return initialPrefix > 0 && markdownSpace(code) ? factorySpace(effects, beforeContentChunk, \"linePrefix\", initialPrefix + 1)(code) : beforeContentChunk(code);\n  }\n\n  /**\n   * Before code content, after optional prefix.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeContentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);\n    }\n    effects.enter(\"codeFlowValue\");\n    return contentChunk(code);\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^^^^^^^^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFlowValue\");\n      return beforeContentChunk(code);\n    }\n    effects.consume(code);\n    return contentChunk;\n  }\n\n  /**\n   * After code.\n   *\n   * ```markdown\n   *   | ~~~js\n   *   | alert(1)\n   * > | ~~~\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    effects.exit(\"codeFenced\");\n    return ok(code);\n  }\n\n  /**\n   * @this {TokenizeContext}\n   *   Context.\n   * @type {Tokenizer}\n   */\n  function tokenizeCloseStart(effects, ok, nok) {\n    let size = 0;\n    return startBefore;\n\n    /**\n     *\n     *\n     * @type {State}\n     */\n    function startBefore(code) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return start;\n    }\n\n    /**\n     * Before closing fence, at optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function start(code) {\n      // Always populated by defaults.\n\n      // To do: `enter` here or in next state?\n      effects.enter(\"codeFencedFence\");\n      return markdownSpace(code) ? factorySpace(effects, beforeSequenceClose, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : beforeSequenceClose(code);\n    }\n\n    /**\n     * In closing fence, after optional whitespace, at sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function beforeSequenceClose(code) {\n      if (code === marker) {\n        effects.enter(\"codeFencedFenceSequence\");\n        return sequenceClose(code);\n      }\n      return nok(code);\n    }\n\n    /**\n     * In closing fence sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceClose(code) {\n      if (code === marker) {\n        size++;\n        effects.consume(code);\n        return sequenceClose;\n      }\n      if (size >= sizeOpen) {\n        effects.exit(\"codeFencedFenceSequence\");\n        return markdownSpace(code) ? factorySpace(effects, sequenceCloseAfter, \"whitespace\")(code) : sequenceCloseAfter(code);\n      }\n      return nok(code);\n    }\n\n    /**\n     * After closing fence sequence, after optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *        ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceCloseAfter(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit(\"codeFencedFence\");\n        return ok(code);\n      }\n      return nok(code);\n    }\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuation(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return lineStart;\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function lineStart(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);\n  }\n}"],"names":["effects","ok","nok","start"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-indented.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"code-indented.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-indented.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented\n};\n\n/** @type {Construct} */\nconst furtherStart = {\n  partial: true,\n  tokenize: tokenizeFurtherStart\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of code (indented).\n   *\n   * > **Parsing note**: it is not needed to check if this first line is a\n   * > filled line (that it has a non-whitespace character), because blank lines\n   * > are parsed already, so we never run into that.\n   *\n   * ```markdown\n   * > |     aaa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: manually check if interrupting like `markdown-rs`.\n\n    effects.enter(\"codeIndented\");\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, \"linePrefix\", 4 + 1)(code);\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? atBreak(code) : nok(code);\n  }\n\n  /**\n   * At a break.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === null) {\n      return after(code);\n    }\n    if (markdownLineEnding(code)) {\n      return effects.attempt(furtherStart, atBreak, after)(code);\n    }\n    effects.enter(\"codeFlowValue\");\n    return inside(code);\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFlowValue\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return inside;\n  }\n\n  /** @type {State} */\n  function after(code) {\n    effects.exit(\"codeIndented\");\n    // To do: allow interrupting like `markdown-rs`.\n    // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeFurtherStart(effects, ok, nok) {\n  const self = this;\n  return furtherStart;\n\n  /**\n   * At eol, trying to parse another indent.\n   *\n   * ```markdown\n   * > |     aaa\n   *            ^\n   *   |     bbb\n   * ```\n   *\n   * @type {State}\n   */\n  function furtherStart(code) {\n    // To do: improve `lazy` / `pierce` handling.\n    // If this is a lazy line, it can’t be code.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return furtherStart;\n    }\n\n    // To do: the code here in `micromark-js` is a bit different from\n    // `markdown-rs` because there it can attempt spaces.\n    // We can’t yet.\n    //\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, \"linePrefix\", 4 + 1)(code);\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? ok(code) : markdownLineEnding(code) ? furtherStart(code) : nok(code);\n  }\n}"],"names":["furtherStart"],"mappings":";;AAYY,MAAC,eAAe;AAAA,EAC1B,MAAM;AAAA,EACN,UAAU;AACZ;AAGA,MAAM,eAAe;AAAA,EACnB,SAAS;AAAA,EACT,UAAU;AACZ;AAOA,SAAS,qBAAqB,SAAS,IAAI,KAAK;AAC9C,QAAM,OAAO;AACb,SAAO;AAgBP,WAAS,MAAM,MAAM;AAGnB,YAAQ,MAAM,cAAc;AAG5B,WAAO,aAAa,SAAS,aAAa,cAAc,IAAI,CAAC,EAAE,IAAI;AAAA,EACvE;AAYE,WAAS,YAAY,MAAM;AACzB,UAAM,OAAO,KAAK,OAAO,KAAK,OAAO,SAAS,CAAC;AAC/C,WAAO,QAAQ,KAAK,CAAC,EAAE,SAAS,gBAAgB,KAAK,CAAC,EAAE,eAAe,KAAK,CAAC,GAAG,IAAI,EAAE,UAAU,IAAI,QAAQ,IAAI,IAAI,IAAI,IAAI;AAAA,EAChI;AAYE,WAAS,QAAQ,MAAM;AACrB,QAAI,SAAS,MAAM;AACjB,aAAO,MAAM,IAAI;AAAA,IACvB;AACI,QAAI,mBAAmB,IAAI,GAAG;AAC5B,aAAO,QAAQ,QAAQ,cAAc,SAAS,KAAK,EAAE,IAAI;AAAA,IAC/D;AACI,YAAQ,MAAM,eAAe;AAC7B,WAAO,OAAO,IAAI;AAAA,EACtB;AAYE,WAAS,OAAO,MAAM;AACpB,QAAI,SAAS,QAAQ,mBAAmB,IAAI,GAAG;AAC7C,cAAQ,KAAK,eAAe;AAC5B,aAAO,QAAQ,IAAI;AAAA,IACzB;AACI,YAAQ,QAAQ,IAAI;AACpB,WAAO;AAAA,EACX;AAGE,WAAS,MAAM,MAAM;AACnB,YAAQ,KAAK,cAAc;AAI3B,WAAO,GAAG,IAAI;AAAA,EAClB;AACA;AAOA,SAAS,qBAAqB,SAAS,IAAI,KAAK;AAC9C,QAAM,OAAO;AACb,SAAOA;AAaP,WAASA,cAAa,MAAM;AAG1B,QAAI,KAAK,OAAO,KAAK,KAAK,IAAG,EAAG,IAAI,GAAG;AACrC,aAAO,IAAI,IAAI;AAAA,IACrB;AACI,QAAI,mBAAmB,IAAI,GAAG;AAC5B,cAAQ,MAAM,YAAY;AAC1B,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,YAAY;AACzB,aAAOA;AAAA,IACb;AAQI,WAAO,aAAa,SAAS,aAAa,cAAc,IAAI,CAAC,EAAE,IAAI;AAAA,EACvE;AAYE,WAAS,YAAY,MAAM;AACzB,UAAM,OAAO,KAAK,OAAO,KAAK,OAAO,SAAS,CAAC;AAC/C,WAAO,QAAQ,KAAK,CAAC,EAAE,SAAS,gBAAgB,KAAK,CAAC,EAAE,eAAe,KAAK,CAAC,GAAG,IAAI,EAAE,UAAU,IAAI,GAAG,IAAI,IAAI,mBAAmB,IAAI,IAAIA,cAAa,IAAI,IAAI,IAAI,IAAI;AAAA,EAC3K;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-text.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"code-text.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-text.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   Previous,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const codeText = {\n  name: 'codeText',\n  previous,\n  resolve: resolveCodeText,\n  tokenize: tokenizeCodeText\n};\n\n// To do: next major: don’t resolve, like `markdown-rs`.\n/** @type {Resolver} */\nfunction resolveCodeText(events) {\n  let tailExitIndex = events.length - 4;\n  let headEnterIndex = 3;\n  /** @type {number} */\n  let index;\n  /** @type {number | undefined} */\n  let enter;\n\n  // If we start and end with an EOL or a space.\n  if ((events[headEnterIndex][1].type === \"lineEnding\" || events[headEnterIndex][1].type === 'space') && (events[tailExitIndex][1].type === \"lineEnding\" || events[tailExitIndex][1].type === 'space')) {\n    index = headEnterIndex;\n\n    // And we have data.\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === \"codeTextData\") {\n        // Then we have padding.\n        events[headEnterIndex][1].type = \"codeTextPadding\";\n        events[tailExitIndex][1].type = \"codeTextPadding\";\n        headEnterIndex += 2;\n        tailExitIndex -= 2;\n        break;\n      }\n    }\n  }\n\n  // Merge adjacent spaces and data.\n  index = headEnterIndex - 1;\n  tailExitIndex++;\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== \"lineEnding\") {\n        enter = index;\n      }\n    } else if (index === tailExitIndex || events[index][1].type === \"lineEnding\") {\n      events[enter][1].type = \"codeTextData\";\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end;\n        events.splice(enter + 2, index - enter - 2);\n        tailExitIndex -= index - enter - 2;\n        index = enter + 2;\n      }\n      enter = undefined;\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Previous}\n */\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return code !== 96 || this.events[this.events.length - 1][1].type === \"characterEscape\";\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeText(effects, ok, nok) {\n  const self = this;\n  let sizeOpen = 0;\n  /** @type {number} */\n  let size;\n  /** @type {Token} */\n  let token;\n  return start;\n\n  /**\n   * Start of code (text).\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * > | \\`a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"codeText\");\n    effects.enter(\"codeTextSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 96) {\n      effects.consume(code);\n      sizeOpen++;\n      return sequenceOpen;\n    }\n    effects.exit(\"codeTextSequence\");\n    return between(code);\n  }\n\n  /**\n   * Between something and something else.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function between(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code);\n    }\n\n    // To do: next major: don’t do spaces in resolve, but when compiling,\n    // like `markdown-rs`.\n    // Tabs don’t work, and virtual spaces don’t make sense.\n    if (code === 32) {\n      effects.enter('space');\n      effects.consume(code);\n      effects.exit('space');\n      return between;\n    }\n\n    // Closing fence? Could also be data.\n    if (code === 96) {\n      token = effects.enter(\"codeTextSequence\");\n      size = 0;\n      return sequenceClose(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return between;\n    }\n\n    // Data.\n    effects.enter(\"codeTextData\");\n    return data(code);\n  }\n\n  /**\n   * In data.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {\n      effects.exit(\"codeTextData\");\n      return between(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n\n  /**\n   * In closing sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceClose(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code);\n      size++;\n      return sequenceClose;\n    }\n\n    // Done!\n    if (size === sizeOpen) {\n      effects.exit(\"codeTextSequence\");\n      effects.exit(\"codeText\");\n      return ok(code);\n    }\n\n    // More or less accents: mark as data.\n    token.type = \"codeTextData\";\n    return data(code);\n  }\n}"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/content.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"content.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/content.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { subtokenize } from 'micromark-util-subtokenize';\n/**\n * No name because it must not be turned off.\n * @type {Construct}\n */\nexport const content = {\n  resolve: resolveContent,\n  tokenize: tokenizeContent\n};\n\n/** @type {Construct} */\nconst continuationConstruct = {\n  partial: true,\n  tokenize: tokenizeContinuation\n};\n\n/**\n * Content is transparent: it’s parsed right now. That way, definitions are also\n * parsed right now: before text in paragraphs (specifically, media) are parsed.\n *\n * @type {Resolver}\n */\nfunction resolveContent(events) {\n  subtokenize(events);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeContent(effects, ok) {\n  /** @type {Token | undefined} */\n  let previous;\n  return chunkStart;\n\n  /**\n   * Before a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkStart(code) {\n    effects.enter(\"content\");\n    previous = effects.enter(\"chunkContent\", {\n      contentType: \"content\"\n    });\n    return chunkInside(code);\n  }\n\n  /**\n   * In a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkInside(code) {\n    if (code === null) {\n      return contentEnd(code);\n    }\n\n    // To do: in `markdown-rs`, each line is parsed on its own, and everything\n    // is stitched together resolving.\n    if (markdownLineEnding(code)) {\n      return effects.check(continuationConstruct, contentContinue, contentEnd)(code);\n    }\n\n    // Data.\n    effects.consume(code);\n    return chunkInside;\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentEnd(code) {\n    effects.exit(\"chunkContent\");\n    effects.exit(\"content\");\n    return ok(code);\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentContinue(code) {\n    effects.consume(code);\n    effects.exit(\"chunkContent\");\n    previous.next = effects.enter(\"chunkContent\", {\n      contentType: \"content\",\n      previous\n    });\n    previous = previous.next;\n    return chunkInside;\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeContinuation(effects, ok, nok) {\n  const self = this;\n  return startLookahead;\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function startLookahead(code) {\n    effects.exit(\"chunkContent\");\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, prefixed, \"linePrefix\");\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    // Always populated by defaults.\n\n    const tail = self.events[self.events.length - 1];\n    if (!self.parser.constructs.disable.null.includes('codeIndented') && tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4) {\n      return ok(code);\n    }\n    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code);\n  }\n}"],"names":[],"mappings":";;;AAkBY,MAAC,UAAU;AAAA,EACrB,SAAS;AAAA,EACT,UAAU;AACZ;AAGA,MAAM,wBAAwB;AAAA,EAC5B,SAAS;AAAA,EACT,UAAU;AACZ;AAQA,SAAS,eAAe,QAAQ;AAC9B,cAAY,MAAM;AAClB,SAAO;AACT;AAOA,SAAS,gBAAgB,SAAS,IAAI;AAEpC,MAAI;AACJ,SAAO;AAYP,WAAS,WAAW,MAAM;AACxB,YAAQ,MAAM,SAAS;AACvB,eAAW,QAAQ,MAAM,gBAAgB;AAAA,MACvC,aAAa;AAAA,IACnB,CAAK;AACD,WAAO,YAAY,IAAI;AAAA,EAC3B;AAYE,WAAS,YAAY,MAAM;AACzB,QAAI,SAAS,MAAM;AACjB,aAAO,WAAW,IAAI;AAAA,IAC5B;AAII,QAAI,mBAAmB,IAAI,GAAG;AAC5B,aAAO,QAAQ,MAAM,uBAAuB,iBAAiB,UAAU,EAAE,IAAI;AAAA,IACnF;AAGI,YAAQ,QAAQ,IAAI;AACpB,WAAO;AAAA,EACX;AAOE,WAAS,WAAW,MAAM;AACxB,YAAQ,KAAK,cAAc;AAC3B,YAAQ,KAAK,SAAS;AACtB,WAAO,GAAG,IAAI;AAAA,EAClB;AAOE,WAAS,gBAAgB,MAAM;AAC7B,YAAQ,QAAQ,IAAI;AACpB,YAAQ,KAAK,cAAc;AAC3B,aAAS,OAAO,QAAQ,MAAM,gBAAgB;AAAA,MAC5C,aAAa;AAAA,MACb;AAAA,IACN,CAAK;AACD,eAAW,SAAS;AACpB,WAAO;AAAA,EACX;AACA;AAOA,SAAS,qBAAqB,SAAS,IAAI,KAAK;AAC9C,QAAM,OAAO;AACb,SAAO;AAOP,WAAS,eAAe,MAAM;AAC5B,YAAQ,KAAK,cAAc;AAC3B,YAAQ,MAAM,YAAY;AAC1B,YAAQ,QAAQ,IAAI;AACpB,YAAQ,KAAK,YAAY;AACzB,WAAO,aAAa,SAAS,UAAU,YAAY;AAAA,EACvD;AAOE,WAAS,SAAS,MAAM;AACtB,QAAI,SAAS,QAAQ,mBAAmB,IAAI,GAAG;AAC7C,aAAO,IAAI,IAAI;AAAA,IACrB;AAII,UAAM,OAAO,KAAK,OAAO,KAAK,OAAO,SAAS,CAAC;AAC/C,QAAI,CAAC,KAAK,OAAO,WAAW,QAAQ,KAAK,SAAS,cAAc,KAAK,QAAQ,KAAK,CAAC,EAAE,SAAS,gBAAgB,KAAK,CAAC,EAAE,eAAe,KAAK,CAAC,GAAG,IAAI,EAAE,UAAU,GAAG;AAC/J,aAAO,GAAG,IAAI;AAAA,IACpB;AACI,WAAO,QAAQ,UAAU,KAAK,OAAO,WAAW,MAAM,KAAK,EAAE,EAAE,IAAI;AAAA,EACvE;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/definition.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"definition.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/definition.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factoryDestination } from 'micromark-factory-destination';\nimport { factoryLabel } from 'micromark-factory-label';\nimport { factorySpace } from 'micromark-factory-space';\nimport { factoryTitle } from 'micromark-factory-title';\nimport { factoryWhitespace } from 'micromark-factory-whitespace';\nimport { markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\n/** @type {Construct} */\nexport const definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n};\n\n/** @type {Construct} */\nconst titleBefore = {\n  partial: true,\n  tokenize: tokenizeTitleBefore\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeDefinition(effects, ok, nok) {\n  const self = this;\n  /** @type {string} */\n  let identifier;\n  return start;\n\n  /**\n   * At start of a definition.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // Do not interrupt paragraphs (but do follow definitions).\n    // To do: do `interrupt` the way `markdown-rs` does.\n    // To do: parse whitespace the way `markdown-rs` does.\n    effects.enter(\"definition\");\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at `[`.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    // To do: parse whitespace the way `markdown-rs` does.\n\n    return factoryLabel.call(self, effects, labelAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionLabel\", \"definitionLabelMarker\", \"definitionLabelString\")(code);\n  }\n\n  /**\n   * After label.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));\n    if (code === 58) {\n      effects.enter(\"definitionMarker\");\n      effects.consume(code);\n      effects.exit(\"definitionMarker\");\n      return markerAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After marker.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function markerAfter(code) {\n    // Note: whitespace is optional.\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, destinationBefore)(code) : destinationBefore(code);\n  }\n\n  /**\n   * Before destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationBefore(code) {\n    return factoryDestination(effects, destinationAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionDestination\", \"definitionDestinationLiteral\", \"definitionDestinationLiteralMarker\", \"definitionDestinationRaw\", \"definitionDestinationString\")(code);\n  }\n\n  /**\n   * After destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationAfter(code) {\n    return effects.attempt(titleBefore, after, after)(code);\n  }\n\n  /**\n   * After definition.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return markdownSpace(code) ? factorySpace(effects, afterWhitespace, \"whitespace\")(code) : afterWhitespace(code);\n  }\n\n  /**\n   * After definition, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterWhitespace(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"definition\");\n\n      // Note: we don’t care about uniqueness.\n      // It’s likely that that doesn’t happen very frequently.\n      // It is more likely that it wastes precious time.\n      self.parser.defined.push(identifier);\n\n      // To do: `markdown-rs` interrupt.\n      // // You’d be interrupting.\n      // tokenizer.interrupt = true\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeTitleBefore(effects, ok, nok) {\n  return titleBefore;\n\n  /**\n   * After destination, at whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleBefore(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, beforeMarker)(code) : nok(code);\n  }\n\n  /**\n   * At title.\n   *\n   * ```markdown\n   *   | [a]: b\n   * > | \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeMarker(code) {\n    return factoryTitle(effects, titleAfter, nok, \"definitionTitle\", \"definitionTitleMarker\", \"definitionTitleString\")(code);\n  }\n\n  /**\n   * After title.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfter(code) {\n    return markdownSpace(code) ? factorySpace(effects, titleAfterOptionalWhitespace, \"whitespace\")(code) : titleAfterOptionalWhitespace(code);\n  }\n\n  /**\n   * After title, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfterOptionalWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}"],"names":["titleBefore"],"mappings":";;;;;;;AAiBY,MAAC,aAAa;AAAA,EACxB,MAAM;AAAA,EACN,UAAU;AACZ;AAGA,MAAM,cAAc;AAAA,EAClB,SAAS;AAAA,EACT,UAAU;AACZ;AAOA,SAAS,mBAAmB,SAAS,IAAI,KAAK;AAC5C,QAAM,OAAO;AAEb,MAAI;AACJ,SAAO;AAYP,WAAS,MAAM,MAAM;AAInB,YAAQ,MAAM,YAAY;AAC1B,WAAO,OAAO,IAAI;AAAA,EACtB;AAYE,WAAS,OAAO,MAAM;AAGpB,WAAO,aAAa;AAAA,MAAK;AAAA,MAAM;AAAA,MAAS;AAAA;AAAA,MAExC;AAAA,MAAK;AAAA,MAAmB;AAAA,MAAyB;AAAA,IAAuB,EAAE,IAAI;AAAA,EAClF;AAYE,WAAS,WAAW,MAAM;AACxB,iBAAa,oBAAoB,KAAK,eAAe,KAAK,OAAO,KAAK,OAAO,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,EAAE,CAAC;AACzG,QAAI,SAAS,IAAI;AACf,cAAQ,MAAM,kBAAkB;AAChC,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,kBAAkB;AAC/B,aAAO;AAAA,IACb;AACI,WAAO,IAAI,IAAI;AAAA,EACnB;AAYE,WAAS,YAAY,MAAM;AAEzB,WAAO,0BAA0B,IAAI,IAAI,kBAAkB,SAAS,iBAAiB,EAAE,IAAI,IAAI,kBAAkB,IAAI;AAAA,EACzH;AAYE,WAAS,kBAAkB,MAAM;AAC/B,WAAO;AAAA,MAAmB;AAAA,MAAS;AAAA;AAAA,MAEnC;AAAA,MAAK;AAAA,MAAyB;AAAA,MAAgC;AAAA,MAAsC;AAAA,MAA4B;AAAA,IAA6B,EAAE,IAAI;AAAA,EACvK;AAYE,WAAS,iBAAiB,MAAM;AAC9B,WAAO,QAAQ,QAAQ,aAAa,OAAO,KAAK,EAAE,IAAI;AAAA,EAC1D;AAcE,WAAS,MAAM,MAAM;AACnB,WAAO,cAAc,IAAI,IAAI,aAAa,SAAS,iBAAiB,YAAY,EAAE,IAAI,IAAI,gBAAgB,IAAI;AAAA,EAClH;AAcE,WAAS,gBAAgB,MAAM;AAC7B,QAAI,SAAS,QAAQ,mBAAmB,IAAI,GAAG;AAC7C,cAAQ,KAAK,YAAY;AAKzB,WAAK,OAAO,QAAQ,KAAK,UAAU;AAKnC,aAAO,GAAG,IAAI;AAAA,IACpB;AACI,WAAO,IAAI,IAAI;AAAA,EACnB;AACA;AAOA,SAAS,oBAAoB,SAAS,IAAI,KAAK;AAC7C,SAAOA;AAcP,WAASA,aAAY,MAAM;AACzB,WAAO,0BAA0B,IAAI,IAAI,kBAAkB,SAAS,YAAY,EAAE,IAAI,IAAI,IAAI,IAAI;AAAA,EACtG;AAaE,WAAS,aAAa,MAAM;AAC1B,WAAO,aAAa,SAAS,YAAY,KAAK,mBAAmB,yBAAyB,uBAAuB,EAAE,IAAI;AAAA,EAC3H;AAYE,WAAS,WAAW,MAAM;AACxB,WAAO,cAAc,IAAI,IAAI,aAAa,SAAS,8BAA8B,YAAY,EAAE,IAAI,IAAI,6BAA6B,IAAI;AAAA,EAC5I;AAYE,WAAS,6BAA6B,MAAM;AAC1C,WAAO,SAAS,QAAQ,mBAAmB,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI;AAAA,EAC1E;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/hard-break-escape.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hard-break-escape.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/hard-break-escape.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of a hard break (escape).\n   *\n   * ```markdown\n   * > | a\\\n   *      ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"hardBreakEscape\");\n    effects.consume(code);\n    return after;\n  }\n\n  /**\n   * After `\\`, at eol.\n   *\n   * ```markdown\n   * > | a\\\n   *       ^\n   *   | b\n   * ```\n   *\n   *  @type {State}\n   */\n  function after(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit(\"hardBreakEscape\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n}"],"names":[],"mappings":";AAWY,MAAC,kBAAkB;AAAA,EAC7B,MAAM;AAAA,EACN,UAAU;AACZ;AAOA,SAAS,wBAAwB,SAAS,IAAI,KAAK;AACjD,SAAO;AAaP,WAAS,MAAM,MAAM;AACnB,YAAQ,MAAM,iBAAiB;AAC/B,YAAQ,QAAQ,IAAI;AACpB,WAAO;AAAA,EACX;AAaE,WAAS,MAAM,MAAM;AACnB,QAAI,mBAAmB,IAAI,GAAG;AAC5B,cAAQ,KAAK,iBAAiB;AAC9B,aAAO,GAAG,IAAI;AAAA,IACpB;AACI,WAAO,IAAI,IAAI;AAAA,EACnB;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/heading-atx.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"heading-atx.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/heading-atx.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { splice } from 'micromark-util-chunked';\n/** @type {Construct} */\nexport const headingAtx = {\n  name: 'headingAtx',\n  resolve: resolveHeadingAtx,\n  tokenize: tokenizeHeadingAtx\n};\n\n/** @type {Resolver} */\nfunction resolveHeadingAtx(events, context) {\n  let contentEnd = events.length - 2;\n  let contentStart = 3;\n  /** @type {Token} */\n  let content;\n  /** @type {Token} */\n  let text;\n\n  // Prefix whitespace, part of the opening.\n  if (events[contentStart][1].type === \"whitespace\") {\n    contentStart += 2;\n  }\n\n  // Suffix whitespace, part of the closing.\n  if (contentEnd - 2 > contentStart && events[contentEnd][1].type === \"whitespace\") {\n    contentEnd -= 2;\n  }\n  if (events[contentEnd][1].type === \"atxHeadingSequence\" && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === \"whitespace\")) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;\n  }\n  if (contentEnd > contentStart) {\n    content = {\n      type: \"atxHeadingText\",\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end\n    };\n    text = {\n      type: \"chunkText\",\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end,\n      contentType: \"text\"\n    };\n    splice(events, contentStart, contentEnd - contentStart + 1, [['enter', content, context], ['enter', text, context], ['exit', text, context], ['exit', content, context]]);\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  let size = 0;\n  return start;\n\n  /**\n   * Start of a heading (atx).\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    effects.enter(\"atxHeading\");\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at `#`.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"atxHeadingSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code);\n      return sequenceOpen;\n    }\n\n    // Always at least one `#`.\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"atxHeadingSequence\");\n      return atBreak(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ## aa\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === 35) {\n      effects.enter(\"atxHeadingSequence\");\n      return sequenceFurther(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"atxHeading\");\n      // To do: interrupt like `markdown-rs`.\n      // // Feel free to interrupt.\n      // tokenizer.interrupt = false\n      return ok(code);\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, \"whitespace\")(code);\n    }\n\n    // To do: generate `data` tokens, add the `text` token later.\n    // Needs edit map, see: `markdown.rs`.\n    effects.enter(\"atxHeadingText\");\n    return data(code);\n  }\n\n  /**\n   * In further sequence (after whitespace).\n   *\n   * Could be normal “visible” hashes in the heading or a final sequence.\n   *\n   * ```markdown\n   * > | ## aa ##\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceFurther(code) {\n    if (code === 35) {\n      effects.consume(code);\n      return sequenceFurther;\n    }\n    effects.exit(\"atxHeadingSequence\");\n    return atBreak(code);\n  }\n\n  /**\n   * In text.\n   *\n   * ```markdown\n   * > | ## aa\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"atxHeadingText\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n}"],"names":[],"mappings":";;;AAeY,MAAC,aAAa;AAAA,EACxB,MAAM;AAAA,EACN,SAAS;AAAA,EACT,UAAU;AACZ;AAGA,SAAS,kBAAkB,QAAQ,SAAS;AAC1C,MAAI,aAAa,OAAO,SAAS;AACjC,MAAI,eAAe;AAEnB,MAAI;AAEJ,MAAI;AAGJ,MAAI,OAAO,YAAY,EAAE,CAAC,EAAE,SAAS,cAAc;AACjD,oBAAgB;AAAA,EACpB;AAGE,MAAI,aAAa,IAAI,gBAAgB,OAAO,UAAU,EAAE,CAAC,EAAE,SAAS,cAAc;AAChF,kBAAc;AAAA,EAClB;AACE,MAAI,OAAO,UAAU,EAAE,CAAC,EAAE,SAAS,yBAAyB,iBAAiB,aAAa,KAAK,aAAa,IAAI,gBAAgB,OAAO,aAAa,CAAC,EAAE,CAAC,EAAE,SAAS,eAAe;AAChL,kBAAc,eAAe,MAAM,aAAa,IAAI;AAAA,EACxD;AACE,MAAI,aAAa,cAAc;AAC7B,cAAU;AAAA,MACR,MAAM;AAAA,MACN,OAAO,OAAO,YAAY,EAAE,CAAC,EAAE;AAAA,MAC/B,KAAK,OAAO,UAAU,EAAE,CAAC,EAAE;AAAA,IAC5B;AACD,WAAO;AAAA,MACL,MAAM;AAAA,MACN,OAAO,OAAO,YAAY,EAAE,CAAC,EAAE;AAAA,MAC/B,KAAK,OAAO,UAAU,EAAE,CAAC,EAAE;AAAA,MAC3B,aAAa;AAAA,IACd;AACD,WAAO,QAAQ,cAAc,aAAa,eAAe,GAAG,CAAC,CAAC,SAAS,SAAS,OAAO,GAAG,CAAC,SAAS,MAAM,OAAO,GAAG,CAAC,QAAQ,MAAM,OAAO,GAAG,CAAC,QAAQ,SAAS,OAAO,CAAC,CAAC;AAAA,EAC5K;AACE,SAAO;AACT;AAOA,SAAS,mBAAmB,SAAS,IAAI,KAAK;AAC5C,MAAI,OAAO;AACX,SAAO;AAYP,WAAS,MAAM,MAAM;AAEnB,YAAQ,MAAM,YAAY;AAC1B,WAAO,OAAO,IAAI;AAAA,EACtB;AAYE,WAAS,OAAO,MAAM;AACpB,YAAQ,MAAM,oBAAoB;AAClC,WAAO,aAAa,IAAI;AAAA,EAC5B;AAYE,WAAS,aAAa,MAAM;AAC1B,QAAI,SAAS,MAAM,SAAS,GAAG;AAC7B,cAAQ,QAAQ,IAAI;AACpB,aAAO;AAAA,IACb;AAGI,QAAI,SAAS,QAAQ,0BAA0B,IAAI,GAAG;AACpD,cAAQ,KAAK,oBAAoB;AACjC,aAAO,QAAQ,IAAI;AAAA,IACzB;AACI,WAAO,IAAI,IAAI;AAAA,EACnB;AAYE,WAAS,QAAQ,MAAM;AACrB,QAAI,SAAS,IAAI;AACf,cAAQ,MAAM,oBAAoB;AAClC,aAAO,gBAAgB,IAAI;AAAA,IACjC;AACI,QAAI,SAAS,QAAQ,mBAAmB,IAAI,GAAG;AAC7C,cAAQ,KAAK,YAAY;AAIzB,aAAO,GAAG,IAAI;AAAA,IACpB;AACI,QAAI,cAAc,IAAI,GAAG;AACvB,aAAO,aAAa,SAAS,SAAS,YAAY,EAAE,IAAI;AAAA,IAC9D;AAII,YAAQ,MAAM,gBAAgB;AAC9B,WAAO,KAAK,IAAI;AAAA,EACpB;AAcE,WAAS,gBAAgB,MAAM;AAC7B,QAAI,SAAS,IAAI;AACf,cAAQ,QAAQ,IAAI;AACpB,aAAO;AAAA,IACb;AACI,YAAQ,KAAK,oBAAoB;AACjC,WAAO,QAAQ,IAAI;AAAA,EACvB;AAYE,WAAS,KAAK,MAAM;AAClB,QAAI,SAAS,QAAQ,SAAS,MAAM,0BAA0B,IAAI,GAAG;AACnE,cAAQ,KAAK,gBAAgB;AAC7B,aAAO,QAAQ,IAAI;AAAA,IACzB;AACI,YAAQ,QAAQ,IAAI;AACpB,WAAO;AAAA,EACX;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/html-flow.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"html-flow.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/html-flow.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiAlphanumeric, asciiAlpha, markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { htmlBlockNames, htmlRawNames } from 'micromark-util-html-tag-name';\nimport { blankLine } from './blank-line.js';\n\n/** @type {Construct} */\nexport const htmlFlow = {\n  concrete: true,\n  name: 'htmlFlow',\n  resolveTo: resolveToHtmlFlow,\n  tokenize: tokenizeHtmlFlow\n};\n\n/** @type {Construct} */\nconst blankLineBefore = {\n  partial: true,\n  tokenize: tokenizeBlankLineBefore\n};\nconst nonLazyContinuationStart = {\n  partial: true,\n  tokenize: tokenizeNonLazyContinuationStart\n};\n\n/** @type {Resolver} */\nfunction resolveToHtmlFlow(events) {\n  let index = events.length;\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === \"htmlFlow\") {\n      break;\n    }\n  }\n  if (index > 1 && events[index - 2][1].type === \"linePrefix\") {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start;\n    // Add the prefix start to the HTML line token.\n    events[index + 1][1].start = events[index - 2][1].start;\n    // Remove the line prefix.\n    events.splice(index - 2, 2);\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  const self = this;\n  /** @type {number} */\n  let marker;\n  /** @type {boolean} */\n  let closingTag;\n  /** @type {string} */\n  let buffer;\n  /** @type {number} */\n  let index;\n  /** @type {Code} */\n  let markerB;\n  return start;\n\n  /**\n   * Start of HTML (flow).\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    return before(code);\n  }\n\n  /**\n   * At `<`, after optional whitespace.\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"htmlFlow\");\n    effects.enter(\"htmlFlowData\");\n    effects.consume(code);\n    return open;\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | <x />\n   *      ^\n   * > | <!doctype>\n   *      ^\n   * > | <!--xxx-->\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      closingTag = true;\n      return tagCloseStart;\n    }\n    if (code === 63) {\n      effects.consume(code);\n      marker = 3;\n      // To do:\n      // tokenizer.concrete = true\n      // To do: use `markdown-rs` style interrupt.\n      // While we’re in an instruction instead of a declaration, we’re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      // Always the case.\n      effects.consume(code);\n      buffer = String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *       ^\n   * > | <!--xxx-->\n   *       ^\n   * > | <![CDATA[>&<]]>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      marker = 2;\n      return commentOpenInside;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      marker = 5;\n      index = 0;\n      return cdataOpenInside;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      marker = 4;\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!-`, inside a comment, at another `-`.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<![`, inside CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *        ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = \"CDATA[\";\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code);\n      if (index === value.length) {\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok : continuation;\n      }\n      return cdataOpenInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | </x>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      // Always the case.\n      effects.consume(code);\n      buffer = String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In tag name.\n   *\n   * ```markdown\n   * > | <ab>\n   *      ^^\n   * > | </ab>\n   *       ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagName(code) {\n    if (code === null || code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      const slash = code === 47;\n      const name = buffer.toLowerCase();\n      if (!slash && !closingTag && htmlRawNames.includes(name)) {\n        marker = 1;\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n      if (htmlBlockNames.includes(buffer.toLowerCase())) {\n        marker = 6;\n        if (slash) {\n          effects.consume(code);\n          return basicSelfClosing;\n        }\n\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n      marker = 7;\n      // Do not support complete HTML when interrupting.\n      return self.interrupt && !self.parser.lazy[self.now().line] ? nok(code) : closingTag ? completeClosingTagAfter(code) : completeAttributeNameBefore(code);\n    }\n\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      buffer += String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After closing slash of a basic tag name.\n   *\n   * ```markdown\n   * > | <div/>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code);\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuation;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After closing slash of a complete tag name.\n   *\n   * ```markdown\n   * > | <x/>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeClosingTagAfter;\n    }\n    return completeEnd(code);\n  }\n\n  /**\n   * At an attribute name.\n   *\n   * At first, this state is used after a complete tag name, after whitespace,\n   * where it expects optional attributes or the end of the tag.\n   * It is also reused after attributes, when expecting more optional\n   * attributes.\n   *\n   * ```markdown\n   * > | <a />\n   *        ^\n   * > | <a :b>\n   *        ^\n   * > | <a _b>\n   *        ^\n   * > | <a b>\n   *        ^\n   * > | <a >\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return completeEnd;\n    }\n\n    // ASCII alphanumerical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameBefore;\n    }\n    return completeEnd(code);\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | <a :b>\n   *         ^\n   * > | <a _b>\n   *         ^\n   * > | <a b>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeName(code) {\n    // ASCII alphanumerical and `-`, `.`, `:`, and `_`.\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n    return completeAttributeNameAfter(code);\n  }\n\n  /**\n   * After attribute name, at an optional initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b>\n   *         ^\n   * > | <a b=c>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameAfter;\n    }\n    return completeAttributeNameBefore(code);\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * > | <a b=\"c\">\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      markerB = code;\n      return completeAttributeValueQuoted;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    return completeAttributeValueUnquoted(code);\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *           ^\n   * > | <a b='c'>\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuoted(code) {\n    if (code === markerB) {\n      effects.consume(code);\n      markerB = null;\n      return completeAttributeValueQuotedAfter;\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return completeAttributeValueQuoted;\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 47 || code === 60 || code === 61 || code === 62 || code === 96 || markdownLineEndingOrSpace(code)) {\n      return completeAttributeNameAfter(code);\n    }\n    effects.consume(code);\n    return completeAttributeValueUnquoted;\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the\n   * end of the tag.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In certain circumstances of a complete tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `>` in a complete tag.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return continuation(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In continuation of any HTML kind.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuation(code) {\n    if (code === 45 && marker === 2) {\n      effects.consume(code);\n      return continuationCommentInside;\n    }\n    if (code === 60 && marker === 1) {\n      effects.consume(code);\n      return continuationRawTagOpen;\n    }\n    if (code === 62 && marker === 4) {\n      effects.consume(code);\n      return continuationClose;\n    }\n    if (code === 63 && marker === 3) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    if (code === 93 && marker === 5) {\n      effects.consume(code);\n      return continuationCdataInside;\n    }\n    if (markdownLineEnding(code) && (marker === 6 || marker === 7)) {\n      effects.exit(\"htmlFlowData\");\n      return effects.check(blankLineBefore, continuationAfter, continuationStart)(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"htmlFlowData\");\n      return continuationStart(code);\n    }\n    effects.consume(code);\n    return continuation;\n  }\n\n  /**\n   * In continuation, at eol.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStart(code) {\n    return effects.check(nonLazyContinuationStart, continuationStartNonLazy, continuationAfter)(code);\n  }\n\n  /**\n   * In continuation, at eol, before non-lazy content.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStartNonLazy(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return continuationBefore;\n  }\n\n  /**\n   * In continuation, before non-lazy content.\n   *\n   * ```markdown\n   *   | <x>\n   * > | asd\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return continuationStart(code);\n    }\n    effects.enter(\"htmlFlowData\");\n    return continuation(code);\n  }\n\n  /**\n   * In comment continuation, after one `-`, expecting another.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In raw continuation, after `<`, at `/`.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code);\n      buffer = '';\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In raw continuation, after `</`, in a raw tag name.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                             ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawEndTag(code) {\n    if (code === 62) {\n      const name = buffer.toLowerCase();\n      if (htmlRawNames.includes(name)) {\n        effects.consume(code);\n        return continuationClose;\n      }\n      return continuation(code);\n    }\n    if (asciiAlpha(code) && buffer.length < 8) {\n      // Always the case.\n      effects.consume(code);\n      buffer += String.fromCharCode(code);\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In cdata continuation, after `]`, expecting `]>`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *                  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCdataInside(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In declaration or instruction continuation, at `>`.\n   *\n   * ```markdown\n   * > | <!-->\n   *         ^\n   * > | <?>\n   *       ^\n   * > | <!q>\n   *        ^\n   * > | <!--ab-->\n   *             ^\n   * > | <![CDATA[>&<]]>\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    // More dashes.\n    if (code === 45 && marker === 2) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In closed continuation: everything we get until the eol/eof is part of it.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"htmlFlowData\");\n      return continuationAfter(code);\n    }\n    effects.consume(code);\n    return continuationClose;\n  }\n\n  /**\n   * Done.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationAfter(code) {\n    effects.exit(\"htmlFlow\");\n    // // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    // // No longer concrete.\n    // tokenizer.concrete = false\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuationStart(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * At eol, before continuation.\n   *\n   * ```markdown\n   * > | * ```js\n   *            ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * A continuation.\n   *\n   * ```markdown\n   *   | * ```js\n   * > | b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLineBefore(effects, ok, nok) {\n  return start;\n\n  /**\n   * Before eol, expecting blank line.\n   *\n   * ```markdown\n   * > | <div>\n   *          ^\n   *   |\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return effects.attempt(blankLine, ok, nok);\n  }\n}"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/html-text.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"html-text.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/html-text.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { asciiAlphanumeric, asciiAlpha, markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlText(effects, ok, nok) {\n  const self = this;\n  /** @type {NonNullable<Code> | undefined} */\n  let marker;\n  /** @type {number} */\n  let index;\n  /** @type {State} */\n  let returnState;\n  return start;\n\n  /**\n   * Start of HTML (text).\n   *\n   * ```markdown\n   * > | a <b> c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"htmlText\");\n    effects.enter(\"htmlTextData\");\n    effects.consume(code);\n    return open;\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | a <b> c\n   *        ^\n   * > | a <!doctype> c\n   *        ^\n   * > | a <!--b--> c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instruction;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | a <!doctype> c\n   *         ^\n   * > | a <!--b--> c\n   *         ^\n   * > | a <![CDATA[>&<]]> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentOpenInside;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      index = 0;\n      return cdataOpenInside;\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return declaration;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In a comment, after `<!-`, at another `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentEnd;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In comment.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function comment(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 45) {\n      effects.consume(code);\n      return commentClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = comment;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return comment;\n  }\n\n  /**\n   * In comment, after `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentEnd;\n    }\n    return comment(code);\n  }\n\n  /**\n   * In comment, after `--`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentEnd(code) {\n    return code === 62 ? end(code) : code === 45 ? commentClose(code) : comment(code);\n  }\n\n  /**\n   * After `<![`, in CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *          ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = \"CDATA[\";\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === value.length ? cdata : cdataOpenInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In CDATA.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdata(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = cdata;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return cdata;\n  }\n\n  /**\n   * In CDATA, after `]`, at another `]`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n\n  /**\n   * In CDATA, after `]]`, at `>`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n\n  /**\n   * In declaration.\n   *\n   * ```markdown\n   * > | a <!b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = declaration;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return declaration;\n  }\n\n  /**\n   * In instruction.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instruction(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instructionClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = instruction;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return instruction;\n  }\n\n  /**\n   * In instruction, after `?`, at `>`.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code);\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `</x`, in a tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagClose(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return tagCloseBetween(code);\n  }\n\n  /**\n   * In closing tag, after tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagCloseBetween;\n    }\n    return end(code);\n  }\n\n  /**\n   * After `<x`, in opening tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpen(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In opening tag, after tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return end;\n    }\n\n    // ASCII alphabetical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenBetween;\n    }\n    return end(code);\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeName(code) {\n    // ASCII alphabetical and `-`, `.`, `:`, and `_`.\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n    return tagOpenAttributeNameAfter(code);\n  }\n\n  /**\n   * After attribute name, before initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeNameAfter;\n    }\n    return tagOpenBetween(code);\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return tagOpenAttributeValueQuoted;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      marker = undefined;\n      return tagOpenAttributeValueQuotedAfter;\n    }\n    if (code === null) {\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueQuoted;\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 96) {\n      return nok(code);\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the end\n   * of the tag.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In certain circumstances of a tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function end(code) {\n    if (code === 62) {\n      effects.consume(code);\n      effects.exit(\"htmlTextData\");\n      effects.exit(\"htmlText\");\n      return ok;\n    }\n    return nok(code);\n  }\n\n  /**\n   * At eol.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   * > | a <!--a\n   *            ^\n   *   | b-->\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingBefore(code) {\n    effects.exit(\"htmlTextData\");\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return lineEndingAfter;\n  }\n\n  /**\n   * After eol, at optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfter(code) {\n    // Always populated by defaults.\n\n    return markdownSpace(code) ? factorySpace(effects, lineEndingAfterPrefix, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : lineEndingAfterPrefix(code);\n  }\n\n  /**\n   * After eol, after optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfterPrefix(code) {\n    effects.enter(\"htmlTextData\");\n    return returnState(code);\n  }\n}"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/label-end.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"label-end.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/label-end.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   Event,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factoryDestination } from 'micromark-factory-destination';\nimport { factoryLabel } from 'micromark-factory-label';\nimport { factoryTitle } from 'micromark-factory-title';\nimport { factoryWhitespace } from 'micromark-factory-whitespace';\nimport { markdownLineEndingOrSpace } from 'micromark-util-character';\nimport { push, splice } from 'micromark-util-chunked';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/** @type {Construct} */\nexport const labelEnd = {\n  name: 'labelEnd',\n  resolveAll: resolveAllLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  tokenize: tokenizeLabelEnd\n};\n\n/** @type {Construct} */\nconst resourceConstruct = {\n  tokenize: tokenizeResource\n};\n/** @type {Construct} */\nconst referenceFullConstruct = {\n  tokenize: tokenizeReferenceFull\n};\n/** @type {Construct} */\nconst referenceCollapsedConstruct = {\n  tokenize: tokenizeReferenceCollapsed\n};\n\n/** @type {Resolver} */\nfunction resolveAllLabelEnd(events) {\n  let index = -1;\n  /** @type {Array<Event>} */\n  const newEvents = [];\n  while (++index < events.length) {\n    const token = events[index][1];\n    newEvents.push(events[index]);\n    if (token.type === \"labelImage\" || token.type === \"labelLink\" || token.type === \"labelEnd\") {\n      // Remove the marker.\n      const offset = token.type === \"labelImage\" ? 4 : 2;\n      token.type = \"data\";\n      index += offset;\n    }\n  }\n\n  // If the events are equal, we don't have to copy newEvents to events\n  if (events.length !== newEvents.length) {\n    splice(events, 0, events.length, newEvents);\n  }\n  return events;\n}\n\n/** @type {Resolver} */\nfunction resolveToLabelEnd(events, context) {\n  let index = events.length;\n  let offset = 0;\n  /** @type {Token} */\n  let token;\n  /** @type {number | undefined} */\n  let open;\n  /** @type {number | undefined} */\n  let close;\n  /** @type {Array<Event>} */\n  let media;\n\n  // Find an opening.\n  while (index--) {\n    token = events[index][1];\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (token.type === \"link\" || token.type === \"labelLink\" && token._inactive) {\n        break;\n      }\n\n      // Mark other link openings as inactive, as we can’t have links in\n      // links.\n      if (events[index][0] === 'enter' && token.type === \"labelLink\") {\n        token._inactive = true;\n      }\n    } else if (close) {\n      if (events[index][0] === 'enter' && (token.type === \"labelImage\" || token.type === \"labelLink\") && !token._balanced) {\n        open = index;\n        if (token.type !== \"labelLink\") {\n          offset = 2;\n          break;\n        }\n      }\n    } else if (token.type === \"labelEnd\") {\n      close = index;\n    }\n  }\n  const group = {\n    type: events[open][1].type === \"labelLink\" ? \"link\" : \"image\",\n    start: {\n      ...events[open][1].start\n    },\n    end: {\n      ...events[events.length - 1][1].end\n    }\n  };\n  const label = {\n    type: \"label\",\n    start: {\n      ...events[open][1].start\n    },\n    end: {\n      ...events[close][1].end\n    }\n  };\n  const text = {\n    type: \"labelText\",\n    start: {\n      ...events[open + offset + 2][1].end\n    },\n    end: {\n      ...events[close - 2][1].start\n    }\n  };\n  media = [['enter', group, context], ['enter', label, context]];\n\n  // Opening marker.\n  media = push(media, events.slice(open + 1, open + offset + 3));\n\n  // Text open.\n  media = push(media, [['enter', text, context]]);\n\n  // Always populated by defaults.\n\n  // Between.\n  media = push(media, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + offset + 4, close - 3), context));\n\n  // Text close, marker close, label close.\n  media = push(media, [['exit', text, context], events[close - 2], events[close - 1], ['exit', label, context]]);\n\n  // Reference, resource, or so.\n  media = push(media, events.slice(close + 1));\n\n  // Media close.\n  media = push(media, [['exit', group, context]]);\n  splice(events, open, events.length, media);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  const self = this;\n  let index = self.events.length;\n  /** @type {Token} */\n  let labelStart;\n  /** @type {boolean} */\n  let defined;\n\n  // Find an opening.\n  while (index--) {\n    if ((self.events[index][1].type === \"labelImage\" || self.events[index][1].type === \"labelLink\") && !self.events[index][1]._balanced) {\n      labelStart = self.events[index][1];\n      break;\n    }\n  }\n  return start;\n\n  /**\n   * Start of label end.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // If there is not an okay opening.\n    if (!labelStart) {\n      return nok(code);\n    }\n\n    // If the corresponding label (link) start is marked as inactive,\n    // it means we’d be wrapping a link, like this:\n    //\n    // ```markdown\n    // > | a [b [c](d) e](f) g.\n    //                  ^\n    // ```\n    //\n    // We can’t have that, so it’s just balanced brackets.\n    if (labelStart._inactive) {\n      return labelEndNok(code);\n    }\n    defined = self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize({\n      start: labelStart.end,\n      end: self.now()\n    })));\n    effects.enter(\"labelEnd\");\n    effects.enter(\"labelMarker\");\n    effects.consume(code);\n    effects.exit(\"labelMarker\");\n    effects.exit(\"labelEnd\");\n    return after;\n  }\n\n  /**\n   * After `]`.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // Note: `markdown-rs` also parses GFM footnotes here, which for us is in\n    // an extension.\n\n    // Resource (`[asd](fgh)`)?\n    if (code === 40) {\n      return effects.attempt(resourceConstruct, labelEndOk, defined ? labelEndOk : labelEndNok)(code);\n    }\n\n    // Full (`[asd][fgh]`) or collapsed (`[asd][]`) reference?\n    if (code === 91) {\n      return effects.attempt(referenceFullConstruct, labelEndOk, defined ? referenceNotFull : labelEndNok)(code);\n    }\n\n    // Shortcut (`[asd]`) reference?\n    return defined ? labelEndOk(code) : labelEndNok(code);\n  }\n\n  /**\n   * After `]`, at `[`, but not at a full reference.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] b\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceNotFull(code) {\n    return effects.attempt(referenceCollapsedConstruct, labelEndOk, labelEndNok)(code);\n  }\n\n  /**\n   * Done, we found something.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *           ^\n   * > | [a][b] c\n   *           ^\n   * > | [a][] b\n   *          ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndOk(code) {\n    // Note: `markdown-rs` does a bunch of stuff here.\n    return ok(code);\n  }\n\n  /**\n   * Done, it’s nothing.\n   *\n   * There was an okay opening, but we didn’t match anything.\n   *\n   * ```markdown\n   * > | [a](b c\n   *        ^\n   * > | [a][b c\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndNok(code) {\n    labelStart._balanced = true;\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeResource(effects, ok, nok) {\n  return resourceStart;\n\n  /**\n   * At a resource.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceStart(code) {\n    effects.enter(\"resource\");\n    effects.enter(\"resourceMarker\");\n    effects.consume(code);\n    effects.exit(\"resourceMarker\");\n    return resourceBefore;\n  }\n\n  /**\n   * In resource, after `(`, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBefore(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceOpen)(code) : resourceOpen(code);\n  }\n\n  /**\n   * In resource, after optional whitespace, at `)` or a destination.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceOpen(code) {\n    if (code === 41) {\n      return resourceEnd(code);\n    }\n    return factoryDestination(effects, resourceDestinationAfter, resourceDestinationMissing, \"resourceDestination\", \"resourceDestinationLiteral\", \"resourceDestinationLiteralMarker\", \"resourceDestinationRaw\", \"resourceDestinationString\", 32)(code);\n  }\n\n  /**\n   * In resource, after destination, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceBetween)(code) : resourceEnd(code);\n  }\n\n  /**\n   * At invalid destination.\n   *\n   * ```markdown\n   * > | [a](<<) b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationMissing(code) {\n    return nok(code);\n  }\n\n  /**\n   * In resource, after destination and whitespace, at `(` or title.\n   *\n   * ```markdown\n   * > | [a](b ) c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBetween(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(effects, resourceTitleAfter, nok, \"resourceTitle\", \"resourceTitleMarker\", \"resourceTitleString\")(code);\n    }\n    return resourceEnd(code);\n  }\n\n  /**\n   * In resource, after title, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b \"c\") d\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceTitleAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceEnd)(code) : resourceEnd(code);\n  }\n\n  /**\n   * In resource, at `)`.\n   *\n   * ```markdown\n   * > | [a](b) d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceEnd(code) {\n    if (code === 41) {\n      effects.enter(\"resourceMarker\");\n      effects.consume(code);\n      effects.exit(\"resourceMarker\");\n      effects.exit(\"resource\");\n      return ok;\n    }\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceFull(effects, ok, nok) {\n  const self = this;\n  return referenceFull;\n\n  /**\n   * In a reference (full), at the `[`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFull(code) {\n    return factoryLabel.call(self, effects, referenceFullAfter, referenceFullMissing, \"reference\", \"referenceMarker\", \"referenceString\")(code);\n  }\n\n  /**\n   * In a reference (full), after `]`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullAfter(code) {\n    return self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1))) ? ok(code) : nok(code);\n  }\n\n  /**\n   * In reference (full) that was missing.\n   *\n   * ```markdown\n   * > | [a][b d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullMissing(code) {\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceCollapsed(effects, ok, nok) {\n  return referenceCollapsedStart;\n\n  /**\n   * In reference (collapsed), at `[`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceCollapsedStart(code) {\n    // We only attempt a collapsed label if there’s a `[`.\n\n    effects.enter(\"reference\");\n    effects.enter(\"referenceMarker\");\n    effects.consume(code);\n    effects.exit(\"referenceMarker\");\n    return referenceCollapsedOpen;\n  }\n\n  /**\n   * In reference (collapsed), at `]`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *         ^\n   * ```\n   *\n   *  @type {State}\n   */\n  function referenceCollapsedOpen(code) {\n    if (code === 93) {\n      effects.enter(\"referenceMarker\");\n      effects.consume(code);\n      effects.exit(\"referenceMarker\");\n      effects.exit(\"reference\");\n      return ok;\n    }\n    return nok(code);\n  }\n}"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/label-start-image.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"label-start-image.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/label-start-image.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { labelEnd } from './label-end.js';\n\n/** @type {Construct} */\nexport const labelStartImage = {\n  name: 'labelStartImage',\n  resolveAll: labelEnd.resolveAll,\n  tokenize: tokenizeLabelStartImage\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of label (image) start.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"labelImage\");\n    effects.enter(\"labelImageMarker\");\n    effects.consume(code);\n    effects.exit(\"labelImageMarker\");\n    return open;\n  }\n\n  /**\n   * After `!`, at `[`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 91) {\n      effects.enter(\"labelMarker\");\n      effects.consume(code);\n      effects.exit(\"labelMarker\");\n      effects.exit(\"labelImage\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `![`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *         ^\n   * ```\n   *\n   * This is needed in because, when GFM footnotes are enabled, images never\n   * form when started with a `^`.\n   * Instead, links form:\n   *\n   * ```markdown\n   * ![^a](b)\n   *\n   * ![^a][b]\n   *\n   * [b]: c\n   * ```\n   *\n   * ```html\n   * <p>!<a href=\\\"b\\\">^a</a></p>\n   * <p>!<a href=\\\"c\\\">^a</a></p>\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // To do: use a new field to do this, this is still needed for\n    // `micromark-extension-gfm-footnote`, but the `label-start-link`\n    // behavior isn’t.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);\n  }\n}"],"names":[],"mappings":";AAYY,MAAC,kBAAkB;AAAA,EAC7B,MAAM;AAAA,EACN,YAAY,SAAS;AAAA,EACrB,UAAU;AACZ;AAOA,SAAS,wBAAwB,SAAS,IAAI,KAAK;AACjD,QAAM,OAAO;AACb,SAAO;AAYP,WAAS,MAAM,MAAM;AACnB,YAAQ,MAAM,YAAY;AAC1B,YAAQ,MAAM,kBAAkB;AAChC,YAAQ,QAAQ,IAAI;AACpB,YAAQ,KAAK,kBAAkB;AAC/B,WAAO;AAAA,EACX;AAYE,WAAS,KAAK,MAAM;AAClB,QAAI,SAAS,IAAI;AACf,cAAQ,MAAM,aAAa;AAC3B,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,aAAa;AAC1B,cAAQ,KAAK,YAAY;AACzB,aAAO;AAAA,IACb;AACI,WAAO,IAAI,IAAI;AAAA,EACnB;AA6BE,WAAS,MAAM,MAAM;AAMnB,WAAO,SAAS,MAAM,4BAA4B,KAAK,OAAO,aAAa,IAAI,IAAI,IAAI,GAAG,IAAI;AAAA,EAClG;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/label-start-link.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"label-start-link.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/label-start-link.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { labelEnd } from './label-end.js';\n\n/** @type {Construct} */\nexport const labelStartLink = {\n  name: 'labelStartLink',\n  resolveAll: labelEnd.resolveAll,\n  tokenize: tokenizeLabelStartLink\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of label (link) start.\n   *\n   * ```markdown\n   * > | a [b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"labelLink\");\n    effects.enter(\"labelMarker\");\n    effects.consume(code);\n    effects.exit(\"labelMarker\");\n    effects.exit(\"labelLink\");\n    return after;\n  }\n\n  /** @type {State} */\n  function after(code) {\n    // To do: this isn’t needed in `micromark-extension-gfm-footnote`,\n    // remove.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);\n  }\n}"],"names":[],"mappings":";AAYY,MAAC,iBAAiB;AAAA,EAC5B,MAAM;AAAA,EACN,YAAY,SAAS;AAAA,EACrB,UAAU;AACZ;AAOA,SAAS,uBAAuB,SAAS,IAAI,KAAK;AAChD,QAAM,OAAO;AACb,SAAO;AAYP,WAAS,MAAM,MAAM;AACnB,YAAQ,MAAM,WAAW;AACzB,YAAQ,MAAM,aAAa;AAC3B,YAAQ,QAAQ,IAAI;AACpB,YAAQ,KAAK,aAAa;AAC1B,YAAQ,KAAK,WAAW;AACxB,WAAO;AAAA,EACX;AAGE,WAAS,MAAM,MAAM;AAKnB,WAAO,SAAS,MAAM,4BAA4B,KAAK,OAAO,aAAa,IAAI,IAAI,IAAI,GAAG,IAAI;AAAA,EAClG;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/line-ending.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"line-ending.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/line-ending.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLineEnding(effects, ok) {\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, ok, \"linePrefix\");\n  }\n}"],"names":[],"mappings":";AAYY,MAAC,aAAa;AAAA,EACxB,MAAM;AAAA,EACN,UAAU;AACZ;AAOA,SAAS,mBAAmB,SAAS,IAAI;AACvC,SAAO;AAGP,WAAS,MAAM,MAAM;AACnB,YAAQ,MAAM,YAAY;AAC1B,YAAQ,QAAQ,IAAI;AACpB,YAAQ,KAAK,YAAY;AACzB,WAAO,aAAa,SAAS,IAAI,YAAY;AAAA,EACjD;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/list.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"list.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/list.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   Construct,\n *   Exiter,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { asciiDigit, markdownSpace } from 'micromark-util-character';\nimport { blankLine } from './blank-line.js';\nimport { thematicBreak } from './thematic-break.js';\n\n/** @type {Construct} */\nexport const list = {\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd,\n  name: 'list',\n  tokenize: tokenizeListStart\n};\n\n/** @type {Construct} */\nconst listItemPrefixWhitespaceConstruct = {\n  partial: true,\n  tokenize: tokenizeListItemPrefixWhitespace\n};\n\n/** @type {Construct} */\nconst indentConstruct = {\n  partial: true,\n  tokenize: tokenizeIndent\n};\n\n// To do: `markdown-rs` parses list items on their own and later stitches them\n// together.\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeListStart(effects, ok, nok) {\n  const self = this;\n  const tail = self.events[self.events.length - 1];\n  let initialSize = tail && tail[1].type === \"linePrefix\" ? tail[2].sliceSerialize(tail[1], true).length : 0;\n  let size = 0;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    const kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? \"listUnordered\" : \"listOrdered\");\n    if (kind === \"listUnordered\" ? !self.containerState.marker || code === self.containerState.marker : asciiDigit(code)) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind;\n        effects.enter(kind, {\n          _container: true\n        });\n      }\n      if (kind === \"listUnordered\") {\n        effects.enter(\"listItemPrefix\");\n        return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code);\n      }\n      if (!self.interrupt || code === 49) {\n        effects.enter(\"listItemPrefix\");\n        effects.enter(\"listItemValue\");\n        return inside(code);\n      }\n    }\n    return nok(code);\n  }\n\n  /** @type {State} */\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code);\n      return inside;\n    }\n    if ((!self.interrupt || size < 2) && (self.containerState.marker ? code === self.containerState.marker : code === 41 || code === 46)) {\n      effects.exit(\"listItemValue\");\n      return atMarker(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * @type {State}\n   **/\n  function atMarker(code) {\n    effects.enter(\"listItemMarker\");\n    effects.consume(code);\n    effects.exit(\"listItemMarker\");\n    self.containerState.marker = self.containerState.marker || code;\n    return effects.check(blankLine,\n    // Can’t be empty when interrupting.\n    self.interrupt ? nok : onBlank, effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix));\n  }\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true;\n    initialSize++;\n    return endOfPrefix(code);\n  }\n\n  /** @type {State} */\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter(\"listItemPrefixWhitespace\");\n      effects.consume(code);\n      effects.exit(\"listItemPrefixWhitespace\");\n      return endOfPrefix;\n    }\n    return nok(code);\n  }\n\n  /** @type {State} */\n  function endOfPrefix(code) {\n    self.containerState.size = initialSize + self.sliceSerialize(effects.exit(\"listItemPrefix\"), true).length;\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeListContinuation(effects, ok, nok) {\n  const self = this;\n  self.containerState._closeFlow = undefined;\n  return effects.check(blankLine, onBlank, notBlank);\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.furtherBlankLines = self.containerState.furtherBlankLines || self.containerState.initialBlankLine;\n\n    // We have a blank line.\n    // Still, try to consume at most the items size.\n    return factorySpace(effects, ok, \"listItemIndent\", self.containerState.size + 1)(code);\n  }\n\n  /** @type {State} */\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = undefined;\n      self.containerState.initialBlankLine = undefined;\n      return notInCurrentItem(code);\n    }\n    self.containerState.furtherBlankLines = undefined;\n    self.containerState.initialBlankLine = undefined;\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code);\n  }\n\n  /** @type {State} */\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true;\n    // As we’re closing flow, we’re no longer interrupting.\n    self.interrupt = undefined;\n    // Always populated by defaults.\n\n    return factorySpace(effects, effects.attempt(list, ok, nok), \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this;\n  return factorySpace(effects, afterPrefix, \"listItemIndent\", self.containerState.size + 1);\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"listItemIndent\" && tail[2].sliceSerialize(tail[1], true).length === self.containerState.size ? ok(code) : nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Exiter}\n */\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type);\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  const self = this;\n\n  // Always populated by defaults.\n\n  return factorySpace(effects, afterPrefix, \"listItemPrefixWhitespace\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4 + 1);\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return !markdownSpace(code) && tail && tail[1].type === \"listItemPrefixWhitespace\" ? ok(code) : nok(code);\n  }\n}"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/setext-underline.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"setext-underline.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/setext-underline.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const setextUnderline = {\n  name: 'setextUnderline',\n  resolveTo: resolveToSetextUnderline,\n  tokenize: tokenizeSetextUnderline\n};\n\n/** @type {Resolver} */\nfunction resolveToSetextUnderline(events, context) {\n  // To do: resolve like `markdown-rs`.\n  let index = events.length;\n  /** @type {number | undefined} */\n  let content;\n  /** @type {number | undefined} */\n  let text;\n  /** @type {number | undefined} */\n  let definition;\n\n  // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === \"content\") {\n        content = index;\n        break;\n      }\n      if (events[index][1].type === \"paragraph\") {\n        text = index;\n      }\n    }\n    // Exit\n    else {\n      if (events[index][1].type === \"content\") {\n        // Remove the content end (if needed we’ll add it later)\n        events.splice(index, 1);\n      }\n      if (!definition && events[index][1].type === \"definition\") {\n        definition = index;\n      }\n    }\n  }\n  const heading = {\n    type: \"setextHeading\",\n    start: {\n      ...events[content][1].start\n    },\n    end: {\n      ...events[events.length - 1][1].end\n    }\n  };\n\n  // Change the paragraph to setext heading text.\n  events[text][1].type = \"setextHeadingText\";\n\n  // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context]);\n    events.splice(definition + 1, 0, ['exit', events[content][1], context]);\n    events[content][1].end = {\n      ...events[definition][1].end\n    };\n  } else {\n    events[content][1] = heading;\n  }\n\n  // Add the heading exit at the end.\n  events.push(['exit', heading, context]);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  const self = this;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * At start of heading (setext) underline.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    let index = self.events.length;\n    /** @type {boolean | undefined} */\n    let paragraph;\n    // Find an opening.\n    while (index--) {\n      // Skip enter/exit of line ending, line prefix, and content.\n      // We can now either have a definition or a paragraph.\n      if (self.events[index][1].type !== \"lineEnding\" && self.events[index][1].type !== \"linePrefix\" && self.events[index][1].type !== \"content\") {\n        paragraph = self.events[index][1].type === \"paragraph\";\n        break;\n      }\n    }\n\n    // To do: handle lazy/pierce like `markdown-rs`.\n    // To do: parse indent like `markdown-rs`.\n    if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {\n      effects.enter(\"setextHeadingLine\");\n      marker = code;\n      return before(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * After optional whitespace, at `-` or `=`.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"setextHeadingLineSequence\");\n    return inside(code);\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return inside;\n    }\n    effects.exit(\"setextHeadingLineSequence\");\n    return markdownSpace(code) ? factorySpace(effects, after, \"lineSuffix\")(code) : after(code);\n  }\n\n  /**\n   * After sequence, after optional whitespace.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"setextHeadingLine\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n}"],"names":[],"mappings":";;AAcY,MAAC,kBAAkB;AAAA,EAC7B,MAAM;AAAA,EACN,WAAW;AAAA,EACX,UAAU;AACZ;AAGA,SAAS,yBAAyB,QAAQ,SAAS;AAEjD,MAAI,QAAQ,OAAO;AAEnB,MAAI;AAEJ,MAAI;AAEJ,MAAI;AAIJ,SAAO,SAAS;AACd,QAAI,OAAO,KAAK,EAAE,CAAC,MAAM,SAAS;AAChC,UAAI,OAAO,KAAK,EAAE,CAAC,EAAE,SAAS,WAAW;AACvC,kBAAU;AACV;AAAA,MACR;AACM,UAAI,OAAO,KAAK,EAAE,CAAC,EAAE,SAAS,aAAa;AACzC,eAAO;AAAA,MACf;AAAA,IACA,OAES;AACH,UAAI,OAAO,KAAK,EAAE,CAAC,EAAE,SAAS,WAAW;AAEvC,eAAO,OAAO,OAAO,CAAC;AAAA,MAC9B;AACM,UAAI,CAAC,cAAc,OAAO,KAAK,EAAE,CAAC,EAAE,SAAS,cAAc;AACzD,qBAAa;AAAA,MACrB;AAAA,IACA;AAAA,EACA;AACE,QAAM,UAAU;AAAA,IACd,MAAM;AAAA,IACN,OAAO;AAAA,MACL,GAAG,OAAO,OAAO,EAAE,CAAC,EAAE;AAAA,IACvB;AAAA,IACD,KAAK;AAAA,MACH,GAAG,OAAO,OAAO,SAAS,CAAC,EAAE,CAAC,EAAE;AAAA,IACtC;AAAA,EACG;AAGD,SAAO,IAAI,EAAE,CAAC,EAAE,OAAO;AAIvB,MAAI,YAAY;AACd,WAAO,OAAO,MAAM,GAAG,CAAC,SAAS,SAAS,OAAO,CAAC;AAClD,WAAO,OAAO,aAAa,GAAG,GAAG,CAAC,QAAQ,OAAO,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC;AACtE,WAAO,OAAO,EAAE,CAAC,EAAE,MAAM;AAAA,MACvB,GAAG,OAAO,UAAU,EAAE,CAAC,EAAE;AAAA,IAC1B;AAAA,EACL,OAAS;AACL,WAAO,OAAO,EAAE,CAAC,IAAI;AAAA,EACzB;AAGE,SAAO,KAAK,CAAC,QAAQ,SAAS,OAAO,CAAC;AACtC,SAAO;AACT;AAOA,SAAS,wBAAwB,SAAS,IAAI,KAAK;AACjD,QAAM,OAAO;AAEb,MAAI;AACJ,SAAO;AAaP,WAAS,MAAM,MAAM;AACnB,QAAI,QAAQ,KAAK,OAAO;AAExB,QAAI;AAEJ,WAAO,SAAS;AAGd,UAAI,KAAK,OAAO,KAAK,EAAE,CAAC,EAAE,SAAS,gBAAgB,KAAK,OAAO,KAAK,EAAE,CAAC,EAAE,SAAS,gBAAgB,KAAK,OAAO,KAAK,EAAE,CAAC,EAAE,SAAS,WAAW;AAC1I,oBAAY,KAAK,OAAO,KAAK,EAAE,CAAC,EAAE,SAAS;AAC3C;AAAA,MACR;AAAA,IACA;AAII,QAAI,CAAC,KAAK,OAAO,KAAK,KAAK,MAAM,IAAI,MAAM,KAAK,aAAa,YAAY;AACvE,cAAQ,MAAM,mBAAmB;AACjC,eAAS;AACT,aAAO,OAAO,IAAI;AAAA,IACxB;AACI,WAAO,IAAI,IAAI;AAAA,EACnB;AAaE,WAAS,OAAO,MAAM;AACpB,YAAQ,MAAM,2BAA2B;AACzC,WAAO,OAAO,IAAI;AAAA,EACtB;AAaE,WAAS,OAAO,MAAM;AACpB,QAAI,SAAS,QAAQ;AACnB,cAAQ,QAAQ,IAAI;AACpB,aAAO;AAAA,IACb;AACI,YAAQ,KAAK,2BAA2B;AACxC,WAAO,cAAc,IAAI,IAAI,aAAa,SAAS,OAAO,YAAY,EAAE,IAAI,IAAI,MAAM,IAAI;AAAA,EAC9F;AAaE,WAAS,MAAM,MAAM;AACnB,QAAI,SAAS,QAAQ,mBAAmB,IAAI,GAAG;AAC7C,cAAQ,KAAK,mBAAmB;AAChC,aAAO,GAAG,IAAI;AAAA,IACpB;AACI,WAAO,IAAI,IAAI;AAAA,EACnB;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/thematic-break.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"thematic-break.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/thematic-break.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  let size = 0;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of thematic break.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"thematicBreak\");\n    // To do: parse indent like `markdown-rs`.\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at marker.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    marker = code;\n    return atBreak(code);\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter(\"thematicBreakSequence\");\n      return sequence(code);\n    }\n    if (size >= 3 && (code === null || markdownLineEnding(code))) {\n      effects.exit(\"thematicBreak\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      size++;\n      return sequence;\n    }\n    effects.exit(\"thematicBreakSequence\");\n    return markdownSpace(code) ? factorySpace(effects, atBreak, \"whitespace\")(code) : atBreak(code);\n  }\n}"],"names":[],"mappings":";;AAaY,MAAC,gBAAgB;AAAA,EAC3B,MAAM;AAAA,EACN,UAAU;AACZ;AAOA,SAAS,sBAAsB,SAAS,IAAI,KAAK;AAC/C,MAAI,OAAO;AAEX,MAAI;AACJ,SAAO;AAYP,WAAS,MAAM,MAAM;AACnB,YAAQ,MAAM,eAAe;AAE7B,WAAO,OAAO,IAAI;AAAA,EACtB;AAYE,WAAS,OAAO,MAAM;AACpB,aAAS;AACT,WAAO,QAAQ,IAAI;AAAA,EACvB;AAYE,WAAS,QAAQ,MAAM;AACrB,QAAI,SAAS,QAAQ;AACnB,cAAQ,MAAM,uBAAuB;AACrC,aAAO,SAAS,IAAI;AAAA,IAC1B;AACI,QAAI,QAAQ,MAAM,SAAS,QAAQ,mBAAmB,IAAI,IAAI;AAC5D,cAAQ,KAAK,eAAe;AAC5B,aAAO,GAAG,IAAI;AAAA,IACpB;AACI,WAAO,IAAI,IAAI;AAAA,EACnB;AAYE,WAAS,SAAS,MAAM;AACtB,QAAI,SAAS,QAAQ;AACnB,cAAQ,QAAQ,IAAI;AACpB;AACA,aAAO;AAAA,IACb;AACI,YAAQ,KAAK,uBAAuB;AACpC,WAAO,cAAc,IAAI,IAAI,aAAa,SAAS,SAAS,YAAY,EAAE,IAAI,IAAI,QAAQ,IAAI;AAAA,EAClG;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-extension-gfm-autolink-literal@2.1.0/node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"syntax.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-extension-gfm-autolink-literal@2.1.0/node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.js"],"sourcesContent":["/**\n * @import {Code, ConstructRecord, Event, Extension, Previous, State, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { asciiAlpha, asciiAlphanumeric, asciiControl, markdownLineEndingOrSpace, unicodePunctuation, unicodeWhitespace } from 'micromark-util-character';\nconst wwwPrefix = {\n  tokenize: tokenizeWwwPrefix,\n  partial: true\n};\nconst domain = {\n  tokenize: tokenizeDomain,\n  partial: true\n};\nconst path = {\n  tokenize: tokenizePath,\n  partial: true\n};\nconst trail = {\n  tokenize: tokenizeTrail,\n  partial: true\n};\nconst emailDomainDotTrail = {\n  tokenize: tokenizeEmailDomainDotTrail,\n  partial: true\n};\nconst wwwAutolink = {\n  name: 'wwwAutolink',\n  tokenize: tokenizeWwwAutolink,\n  previous: previousWww\n};\nconst protocolAutolink = {\n  name: 'protocolAutolink',\n  tokenize: tokenizeProtocolAutolink,\n  previous: previousProtocol\n};\nconst emailAutolink = {\n  name: 'emailAutolink',\n  tokenize: tokenizeEmailAutolink,\n  previous: previousEmail\n};\n\n/** @type {ConstructRecord} */\nconst text = {};\n\n/**\n * Create an extension for `micromark` to support GitHub autolink literal\n * syntax.\n *\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to enable GFM\n *   autolink literal syntax.\n */\nexport function gfmAutolinkLiteral() {\n  return {\n    text\n  };\n}\n\n/** @type {Code} */\nlet code = 48;\n\n// Add alphanumerics.\nwhile (code < 123) {\n  text[code] = emailAutolink;\n  code++;\n  if (code === 58) code = 65;else if (code === 91) code = 97;\n}\ntext[43] = emailAutolink;\ntext[45] = emailAutolink;\ntext[46] = emailAutolink;\ntext[95] = emailAutolink;\ntext[72] = [emailAutolink, protocolAutolink];\ntext[104] = [emailAutolink, protocolAutolink];\ntext[87] = [emailAutolink, wwwAutolink];\ntext[119] = [emailAutolink, wwwAutolink];\n\n// To do: perform email autolink literals on events, afterwards.\n// That’s where `markdown-rs` and `cmark-gfm` perform it.\n// It should look for `@`, then for atext backwards, and then for a label\n// forwards.\n// To do: `mailto:`, `xmpp:` protocol as prefix.\n\n/**\n * Email autolink literal.\n *\n * ```markdown\n * > | a contact@example.org b\n *       ^^^^^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeEmailAutolink(effects, ok, nok) {\n  const self = this;\n  /** @type {boolean | undefined} */\n  let dot;\n  /** @type {boolean} */\n  let data;\n  return start;\n\n  /**\n   * Start of email autolink literal.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (!gfmAtext(code) || !previousEmail.call(self, self.previous) || previousUnbalanced(self.events)) {\n      return nok(code);\n    }\n    effects.enter('literalAutolink');\n    effects.enter('literalAutolinkEmail');\n    return atext(code);\n  }\n\n  /**\n   * In email atext.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atext(code) {\n    if (gfmAtext(code)) {\n      effects.consume(code);\n      return atext;\n    }\n    if (code === 64) {\n      effects.consume(code);\n      return emailDomain;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In email domain.\n   *\n   * The reference code is a bit overly complex as it handles the `@`, of which\n   * there may be just one.\n   * Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L318>\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailDomain(code) {\n    // Dot followed by alphanumerical (not `-` or `_`).\n    if (code === 46) {\n      return effects.check(emailDomainDotTrail, emailDomainAfter, emailDomainDot)(code);\n    }\n\n    // Alphanumerical, `-`, and `_`.\n    if (code === 45 || code === 95 || asciiAlphanumeric(code)) {\n      data = true;\n      effects.consume(code);\n      return emailDomain;\n    }\n\n    // To do: `/` if xmpp.\n\n    // Note: normally we’d truncate trailing punctuation from the link.\n    // However, email autolink literals cannot contain any of those markers,\n    // except for `.`, but that can only occur if it isn’t trailing.\n    // So we can ignore truncating!\n    return emailDomainAfter(code);\n  }\n\n  /**\n   * In email domain, on dot that is not a trail.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *                      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailDomainDot(code) {\n    effects.consume(code);\n    dot = true;\n    return emailDomain;\n  }\n\n  /**\n   * After email domain.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *                          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailDomainAfter(code) {\n    // Domain must not be empty, must include a dot, and must end in alphabetical.\n    // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L332>.\n    if (data && dot && asciiAlpha(self.previous)) {\n      effects.exit('literalAutolinkEmail');\n      effects.exit('literalAutolink');\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\n\n/**\n * `www` autolink literal.\n *\n * ```markdown\n * > | a www.example.org b\n *       ^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeWwwAutolink(effects, ok, nok) {\n  const self = this;\n  return wwwStart;\n\n  /**\n   * Start of www autolink literal.\n   *\n   * ```markdown\n   * > | www.example.com/a?b#c\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwStart(code) {\n    if (code !== 87 && code !== 119 || !previousWww.call(self, self.previous) || previousUnbalanced(self.events)) {\n      return nok(code);\n    }\n    effects.enter('literalAutolink');\n    effects.enter('literalAutolinkWww');\n    // Note: we *check*, so we can discard the `www.` we parsed.\n    // If it worked, we consider it as a part of the domain.\n    return effects.check(wwwPrefix, effects.attempt(domain, effects.attempt(path, wwwAfter), nok), nok)(code);\n  }\n\n  /**\n   * After a www autolink literal.\n   *\n   * ```markdown\n   * > | www.example.com/a?b#c\n   *                          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwAfter(code) {\n    effects.exit('literalAutolinkWww');\n    effects.exit('literalAutolink');\n    return ok(code);\n  }\n}\n\n/**\n * Protocol autolink literal.\n *\n * ```markdown\n * > | a https://example.org b\n *       ^^^^^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeProtocolAutolink(effects, ok, nok) {\n  const self = this;\n  let buffer = '';\n  let seen = false;\n  return protocolStart;\n\n  /**\n   * Start of protocol autolink literal.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolStart(code) {\n    if ((code === 72 || code === 104) && previousProtocol.call(self, self.previous) && !previousUnbalanced(self.events)) {\n      effects.enter('literalAutolink');\n      effects.enter('literalAutolinkHttp');\n      buffer += String.fromCodePoint(code);\n      effects.consume(code);\n      return protocolPrefixInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In protocol.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *     ^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolPrefixInside(code) {\n    // `5` is size of `https`\n    if (asciiAlpha(code) && buffer.length < 5) {\n      // @ts-expect-error: definitely number.\n      buffer += String.fromCodePoint(code);\n      effects.consume(code);\n      return protocolPrefixInside;\n    }\n    if (code === 58) {\n      const protocol = buffer.toLowerCase();\n      if (protocol === 'http' || protocol === 'https') {\n        effects.consume(code);\n        return protocolSlashesInside;\n      }\n    }\n    return nok(code);\n  }\n\n  /**\n   * In slashes.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *           ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolSlashesInside(code) {\n    if (code === 47) {\n      effects.consume(code);\n      if (seen) {\n        return afterProtocol;\n      }\n      seen = true;\n      return protocolSlashesInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After protocol, before domain.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterProtocol(code) {\n    // To do: this is different from `markdown-rs`:\n    // https://github.com/wooorm/markdown-rs/blob/b3a921c761309ae00a51fe348d8a43adbc54b518/src/construct/gfm_autolink_literal.rs#L172-L182\n    return code === null || asciiControl(code) || markdownLineEndingOrSpace(code) || unicodeWhitespace(code) || unicodePunctuation(code) ? nok(code) : effects.attempt(domain, effects.attempt(path, protocolAfter), nok)(code);\n  }\n\n  /**\n   * After a protocol autolink literal.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *                              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolAfter(code) {\n    effects.exit('literalAutolinkHttp');\n    effects.exit('literalAutolink');\n    return ok(code);\n  }\n}\n\n/**\n * `www` prefix.\n *\n * ```markdown\n * > | a www.example.org b\n *       ^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeWwwPrefix(effects, ok, nok) {\n  let size = 0;\n  return wwwPrefixInside;\n\n  /**\n   * In www prefix.\n   *\n   * ```markdown\n   * > | www.example.com\n   *     ^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwPrefixInside(code) {\n    if ((code === 87 || code === 119) && size < 3) {\n      size++;\n      effects.consume(code);\n      return wwwPrefixInside;\n    }\n    if (code === 46 && size === 3) {\n      effects.consume(code);\n      return wwwPrefixAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After www prefix.\n   *\n   * ```markdown\n   * > | www.example.com\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwPrefixAfter(code) {\n    // If there is *anything*, we can link.\n    return code === null ? nok(code) : ok(code);\n  }\n}\n\n/**\n * Domain.\n *\n * ```markdown\n * > | a https://example.org b\n *               ^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDomain(effects, ok, nok) {\n  /** @type {boolean | undefined} */\n  let underscoreInLastSegment;\n  /** @type {boolean | undefined} */\n  let underscoreInLastLastSegment;\n  /** @type {boolean | undefined} */\n  let seen;\n  return domainInside;\n\n  /**\n   * In domain.\n   *\n   * ```markdown\n   * > | https://example.com/a\n   *             ^^^^^^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function domainInside(code) {\n    // Check whether this marker, which is a trailing punctuation\n    // marker, optionally followed by more trailing markers, and then\n    // followed by an end.\n    if (code === 46 || code === 95) {\n      return effects.check(trail, domainAfter, domainAtPunctuation)(code);\n    }\n\n    // GH documents that only alphanumerics (other than `-`, `.`, and `_`) can\n    // occur, which sounds like ASCII only, but they also support `www.點看.com`,\n    // so that’s Unicode.\n    // Instead of some new production for Unicode alphanumerics, markdown\n    // already has that for Unicode punctuation and whitespace, so use those.\n    // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L12>.\n    if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code) || code !== 45 && unicodePunctuation(code)) {\n      return domainAfter(code);\n    }\n    seen = true;\n    effects.consume(code);\n    return domainInside;\n  }\n\n  /**\n   * In domain, at potential trailing punctuation, that was not trailing.\n   *\n   * ```markdown\n   * > | https://example.com\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function domainAtPunctuation(code) {\n    // There is an underscore in the last segment of the domain\n    if (code === 95) {\n      underscoreInLastSegment = true;\n    }\n    // Otherwise, it’s a `.`: save the last segment underscore in the\n    // penultimate segment slot.\n    else {\n      underscoreInLastLastSegment = underscoreInLastSegment;\n      underscoreInLastSegment = undefined;\n    }\n    effects.consume(code);\n    return domainInside;\n  }\n\n  /**\n   * After domain.\n   *\n   * ```markdown\n   * > | https://example.com/a\n   *                        ^\n   * ```\n   *\n   * @type {State} */\n  function domainAfter(code) {\n    // Note: that’s GH says a dot is needed, but it’s not true:\n    // <https://github.com/github/cmark-gfm/issues/279>\n    if (underscoreInLastLastSegment || underscoreInLastSegment || !seen) {\n      return nok(code);\n    }\n    return ok(code);\n  }\n}\n\n/**\n * Path.\n *\n * ```markdown\n * > | a https://example.org/stuff b\n *                          ^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizePath(effects, ok) {\n  let sizeOpen = 0;\n  let sizeClose = 0;\n  return pathInside;\n\n  /**\n   * In path.\n   *\n   * ```markdown\n   * > | https://example.com/a\n   *                        ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function pathInside(code) {\n    if (code === 40) {\n      sizeOpen++;\n      effects.consume(code);\n      return pathInside;\n    }\n\n    // To do: `markdown-rs` also needs this.\n    // If this is a paren, and there are less closings than openings,\n    // we don’t check for a trail.\n    if (code === 41 && sizeClose < sizeOpen) {\n      return pathAtPunctuation(code);\n    }\n\n    // Check whether this trailing punctuation marker is optionally\n    // followed by more trailing markers, and then followed\n    // by an end.\n    if (code === 33 || code === 34 || code === 38 || code === 39 || code === 41 || code === 42 || code === 44 || code === 46 || code === 58 || code === 59 || code === 60 || code === 63 || code === 93 || code === 95 || code === 126) {\n      return effects.check(trail, ok, pathAtPunctuation)(code);\n    }\n    if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n      return ok(code);\n    }\n    effects.consume(code);\n    return pathInside;\n  }\n\n  /**\n   * In path, at potential trailing punctuation, that was not trailing.\n   *\n   * ```markdown\n   * > | https://example.com/a\"b\n   *                          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function pathAtPunctuation(code) {\n    // Count closing parens.\n    if (code === 41) {\n      sizeClose++;\n    }\n    effects.consume(code);\n    return pathInside;\n  }\n}\n\n/**\n * Trail.\n *\n * This calls `ok` if this *is* the trail, followed by an end, which means\n * the entire trail is not part of the link.\n * It calls `nok` if this *is* part of the link.\n *\n * ```markdown\n * > | https://example.com\").\n *                        ^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTrail(effects, ok, nok) {\n  return trail;\n\n  /**\n   * In trail of domain or path.\n   *\n   * ```markdown\n   * > | https://example.com\").\n   *                        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trail(code) {\n    // Regular trailing punctuation.\n    if (code === 33 || code === 34 || code === 39 || code === 41 || code === 42 || code === 44 || code === 46 || code === 58 || code === 59 || code === 63 || code === 95 || code === 126) {\n      effects.consume(code);\n      return trail;\n    }\n\n    // `&` followed by one or more alphabeticals and then a `;`, is\n    // as a whole considered as trailing punctuation.\n    // In all other cases, it is considered as continuation of the URL.\n    if (code === 38) {\n      effects.consume(code);\n      return trailCharacterReferenceStart;\n    }\n\n    // Needed because we allow literals after `[`, as we fix:\n    // <https://github.com/github/cmark-gfm/issues/278>.\n    // Check that it is not followed by `(` or `[`.\n    if (code === 93) {\n      effects.consume(code);\n      return trailBracketAfter;\n    }\n    if (\n    // `<` is an end.\n    code === 60 ||\n    // So is whitespace.\n    code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n      return ok(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In trail, after `]`.\n   *\n   * > 👉 **Note**: this deviates from `cmark-gfm` to fix a bug.\n   * > See end of <https://github.com/github/cmark-gfm/issues/278> for more.\n   *\n   * ```markdown\n   * > | https://example.com](\n   *                         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trailBracketAfter(code) {\n    // Whitespace or something that could start a resource or reference is the end.\n    // Switch back to trail otherwise.\n    if (code === null || code === 40 || code === 91 || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n      return ok(code);\n    }\n    return trail(code);\n  }\n\n  /**\n   * In character-reference like trail, after `&`.\n   *\n   * ```markdown\n   * > | https://example.com&amp;).\n   *                         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trailCharacterReferenceStart(code) {\n    // When non-alpha, it’s not a trail.\n    return asciiAlpha(code) ? trailCharacterReferenceInside(code) : nok(code);\n  }\n\n  /**\n   * In character-reference like trail.\n   *\n   * ```markdown\n   * > | https://example.com&amp;).\n   *                         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trailCharacterReferenceInside(code) {\n    // Switch back to trail if this is well-formed.\n    if (code === 59) {\n      effects.consume(code);\n      return trail;\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return trailCharacterReferenceInside;\n    }\n\n    // It’s not a trail.\n    return nok(code);\n  }\n}\n\n/**\n * Dot in email domain trail.\n *\n * This calls `ok` if this *is* the trail, followed by an end, which means\n * the trail is not part of the link.\n * It calls `nok` if this *is* part of the link.\n *\n * ```markdown\n * > | contact@example.org.\n *                        ^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeEmailDomainDotTrail(effects, ok, nok) {\n  return start;\n\n  /**\n   * Dot.\n   *\n   * ```markdown\n   * > | contact@example.org.\n   *                    ^   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // Must be dot.\n    effects.consume(code);\n    return after;\n  }\n\n  /**\n   * After dot.\n   *\n   * ```markdown\n   * > | contact@example.org.\n   *                     ^   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // Not a trail if alphanumeric.\n    return asciiAlphanumeric(code) ? nok(code) : ok(code);\n  }\n}\n\n/**\n * See:\n * <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L156>.\n *\n * @type {Previous}\n */\nfunction previousWww(code) {\n  return code === null || code === 40 || code === 42 || code === 95 || code === 91 || code === 93 || code === 126 || markdownLineEndingOrSpace(code);\n}\n\n/**\n * See:\n * <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L214>.\n *\n * @type {Previous}\n */\nfunction previousProtocol(code) {\n  return !asciiAlpha(code);\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Previous}\n */\nfunction previousEmail(code) {\n  // Do not allow a slash “inside” atext.\n  // The reference code is a bit weird, but that’s what it results in.\n  // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L307>.\n  // Other than slash, every preceding character is allowed.\n  return !(code === 47 || gfmAtext(code));\n}\n\n/**\n * @param {Code} code\n * @returns {boolean}\n */\nfunction gfmAtext(code) {\n  return code === 43 || code === 45 || code === 46 || code === 95 || asciiAlphanumeric(code);\n}\n\n/**\n * @param {Array<Event>} events\n * @returns {boolean}\n */\nfunction previousUnbalanced(events) {\n  let index = events.length;\n  let result = false;\n  while (index--) {\n    const token = events[index][1];\n    if ((token.type === 'labelLink' || token.type === 'labelImage') && !token._balanced) {\n      result = true;\n      break;\n    }\n\n    // If we’ve seen this token, and it was marked as not having any unbalanced\n    // bracket before it, we can exit.\n    if (token._gfmAutolinkLiteralWalkedInto) {\n      result = false;\n      break;\n    }\n  }\n  if (events.length > 0 && !result) {\n    // Mark the last token as “walked into” w/o finding\n    // anything.\n    events[events.length - 1][1]._gfmAutolinkLiteralWalkedInto = true;\n  }\n  return result;\n}"],"names":["code","trail"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-extension-gfm-footnote@2.1.0/node_modules/micromark-extension-gfm-footnote/lib/syntax.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"syntax.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-extension-gfm-footnote@2.1.0/node_modules/micromark-extension-gfm-footnote/lib/syntax.js"],"sourcesContent":["/**\n * @import {Event, Exiter, Extension, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { blankLine } from 'micromark-core-commonmark';\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEndingOrSpace } from 'micromark-util-character';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nconst indent = {\n  tokenize: tokenizeIndent,\n  partial: true\n};\n\n// To do: micromark should support a `_hiddenGfmFootnoteSupport`, which only\n// affects label start (image).\n// That will let us drop `tokenizePotentialGfmFootnote*`.\n// It currently has a `_hiddenFootnoteSupport`, which affects that and more.\n// That can be removed when `micromark-extension-footnote` is archived.\n\n/**\n * Create an extension for `micromark` to enable GFM footnote syntax.\n *\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to\n *   enable GFM footnote syntax.\n */\nexport function gfmFootnote() {\n  /** @type {Extension} */\n  return {\n    document: {\n      [91]: {\n        name: 'gfmFootnoteDefinition',\n        tokenize: tokenizeDefinitionStart,\n        continuation: {\n          tokenize: tokenizeDefinitionContinuation\n        },\n        exit: gfmFootnoteDefinitionEnd\n      }\n    },\n    text: {\n      [91]: {\n        name: 'gfmFootnoteCall',\n        tokenize: tokenizeGfmFootnoteCall\n      },\n      [93]: {\n        name: 'gfmPotentialFootnoteCall',\n        add: 'after',\n        tokenize: tokenizePotentialGfmFootnoteCall,\n        resolveTo: resolveToPotentialGfmFootnoteCall\n      }\n    }\n  };\n}\n\n// To do: remove after micromark update.\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizePotentialGfmFootnoteCall(effects, ok, nok) {\n  const self = this;\n  let index = self.events.length;\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);\n  /** @type {Token} */\n  let labelStart;\n\n  // Find an opening.\n  while (index--) {\n    const token = self.events[index][1];\n    if (token.type === \"labelImage\") {\n      labelStart = token;\n      break;\n    }\n\n    // Exit if we’ve walked far enough.\n    if (token.type === 'gfmFootnoteCall' || token.type === \"labelLink\" || token.type === \"label\" || token.type === \"image\" || token.type === \"link\") {\n      break;\n    }\n  }\n  return start;\n\n  /**\n   * @type {State}\n   */\n  function start(code) {\n    if (!labelStart || !labelStart._balanced) {\n      return nok(code);\n    }\n    const id = normalizeIdentifier(self.sliceSerialize({\n      start: labelStart.end,\n      end: self.now()\n    }));\n    if (id.codePointAt(0) !== 94 || !defined.includes(id.slice(1))) {\n      return nok(code);\n    }\n    effects.enter('gfmFootnoteCallLabelMarker');\n    effects.consume(code);\n    effects.exit('gfmFootnoteCallLabelMarker');\n    return ok(code);\n  }\n}\n\n// To do: remove after micromark update.\n/** @type {Resolver} */\nfunction resolveToPotentialGfmFootnoteCall(events, context) {\n  let index = events.length;\n  /** @type {Token | undefined} */\n  let labelStart;\n\n  // Find an opening.\n  while (index--) {\n    if (events[index][1].type === \"labelImage\" && events[index][0] === 'enter') {\n      labelStart = events[index][1];\n      break;\n    }\n  }\n  // Change the `labelImageMarker` to a `data`.\n  events[index + 1][1].type = \"data\";\n  events[index + 3][1].type = 'gfmFootnoteCallLabelMarker';\n\n  // The whole (without `!`):\n  /** @type {Token} */\n  const call = {\n    type: 'gfmFootnoteCall',\n    start: Object.assign({}, events[index + 3][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  };\n  // The `^` marker\n  /** @type {Token} */\n  const marker = {\n    type: 'gfmFootnoteCallMarker',\n    start: Object.assign({}, events[index + 3][1].end),\n    end: Object.assign({}, events[index + 3][1].end)\n  };\n  // Increment the end 1 character.\n  marker.end.column++;\n  marker.end.offset++;\n  marker.end._bufferIndex++;\n  /** @type {Token} */\n  const string = {\n    type: 'gfmFootnoteCallString',\n    start: Object.assign({}, marker.end),\n    end: Object.assign({}, events[events.length - 1][1].start)\n  };\n  /** @type {Token} */\n  const chunk = {\n    type: \"chunkString\",\n    contentType: 'string',\n    start: Object.assign({}, string.start),\n    end: Object.assign({}, string.end)\n  };\n\n  /** @type {Array<Event>} */\n  const replacement = [\n  // Take the `labelImageMarker` (now `data`, the `!`)\n  events[index + 1], events[index + 2], ['enter', call, context],\n  // The `[`\n  events[index + 3], events[index + 4],\n  // The `^`.\n  ['enter', marker, context], ['exit', marker, context],\n  // Everything in between.\n  ['enter', string, context], ['enter', chunk, context], ['exit', chunk, context], ['exit', string, context],\n  // The ending (`]`, properly parsed and labelled).\n  events[events.length - 2], events[events.length - 1], ['exit', call, context]];\n  events.splice(index, events.length - index + 1, ...replacement);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeGfmFootnoteCall(effects, ok, nok) {\n  const self = this;\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);\n  let size = 0;\n  /** @type {boolean} */\n  let data;\n\n  // Note: the implementation of `markdown-rs` is different, because it houses\n  // core *and* extensions in one project.\n  // Therefore, it can include footnote logic inside `label-end`.\n  // We can’t do that, but luckily, we can parse footnotes in a simpler way than\n  // needed for labels.\n  return start;\n\n  /**\n   * Start of footnote label.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('gfmFootnoteCall');\n    effects.enter('gfmFootnoteCallLabelMarker');\n    effects.consume(code);\n    effects.exit('gfmFootnoteCallLabelMarker');\n    return callStart;\n  }\n\n  /**\n   * After `[`, at `^`.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function callStart(code) {\n    if (code !== 94) return nok(code);\n    effects.enter('gfmFootnoteCallMarker');\n    effects.consume(code);\n    effects.exit('gfmFootnoteCallMarker');\n    effects.enter('gfmFootnoteCallString');\n    effects.enter('chunkString').contentType = 'string';\n    return callData;\n  }\n\n  /**\n   * In label.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function callData(code) {\n    if (\n    // Too long.\n    size > 999 ||\n    // Closing brace with nothing.\n    code === 93 && !data ||\n    // Space or tab is not supported by GFM for some reason.\n    // `\\n` and `[` not being supported makes sense.\n    code === null || code === 91 || markdownLineEndingOrSpace(code)) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.exit('chunkString');\n      const token = effects.exit('gfmFootnoteCallString');\n      if (!defined.includes(normalizeIdentifier(self.sliceSerialize(token)))) {\n        return nok(code);\n      }\n      effects.enter('gfmFootnoteCallLabelMarker');\n      effects.consume(code);\n      effects.exit('gfmFootnoteCallLabelMarker');\n      effects.exit('gfmFootnoteCall');\n      return ok;\n    }\n    if (!markdownLineEndingOrSpace(code)) {\n      data = true;\n    }\n    size++;\n    effects.consume(code);\n    return code === 92 ? callEscape : callData;\n  }\n\n  /**\n   * On character after escape.\n   *\n   * ```markdown\n   * > | a [^b\\c] d\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function callEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return callData;\n    }\n    return callData(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinitionStart(effects, ok, nok) {\n  const self = this;\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);\n  /** @type {string} */\n  let identifier;\n  let size = 0;\n  /** @type {boolean | undefined} */\n  let data;\n  return start;\n\n  /**\n   * Start of GFM footnote definition.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('gfmFootnoteDefinition')._container = true;\n    effects.enter('gfmFootnoteDefinitionLabel');\n    effects.enter('gfmFootnoteDefinitionLabelMarker');\n    effects.consume(code);\n    effects.exit('gfmFootnoteDefinitionLabelMarker');\n    return labelAtMarker;\n  }\n\n  /**\n   * In label, at caret.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAtMarker(code) {\n    if (code === 94) {\n      effects.enter('gfmFootnoteDefinitionMarker');\n      effects.consume(code);\n      effects.exit('gfmFootnoteDefinitionMarker');\n      effects.enter('gfmFootnoteDefinitionLabelString');\n      effects.enter('chunkString').contentType = 'string';\n      return labelInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In label.\n   *\n   * > 👉 **Note**: `cmark-gfm` prevents whitespace from occurring in footnote\n   * > definition labels.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelInside(code) {\n    if (\n    // Too long.\n    size > 999 ||\n    // Closing brace with nothing.\n    code === 93 && !data ||\n    // Space or tab is not supported by GFM for some reason.\n    // `\\n` and `[` not being supported makes sense.\n    code === null || code === 91 || markdownLineEndingOrSpace(code)) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.exit('chunkString');\n      const token = effects.exit('gfmFootnoteDefinitionLabelString');\n      identifier = normalizeIdentifier(self.sliceSerialize(token));\n      effects.enter('gfmFootnoteDefinitionLabelMarker');\n      effects.consume(code);\n      effects.exit('gfmFootnoteDefinitionLabelMarker');\n      effects.exit('gfmFootnoteDefinitionLabel');\n      return labelAfter;\n    }\n    if (!markdownLineEndingOrSpace(code)) {\n      data = true;\n    }\n    size++;\n    effects.consume(code);\n    return code === 92 ? labelEscape : labelInside;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * > 👉 **Note**: `cmark-gfm` currently does not support escaped brackets:\n   * > <https://github.com/github/cmark-gfm/issues/240>\n   *\n   * ```markdown\n   * > | [^a\\*b]: c\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   * After definition label.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAfter(code) {\n    if (code === 58) {\n      effects.enter('definitionMarker');\n      effects.consume(code);\n      effects.exit('definitionMarker');\n      if (!defined.includes(identifier)) {\n        defined.push(identifier);\n      }\n\n      // Any whitespace after the marker is eaten, forming indented code\n      // is not possible.\n      // No space is also fine, just like a block quote marker.\n      return factorySpace(effects, whitespaceAfter, 'gfmFootnoteDefinitionWhitespace');\n    }\n    return nok(code);\n  }\n\n  /**\n   * After definition prefix.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function whitespaceAfter(code) {\n    // `markdown-rs` has a wrapping token for the prefix that is closed here.\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinitionContinuation(effects, ok, nok) {\n  /// Start of footnote definition continuation.\n  ///\n  /// ```markdown\n  ///   | [^a]: b\n  /// > |     c\n  ///     ^\n  /// ```\n  //\n  // Either a blank line, which is okay, or an indented thing.\n  return effects.check(blankLine, ok, effects.attempt(indent, ok, nok));\n}\n\n/** @type {Exiter} */\nfunction gfmFootnoteDefinitionEnd(effects) {\n  effects.exit('gfmFootnoteDefinition');\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this;\n  return factorySpace(effects, afterPrefix, 'gfmFootnoteDefinitionIndent', 4 + 1);\n\n  /**\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === 'gfmFootnoteDefinitionIndent' && tail[2].sliceSerialize(tail[1], true).length === 4 ? ok(code) : nok(code);\n  }\n}"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-extension-gfm-strikethrough@2.1.0/node_modules/micromark-extension-gfm-strikethrough/lib/syntax.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"syntax.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-extension-gfm-strikethrough@2.1.0/node_modules/micromark-extension-gfm-strikethrough/lib/syntax.js"],"sourcesContent":["/**\n * @import {Options} from 'micromark-extension-gfm-strikethrough'\n * @import {Event, Extension, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { splice } from 'micromark-util-chunked';\nimport { classifyCharacter } from 'micromark-util-classify-character';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/**\n * Create an extension for `micromark` to enable GFM strikethrough syntax.\n *\n * @param {Options | null | undefined} [options={}]\n *   Configuration.\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions`, to\n *   enable GFM strikethrough syntax.\n */\nexport function gfmStrikethrough(options) {\n  const options_ = options || {};\n  let single = options_.singleTilde;\n  const tokenizer = {\n    name: 'strikethrough',\n    tokenize: tokenizeStrikethrough,\n    resolveAll: resolveAllStrikethrough\n  };\n  if (single === null || single === undefined) {\n    single = true;\n  }\n  return {\n    text: {\n      [126]: tokenizer\n    },\n    insideSpan: {\n      null: [tokenizer]\n    },\n    attentionMarkers: {\n      null: [126]\n    }\n  };\n\n  /**\n   * Take events and resolve strikethrough.\n   *\n   * @type {Resolver}\n   */\n  function resolveAllStrikethrough(events, context) {\n    let index = -1;\n\n    // Walk through all events.\n    while (++index < events.length) {\n      // Find a token that can close.\n      if (events[index][0] === 'enter' && events[index][1].type === 'strikethroughSequenceTemporary' && events[index][1]._close) {\n        let open = index;\n\n        // Now walk back to find an opener.\n        while (open--) {\n          // Find a token that can open the closer.\n          if (events[open][0] === 'exit' && events[open][1].type === 'strikethroughSequenceTemporary' && events[open][1]._open &&\n          // If the sizes are the same:\n          events[index][1].end.offset - events[index][1].start.offset === events[open][1].end.offset - events[open][1].start.offset) {\n            events[index][1].type = 'strikethroughSequence';\n            events[open][1].type = 'strikethroughSequence';\n\n            /** @type {Token} */\n            const strikethrough = {\n              type: 'strikethrough',\n              start: Object.assign({}, events[open][1].start),\n              end: Object.assign({}, events[index][1].end)\n            };\n\n            /** @type {Token} */\n            const text = {\n              type: 'strikethroughText',\n              start: Object.assign({}, events[open][1].end),\n              end: Object.assign({}, events[index][1].start)\n            };\n\n            // Opening.\n            /** @type {Array<Event>} */\n            const nextEvents = [['enter', strikethrough, context], ['enter', events[open][1], context], ['exit', events[open][1], context], ['enter', text, context]];\n            const insideSpan = context.parser.constructs.insideSpan.null;\n            if (insideSpan) {\n              // Between.\n              splice(nextEvents, nextEvents.length, 0, resolveAll(insideSpan, events.slice(open + 1, index), context));\n            }\n\n            // Closing.\n            splice(nextEvents, nextEvents.length, 0, [['exit', text, context], ['enter', events[index][1], context], ['exit', events[index][1], context], ['exit', strikethrough, context]]);\n            splice(events, open - 1, index - open + 3, nextEvents);\n            index = open + nextEvents.length - 2;\n            break;\n          }\n        }\n      }\n    }\n    index = -1;\n    while (++index < events.length) {\n      if (events[index][1].type === 'strikethroughSequenceTemporary') {\n        events[index][1].type = \"data\";\n      }\n    }\n    return events;\n  }\n\n  /**\n   * @this {TokenizeContext}\n   * @type {Tokenizer}\n   */\n  function tokenizeStrikethrough(effects, ok, nok) {\n    const previous = this.previous;\n    const events = this.events;\n    let size = 0;\n    return start;\n\n    /** @type {State} */\n    function start(code) {\n      if (previous === 126 && events[events.length - 1][1].type !== \"characterEscape\") {\n        return nok(code);\n      }\n      effects.enter('strikethroughSequenceTemporary');\n      return more(code);\n    }\n\n    /** @type {State} */\n    function more(code) {\n      const before = classifyCharacter(previous);\n      if (code === 126) {\n        // If this is the third marker, exit.\n        if (size > 1) return nok(code);\n        effects.consume(code);\n        size++;\n        return more;\n      }\n      if (size < 2 && !single) return nok(code);\n      const token = effects.exit('strikethroughSequenceTemporary');\n      const after = classifyCharacter(code);\n      token._open = !after || after === 2 && Boolean(before);\n      token._close = !before || before === 2 && Boolean(after);\n      return ok(code);\n    }\n  }\n}"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-extension-gfm-table@2.1.1/node_modules/micromark-extension-gfm-table/lib/edit-map.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"edit-map.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-extension-gfm-table@2.1.1/node_modules/micromark-extension-gfm-table/lib/edit-map.js"],"sourcesContent":["/**\n * @import {Event} from 'micromark-util-types'\n */\n\n// Port of `edit_map.rs` from `markdown-rs`.\n// This should move to `markdown-js` later.\n\n// Deal with several changes in events, batching them together.\n//\n// Preferably, changes should be kept to a minimum.\n// Sometimes, it’s needed to change the list of events, because parsing can be\n// messy, and it helps to expose a cleaner interface of events to the compiler\n// and other users.\n// It can also help to merge many adjacent similar events.\n// And, in other cases, it’s needed to parse subcontent: pass some events\n// through another tokenizer and inject the result.\n\n/**\n * @typedef {[number, number, Array<Event>]} Change\n * @typedef {[number, number, number]} Jump\n */\n\n/**\n * Tracks a bunch of edits.\n */\nexport class EditMap {\n  /**\n   * Create a new edit map.\n   */\n  constructor() {\n    /**\n     * Record of changes.\n     *\n     * @type {Array<Change>}\n     */\n    this.map = [];\n  }\n\n  /**\n   * Create an edit: a remove and/or add at a certain place.\n   *\n   * @param {number} index\n   * @param {number} remove\n   * @param {Array<Event>} add\n   * @returns {undefined}\n   */\n  add(index, remove, add) {\n    addImplementation(this, index, remove, add);\n  }\n\n  // To do: add this when moving to `micromark`.\n  // /**\n  //  * Create an edit: but insert `add` before existing additions.\n  //  *\n  //  * @param {number} index\n  //  * @param {number} remove\n  //  * @param {Array<Event>} add\n  //  * @returns {undefined}\n  //  */\n  // addBefore(index, remove, add) {\n  //   addImplementation(this, index, remove, add, true)\n  // }\n\n  /**\n   * Done, change the events.\n   *\n   * @param {Array<Event>} events\n   * @returns {undefined}\n   */\n  consume(events) {\n    this.map.sort(function (a, b) {\n      return a[0] - b[0];\n    });\n\n    /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */\n    if (this.map.length === 0) {\n      return;\n    }\n\n    // To do: if links are added in events, like they are in `markdown-rs`,\n    // this is needed.\n    // // Calculate jumps: where items in the current list move to.\n    // /** @type {Array<Jump>} */\n    // const jumps = []\n    // let index = 0\n    // let addAcc = 0\n    // let removeAcc = 0\n    // while (index < this.map.length) {\n    //   const [at, remove, add] = this.map[index]\n    //   removeAcc += remove\n    //   addAcc += add.length\n    //   jumps.push([at, removeAcc, addAcc])\n    //   index += 1\n    // }\n    //\n    // . shiftLinks(events, jumps)\n\n    let index = this.map.length;\n    /** @type {Array<Array<Event>>} */\n    const vecs = [];\n    while (index > 0) {\n      index -= 1;\n      vecs.push(events.slice(this.map[index][0] + this.map[index][1]), this.map[index][2]);\n\n      // Truncate rest.\n      events.length = this.map[index][0];\n    }\n    vecs.push(events.slice());\n    events.length = 0;\n    let slice = vecs.pop();\n    while (slice) {\n      for (const element of slice) {\n        events.push(element);\n      }\n      slice = vecs.pop();\n    }\n\n    // Truncate everything.\n    this.map.length = 0;\n  }\n}\n\n/**\n * Create an edit.\n *\n * @param {EditMap} editMap\n * @param {number} at\n * @param {number} remove\n * @param {Array<Event>} add\n * @returns {undefined}\n */\nfunction addImplementation(editMap, at, remove, add) {\n  let index = 0;\n\n  /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */\n  if (remove === 0 && add.length === 0) {\n    return;\n  }\n  while (index < editMap.map.length) {\n    if (editMap.map[index][0] === at) {\n      editMap.map[index][1] += remove;\n\n      // To do: before not used by tables, use when moving to micromark.\n      // if (before) {\n      //   add.push(...editMap.map[index][2])\n      //   editMap.map[index][2] = add\n      // } else {\n      editMap.map[index][2].push(...add);\n      // }\n\n      return;\n    }\n    index += 1;\n  }\n  editMap.map.push([at, remove, add]);\n}\n\n// /**\n//  * Shift `previous` and `next` links according to `jumps`.\n//  *\n//  * This fixes links in case there are events removed or added between them.\n//  *\n//  * @param {Array<Event>} events\n//  * @param {Array<Jump>} jumps\n//  */\n// function shiftLinks(events, jumps) {\n//   let jumpIndex = 0\n//   let index = 0\n//   let add = 0\n//   let rm = 0\n\n//   while (index < events.length) {\n//     const rmCurr = rm\n\n//     while (jumpIndex < jumps.length && jumps[jumpIndex][0] <= index) {\n//       add = jumps[jumpIndex][2]\n//       rm = jumps[jumpIndex][1]\n//       jumpIndex += 1\n//     }\n\n//     // Ignore items that will be removed.\n//     if (rm > rmCurr) {\n//       index += rm - rmCurr\n//     } else {\n//       // ?\n//       // if let Some(link) = &events[index].link {\n//       //     if let Some(next) = link.next {\n//       //         events[next].link.as_mut().unwrap().previous = Some(index + add - rm);\n//       //         while jumpIndex < jumps.len() && jumps[jumpIndex].0 <= next {\n//       //             add = jumps[jumpIndex].2;\n//       //             rm = jumps[jumpIndex].1;\n//       //             jumpIndex += 1;\n//       //         }\n//       //         events[index].link.as_mut().unwrap().next = Some(next + add - rm);\n//       //         index = next;\n//       //         continue;\n//       //     }\n//       // }\n//       index += 1\n//     }\n//   }\n// }"],"names":[],"mappings":"AAyBO,MAAM,QAAQ;AAAA;AAAA;AAAA;AAAA,EAInB,cAAc;AAMZ,SAAK,MAAM,CAAE;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUE,IAAI,OAAO,QAAQ,KAAK;AACtB,sBAAkB,MAAM,OAAO,QAAQ,GAAG;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAqBE,QAAQ,QAAQ;AACd,SAAK,IAAI,KAAK,SAAU,GAAG,GAAG;AAC5B,aAAO,EAAE,CAAC,IAAI,EAAE,CAAC;AAAA,IACvB,CAAK;AAGD,QAAI,KAAK,IAAI,WAAW,GAAG;AACzB;AAAA,IACN;AAoBI,QAAI,QAAQ,KAAK,IAAI;AAErB,UAAM,OAAO,CAAE;AACf,WAAO,QAAQ,GAAG;AAChB,eAAS;AACT,WAAK,KAAK,OAAO,MAAM,KAAK,IAAI,KAAK,EAAE,CAAC,IAAI,KAAK,IAAI,KAAK,EAAE,CAAC,CAAC,GAAG,KAAK,IAAI,KAAK,EAAE,CAAC,CAAC;AAGnF,aAAO,SAAS,KAAK,IAAI,KAAK,EAAE,CAAC;AAAA,IACvC;AACI,SAAK,KAAK,OAAO,OAAO;AACxB,WAAO,SAAS;AAChB,QAAI,QAAQ,KAAK,IAAK;AACtB,WAAO,OAAO;AACZ,iBAAW,WAAW,OAAO;AAC3B,eAAO,KAAK,OAAO;AAAA,MAC3B;AACM,cAAQ,KAAK,IAAK;AAAA,IACxB;AAGI,SAAK,IAAI,SAAS;AAAA,EACtB;AACA;AAWA,SAAS,kBAAkB,SAAS,IAAI,QAAQ,KAAK;AACnD,MAAI,QAAQ;AAGZ,MAAI,WAAW,KAAK,IAAI,WAAW,GAAG;AACpC;AAAA,EACJ;AACE,SAAO,QAAQ,QAAQ,IAAI,QAAQ;AACjC,QAAI,QAAQ,IAAI,KAAK,EAAE,CAAC,MAAM,IAAI;AAChC,cAAQ,IAAI,KAAK,EAAE,CAAC,KAAK;AAOzB,cAAQ,IAAI,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,GAAG;AAGjC;AAAA,IACN;AACI,aAAS;AAAA,EACb;AACE,UAAQ,IAAI,KAAK,CAAC,IAAI,QAAQ,GAAG,CAAC;AACpC;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-extension-gfm-table@2.1.1/node_modules/micromark-extension-gfm-table/lib/infer.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"infer.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-extension-gfm-table@2.1.1/node_modules/micromark-extension-gfm-table/lib/infer.js"],"sourcesContent":["/**\n * @import {Event} from 'micromark-util-types'\n */\n\n/**\n * @typedef {'center' | 'left' | 'none' | 'right'} Align\n */\n\n/**\n * Figure out the alignment of a GFM table.\n *\n * @param {Readonly<Array<Event>>} events\n *   List of events.\n * @param {number} index\n *   Table enter event.\n * @returns {Array<Align>}\n *   List of aligns.\n */\nexport function gfmTableAlign(events, index) {\n  let inDelimiterRow = false;\n  /** @type {Array<Align>} */\n  const align = [];\n  while (index < events.length) {\n    const event = events[index];\n    if (inDelimiterRow) {\n      if (event[0] === 'enter') {\n        // Start of alignment value: set a new column.\n        // To do: `markdown-rs` uses `tableDelimiterCellValue`.\n        if (event[1].type === 'tableContent') {\n          align.push(events[index + 1][1].type === 'tableDelimiterMarker' ? 'left' : 'none');\n        }\n      }\n      // Exits:\n      // End of alignment value: change the column.\n      // To do: `markdown-rs` uses `tableDelimiterCellValue`.\n      else if (event[1].type === 'tableContent') {\n        if (events[index - 1][1].type === 'tableDelimiterMarker') {\n          const alignIndex = align.length - 1;\n          align[alignIndex] = align[alignIndex] === 'left' ? 'center' : 'right';\n        }\n      }\n      // Done!\n      else if (event[1].type === 'tableDelimiterRow') {\n        break;\n      }\n    } else if (event[0] === 'enter' && event[1].type === 'tableDelimiterRow') {\n      inDelimiterRow = true;\n    }\n    index += 1;\n  }\n  return align;\n}"],"names":[],"mappings":"AAkBO,SAAS,cAAc,QAAQ,OAAO;AAC3C,MAAI,iBAAiB;AAErB,QAAM,QAAQ,CAAE;AAChB,SAAO,QAAQ,OAAO,QAAQ;AAC5B,UAAM,QAAQ,OAAO,KAAK;AAC1B,QAAI,gBAAgB;AAClB,UAAI,MAAM,CAAC,MAAM,SAAS;AAGxB,YAAI,MAAM,CAAC,EAAE,SAAS,gBAAgB;AACpC,gBAAM,KAAK,OAAO,QAAQ,CAAC,EAAE,CAAC,EAAE,SAAS,yBAAyB,SAAS,MAAM;AAAA,QAC3F;AAAA,MACA,WAIe,MAAM,CAAC,EAAE,SAAS,gBAAgB;AACzC,YAAI,OAAO,QAAQ,CAAC,EAAE,CAAC,EAAE,SAAS,wBAAwB;AACxD,gBAAM,aAAa,MAAM,SAAS;AAClC,gBAAM,UAAU,IAAI,MAAM,UAAU,MAAM,SAAS,WAAW;AAAA,QACxE;AAAA,MACA,WAEe,MAAM,CAAC,EAAE,SAAS,qBAAqB;AAC9C;AAAA,MACR;AAAA,IACA,WAAe,MAAM,CAAC,MAAM,WAAW,MAAM,CAAC,EAAE,SAAS,qBAAqB;AACxE,uBAAiB;AAAA,IACvB;AACI,aAAS;AAAA,EACb;AACE,SAAO;AACT;","x_google_ignoreList":[0]}