@easyv/biz-components 0.0.20 → 0.0.21

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

@@ -1,95 +1,187 @@
-import { factorySpace as p } from "../../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js";
-import { markdownSpace as x, markdownLineEnding as u } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
-const d = {
-  partial: !0,
-  tokenize: A
-}, G = {
-  concrete: !0,
+import { factorySpace } from "../../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js";
+import { markdownSpace, markdownLineEnding } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+const nonLazyContinuation = {
+  partial: true,
+  tokenize: tokenizeNonLazyContinuation
+};
+const codeFenced = {
+  concrete: true,
   name: "codeFenced",
-  tokenize: V
+  tokenize: tokenizeCodeFenced
 };
-function V(e, m, l) {
-  const i = this, S = {
-    partial: !0,
-    tokenize: M
+function tokenizeCodeFenced(effects, ok, nok) {
+  const self = this;
+  const closeStart = {
+    partial: true,
+    tokenize: tokenizeCloseStart
   };
-  let c = 0, t = 0, o;
-  return I;
-  function I(n) {
-    return L(n);
-  }
-  function L(n) {
-    const a = i.events[i.events.length - 1];
-    return c = a && a[1].type === "linePrefix" ? a[2].sliceSerialize(a[1], !0).length : 0, o = n, e.enter("codeFenced"), e.enter("codeFencedFence"), e.enter("codeFencedFenceSequence"), z(n);
-  }
-  function z(n) {
-    return n === o ? (t++, e.consume(n), z) : t < 3 ? l(n) : (e.exit("codeFencedFenceSequence"), x(n) ? p(e, F, "whitespace")(n) : F(n));
+  let initialPrefix = 0;
+  let sizeOpen = 0;
+  let marker;
+  return start;
+  function start(code) {
+    return beforeSequenceOpen(code);
+  }
+  function beforeSequenceOpen(code) {
+    const tail = self.events[self.events.length - 1];
+    initialPrefix = tail && tail[1].type === "linePrefix" ? tail[2].sliceSerialize(tail[1], true).length : 0;
+    marker = code;
+    effects.enter("codeFenced");
+    effects.enter("codeFencedFence");
+    effects.enter("codeFencedFenceSequence");
+    return sequenceOpen(code);
+  }
+  function sequenceOpen(code) {
+    if (code === marker) {
+      sizeOpen++;
+      effects.consume(code);
+      return sequenceOpen;
+    }
+    if (sizeOpen < 3) {
+      return nok(code);
+    }
+    effects.exit("codeFencedFenceSequence");
+    return markdownSpace(code) ? factorySpace(effects, infoBefore, "whitespace")(code) : infoBefore(code);
   }
-  function F(n) {
-    return n === null || u(n) ? (e.exit("codeFencedFence"), i.interrupt ? m(n) : e.check(d, w, h)(n)) : (e.enter("codeFencedFenceInfo"), e.enter("chunkString", {
+  function infoBefore(code) {
+    if (code === null || markdownLineEnding(code)) {
+      effects.exit("codeFencedFence");
+      return self.interrupt ? ok(code) : effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);
+    }
+    effects.enter("codeFencedFenceInfo");
+    effects.enter("chunkString", {
       contentType: "string"
-    }), C(n));
-  }
-  function C(n) {
-    return n === null || u(n) ? (e.exit("chunkString"), e.exit("codeFencedFenceInfo"), F(n)) : x(n) ? (e.exit("chunkString"), e.exit("codeFencedFenceInfo"), p(e, P, "whitespace")(n)) : n === 96 && n === o ? l(n) : (e.consume(n), C);
+    });
+    return info(code);
+  }
+  function info(code) {
+    if (code === null || markdownLineEnding(code)) {
+      effects.exit("chunkString");
+      effects.exit("codeFencedFenceInfo");
+      return infoBefore(code);
+    }
+    if (markdownSpace(code)) {
+      effects.exit("chunkString");
+      effects.exit("codeFencedFenceInfo");
+      return factorySpace(effects, metaBefore, "whitespace")(code);
+    }
+    if (code === 96 && code === marker) {
+      return nok(code);
+    }
+    effects.consume(code);
+    return info;
   }
-  function P(n) {
-    return n === null || u(n) ? F(n) : (e.enter("codeFencedFenceMeta"), e.enter("chunkString", {
+  function metaBefore(code) {
+    if (code === null || markdownLineEnding(code)) {
+      return infoBefore(code);
+    }
+    effects.enter("codeFencedFenceMeta");
+    effects.enter("chunkString", {
       contentType: "string"
-    }), q(n));
-  }
-  function q(n) {
-    return n === null || u(n) ? (e.exit("chunkString"), e.exit("codeFencedFenceMeta"), F(n)) : n === 96 && n === o ? l(n) : (e.consume(n), q);
-  }
-  function w(n) {
-    return e.attempt(S, h, O)(n);
-  }
-  function O(n) {
-    return e.enter("lineEnding"), e.consume(n), e.exit("lineEnding"), v;
+    });
+    return meta(code);
+  }
+  function meta(code) {
+    if (code === null || markdownLineEnding(code)) {
+      effects.exit("chunkString");
+      effects.exit("codeFencedFenceMeta");
+      return infoBefore(code);
+    }
+    if (code === 96 && code === marker) {
+      return nok(code);
+    }
+    effects.consume(code);
+    return meta;
   }
-  function v(n) {
-    return c > 0 && x(n) ? p(e, g, "linePrefix", c + 1)(n) : g(n);
+  function atNonLazyBreak(code) {
+    return effects.attempt(closeStart, after, contentBefore)(code);
   }
-  function g(n) {
-    return n === null || u(n) ? e.check(d, w, h)(n) : (e.enter("codeFlowValue"), y(n));
+  function contentBefore(code) {
+    effects.enter("lineEnding");
+    effects.consume(code);
+    effects.exit("lineEnding");
+    return contentStart;
   }
-  function y(n) {
-    return n === null || u(n) ? (e.exit("codeFlowValue"), g(n)) : (e.consume(n), y);
+  function contentStart(code) {
+    return initialPrefix > 0 && markdownSpace(code) ? factorySpace(effects, beforeContentChunk, "linePrefix", initialPrefix + 1)(code) : beforeContentChunk(code);
   }
-  function h(n) {
-    return e.exit("codeFenced"), m(n);
+  function beforeContentChunk(code) {
+    if (code === null || markdownLineEnding(code)) {
+      return effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);
+    }
+    effects.enter("codeFlowValue");
+    return contentChunk(code);
   }
-  function M(n, a, k) {
-    let E = 0;
-    return N;
-    function N(r) {
-      return n.enter("lineEnding"), n.consume(r), n.exit("lineEnding"), T;
+  function contentChunk(code) {
+    if (code === null || markdownLineEnding(code)) {
+      effects.exit("codeFlowValue");
+      return beforeContentChunk(code);
     }
-    function T(r) {
-      return n.enter("codeFencedFence"), x(r) ? p(n, s, "linePrefix", i.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4)(r) : s(r);
+    effects.consume(code);
+    return contentChunk;
+  }
+  function after(code) {
+    effects.exit("codeFenced");
+    return ok(code);
+  }
+  function tokenizeCloseStart(effects2, ok2, nok2) {
+    let size = 0;
+    return startBefore;
+    function startBefore(code) {
+      effects2.enter("lineEnding");
+      effects2.consume(code);
+      effects2.exit("lineEnding");
+      return start2;
     }
-    function s(r) {
-      return r === o ? (n.enter("codeFencedFenceSequence"), B(r)) : k(r);
+    function start2(code) {
+      effects2.enter("codeFencedFence");
+      return markdownSpace(code) ? factorySpace(effects2, beforeSequenceClose, "linePrefix", self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4)(code) : beforeSequenceClose(code);
     }
-    function B(r) {
-      return r === o ? (E++, n.consume(r), B) : E >= t ? (n.exit("codeFencedFenceSequence"), x(r) ? p(n, b, "whitespace")(r) : b(r)) : k(r);
+    function beforeSequenceClose(code) {
+      if (code === marker) {
+        effects2.enter("codeFencedFenceSequence");
+        return sequenceClose(code);
+      }
+      return nok2(code);
     }
-    function b(r) {
-      return r === null || u(r) ? (n.exit("codeFencedFence"), a(r)) : k(r);
+    function sequenceClose(code) {
+      if (code === marker) {
+        size++;
+        effects2.consume(code);
+        return sequenceClose;
+      }
+      if (size >= sizeOpen) {
+        effects2.exit("codeFencedFenceSequence");
+        return markdownSpace(code) ? factorySpace(effects2, sequenceCloseAfter, "whitespace")(code) : sequenceCloseAfter(code);
+      }
+      return nok2(code);
+    }
+    function sequenceCloseAfter(code) {
+      if (code === null || markdownLineEnding(code)) {
+        effects2.exit("codeFencedFence");
+        return ok2(code);
+      }
+      return nok2(code);
     }
   }
 }
-function A(e, m, l) {
-  const i = this;
-  return S;
-  function S(t) {
-    return t === null ? l(t) : (e.enter("lineEnding"), e.consume(t), e.exit("lineEnding"), c);
+function tokenizeNonLazyContinuation(effects, ok, nok) {
+  const self = this;
+  return start;
+  function start(code) {
+    if (code === null) {
+      return nok(code);
+    }
+    effects.enter("lineEnding");
+    effects.consume(code);
+    effects.exit("lineEnding");
+    return lineStart;
   }
-  function c(t) {
-    return i.parser.lazy[i.now().line] ? l(t) : m(t);
+  function lineStart(code) {
+    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);
   }
 }
 export {
-  G as codeFenced
+  codeFenced
 };
 //# sourceMappingURL=code-fenced.es.js.map

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

@@ -1 +1 @@
-{"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":["nonLazyContinuation","tokenizeNonLazyContinuation","codeFenced","tokenizeCodeFenced","effects","ok","nok","self","closeStart","tokenizeCloseStart","initialPrefix","sizeOpen","marker","start","code","beforeSequenceOpen","tail","sequenceOpen","markdownSpace","factorySpace","infoBefore","markdownLineEnding","atNonLazyBreak","after","info","metaBefore","meta","contentBefore","contentStart","beforeContentChunk","contentChunk","size","startBefore","beforeSequenceClose","sequenceClose","sequenceCloseAfter","lineStart"],"mappings":"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","x_google_ignoreList":[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":";;AAaA,MAAM,sBAAsB;AAAA,EAC1B,SAAS;AAAA,EACT,UAAU;AACZ;AAGY,MAAC,aAAa;AAAA,EACxB,UAAU;AAAA,EACV,MAAM;AAAA,EACN,UAAU;AACZ;AAOA,SAAS,mBAAmB,SAAS,IAAI,KAAK;AAC5C,QAAM,OAAO;AAEb,QAAM,aAAa;AAAA,IACjB,SAAS;AAAA,IACT,UAAU;AAAA,EACX;AACD,MAAI,gBAAgB;AACpB,MAAI,WAAW;AAEf,MAAI;AACJ,SAAO;AAcP,WAAS,MAAM,MAAM;AAEnB,WAAO,mBAAmB,IAAI;AAAA,EAClC;AAcE,WAAS,mBAAmB,MAAM;AAChC,UAAM,OAAO,KAAK,OAAO,KAAK,OAAO,SAAS,CAAC;AAC/C,oBAAgB,QAAQ,KAAK,CAAC,EAAE,SAAS,eAAe,KAAK,CAAC,EAAE,eAAe,KAAK,CAAC,GAAG,IAAI,EAAE,SAAS;AACvG,aAAS;AACT,YAAQ,MAAM,YAAY;AAC1B,YAAQ,MAAM,iBAAiB;AAC/B,YAAQ,MAAM,yBAAyB;AACvC,WAAO,aAAa,IAAI;AAAA,EAC5B;AAcE,WAAS,aAAa,MAAM;AAC1B,QAAI,SAAS,QAAQ;AACnB;AACA,cAAQ,QAAQ,IAAI;AACpB,aAAO;AAAA,IACb;AACI,QAAI,WAAW,GAAG;AAChB,aAAO,IAAI,IAAI;AAAA,IACrB;AACI,YAAQ,KAAK,yBAAyB;AACtC,WAAO,cAAc,IAAI,IAAI,aAAa,SAAS,YAAY,YAAY,EAAE,IAAI,IAAI,WAAW,IAAI;AAAA,EACxG;AAcE,WAAS,WAAW,MAAM;AACxB,QAAI,SAAS,QAAQ,mBAAmB,IAAI,GAAG;AAC7C,cAAQ,KAAK,iBAAiB;AAC9B,aAAO,KAAK,YAAY,GAAG,IAAI,IAAI,QAAQ,MAAM,qBAAqB,gBAAgB,KAAK,EAAE,IAAI;AAAA,IACvG;AACI,YAAQ,MAAM,qBAAqB;AACnC,YAAQ,MAAM,eAAe;AAAA,MAC3B,aAAa;AAAA,IACnB,CAAK;AACD,WAAO,KAAK,IAAI;AAAA,EACpB;AAcE,WAAS,KAAK,MAAM;AAClB,QAAI,SAAS,QAAQ,mBAAmB,IAAI,GAAG;AAC7C,cAAQ,KAAK,aAAa;AAC1B,cAAQ,KAAK,qBAAqB;AAClC,aAAO,WAAW,IAAI;AAAA,IAC5B;AACI,QAAI,cAAc,IAAI,GAAG;AACvB,cAAQ,KAAK,aAAa;AAC1B,cAAQ,KAAK,qBAAqB;AAClC,aAAO,aAAa,SAAS,YAAY,YAAY,EAAE,IAAI;AAAA,IACjE;AACI,QAAI,SAAS,MAAM,SAAS,QAAQ;AAClC,aAAO,IAAI,IAAI;AAAA,IACrB;AACI,YAAQ,QAAQ,IAAI;AACpB,WAAO;AAAA,EACX;AAcE,WAAS,WAAW,MAAM;AACxB,QAAI,SAAS,QAAQ,mBAAmB,IAAI,GAAG;AAC7C,aAAO,WAAW,IAAI;AAAA,IAC5B;AACI,YAAQ,MAAM,qBAAqB;AACnC,YAAQ,MAAM,eAAe;AAAA,MAC3B,aAAa;AAAA,IACnB,CAAK;AACD,WAAO,KAAK,IAAI;AAAA,EACpB;AAcE,WAAS,KAAK,MAAM;AAClB,QAAI,SAAS,QAAQ,mBAAmB,IAAI,GAAG;AAC7C,cAAQ,KAAK,aAAa;AAC1B,cAAQ,KAAK,qBAAqB;AAClC,aAAO,WAAW,IAAI;AAAA,IAC5B;AACI,QAAI,SAAS,MAAM,SAAS,QAAQ;AAClC,aAAO,IAAI,IAAI;AAAA,IACrB;AACI,YAAQ,QAAQ,IAAI;AACpB,WAAO;AAAA,EACX;AAeE,WAAS,eAAe,MAAM;AAC5B,WAAO,QAAQ,QAAQ,YAAY,OAAO,aAAa,EAAE,IAAI;AAAA,EACjE;AAcE,WAAS,cAAc,MAAM;AAC3B,YAAQ,MAAM,YAAY;AAC1B,YAAQ,QAAQ,IAAI;AACpB,YAAQ,KAAK,YAAY;AACzB,WAAO;AAAA,EACX;AAcE,WAAS,aAAa,MAAM;AAC1B,WAAO,gBAAgB,KAAK,cAAc,IAAI,IAAI,aAAa,SAAS,oBAAoB,cAAc,gBAAgB,CAAC,EAAE,IAAI,IAAI,mBAAmB,IAAI;AAAA,EAChK;AAcE,WAAS,mBAAmB,MAAM;AAChC,QAAI,SAAS,QAAQ,mBAAmB,IAAI,GAAG;AAC7C,aAAO,QAAQ,MAAM,qBAAqB,gBAAgB,KAAK,EAAE,IAAI;AAAA,IAC3E;AACI,YAAQ,MAAM,eAAe;AAC7B,WAAO,aAAa,IAAI;AAAA,EAC5B;AAcE,WAAS,aAAa,MAAM;AAC1B,QAAI,SAAS,QAAQ,mBAAmB,IAAI,GAAG;AAC7C,cAAQ,KAAK,eAAe;AAC5B,aAAO,mBAAmB,IAAI;AAAA,IACpC;AACI,YAAQ,QAAQ,IAAI;AACpB,WAAO;AAAA,EACX;AAcE,WAAS,MAAM,MAAM;AACnB,YAAQ,KAAK,YAAY;AACzB,WAAO,GAAG,IAAI;AAAA,EAClB;AAOE,WAAS,mBAAmBA,UAASC,KAAIC,MAAK;AAC5C,QAAI,OAAO;AACX,WAAO;AAOP,aAAS,YAAY,MAAM;AACzB,MAAAF,SAAQ,MAAM,YAAY;AAC1B,MAAAA,SAAQ,QAAQ,IAAI;AACpB,MAAAA,SAAQ,KAAK,YAAY;AACzB,aAAOG;AAAA,IACb;AAcI,aAASA,OAAM,MAAM;AAInB,MAAAH,SAAQ,MAAM,iBAAiB;AAC/B,aAAO,cAAc,IAAI,IAAI,aAAaA,UAAS,qBAAqB,cAAc,KAAK,OAAO,WAAW,QAAQ,KAAK,SAAS,cAAc,IAAI,SAAY,CAAC,EAAE,IAAI,IAAI,oBAAoB,IAAI;AAAA,IAC1M;AAcI,aAAS,oBAAoB,MAAM;AACjC,UAAI,SAAS,QAAQ;AACnB,QAAAA,SAAQ,MAAM,yBAAyB;AACvC,eAAO,cAAc,IAAI;AAAA,MACjC;AACM,aAAOE,KAAI,IAAI;AAAA,IACrB;AAcI,aAAS,cAAc,MAAM;AAC3B,UAAI,SAAS,QAAQ;AACnB;AACA,QAAAF,SAAQ,QAAQ,IAAI;AACpB,eAAO;AAAA,MACf;AACM,UAAI,QAAQ,UAAU;AACpB,QAAAA,SAAQ,KAAK,yBAAyB;AACtC,eAAO,cAAc,IAAI,IAAI,aAAaA,UAAS,oBAAoB,YAAY,EAAE,IAAI,IAAI,mBAAmB,IAAI;AAAA,MAC5H;AACM,aAAOE,KAAI,IAAI;AAAA,IACrB;AAcI,aAAS,mBAAmB,MAAM;AAChC,UAAI,SAAS,QAAQ,mBAAmB,IAAI,GAAG;AAC7C,QAAAF,SAAQ,KAAK,iBAAiB;AAC9B,eAAOC,IAAG,IAAI;AAAA,MACtB;AACM,aAAOC,KAAI,IAAI;AAAA,IACrB;AAAA,EACA;AACA;AAOA,SAAS,4BAA4B,SAAS,IAAI,KAAK;AACrD,QAAM,OAAO;AACb,SAAO;AAOP,WAAS,MAAM,MAAM;AACnB,QAAI,SAAS,MAAM;AACjB,aAAO,IAAI,IAAI;AAAA,IACrB;AACI,YAAQ,MAAM,YAAY;AAC1B,YAAQ,QAAQ,IAAI;AACpB,YAAQ,KAAK,YAAY;AACzB,WAAO;AAAA,EACX;AAOE,WAAS,UAAU,MAAM;AACvB,WAAO,KAAK,OAAO,KAAK,KAAK,IAAG,EAAG,IAAI,IAAI,IAAI,IAAI,IAAI,GAAG,IAAI;AAAA,EAClE;AACA;","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

@@ -1,44 +1,68 @@
-import { factorySpace as h } from "../../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js";
-import { markdownLineEnding as o } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
-const P = {
+import { factorySpace } from "../../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js";
+import { markdownLineEnding } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+const codeIndented = {
   name: "codeIndented",
-  tokenize: p
-}, m = {
-  partial: !0,
-  tokenize: d
+  tokenize: tokenizeCodeIndented
 };
-function p(e, f, l) {
-  const r = this;
-  return u;
-  function u(n) {
-    return e.enter("codeIndented"), h(e, s, "linePrefix", 5)(n);
+const furtherStart = {
+  partial: true,
+  tokenize: tokenizeFurtherStart
+};
+function tokenizeCodeIndented(effects, ok, nok) {
+  const self = this;
+  return start;
+  function start(code) {
+    effects.enter("codeIndented");
+    return factorySpace(effects, afterPrefix, "linePrefix", 4 + 1)(code);
   }
-  function s(n) {
-    const a = r.events[r.events.length - 1];
-    return a && a[1].type === "linePrefix" && a[2].sliceSerialize(a[1], !0).length >= 4 ? t(n) : l(n);
+  function afterPrefix(code) {
+    const tail = self.events[self.events.length - 1];
+    return tail && tail[1].type === "linePrefix" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? atBreak(code) : nok(code);
   }
-  function t(n) {
-    return n === null ? x(n) : o(n) ? e.attempt(m, t, x)(n) : (e.enter("codeFlowValue"), i(n));
+  function atBreak(code) {
+    if (code === null) {
+      return after(code);
+    }
+    if (markdownLineEnding(code)) {
+      return effects.attempt(furtherStart, atBreak, after)(code);
+    }
+    effects.enter("codeFlowValue");
+    return inside(code);
   }
-  function i(n) {
-    return n === null || o(n) ? (e.exit("codeFlowValue"), t(n)) : (e.consume(n), i);
+  function inside(code) {
+    if (code === null || markdownLineEnding(code)) {
+      effects.exit("codeFlowValue");
+      return atBreak(code);
+    }
+    effects.consume(code);
+    return inside;
   }
-  function x(n) {
-    return e.exit("codeIndented"), f(n);
+  function after(code) {
+    effects.exit("codeIndented");
+    return ok(code);
   }
 }
-function d(e, f, l) {
-  const r = this;
-  return u;
-  function u(t) {
-    return r.parser.lazy[r.now().line] ? l(t) : o(t) ? (e.enter("lineEnding"), e.consume(t), e.exit("lineEnding"), u) : h(e, s, "linePrefix", 5)(t);
+function tokenizeFurtherStart(effects, ok, nok) {
+  const self = this;
+  return furtherStart2;
+  function furtherStart2(code) {
+    if (self.parser.lazy[self.now().line]) {
+      return nok(code);
+    }
+    if (markdownLineEnding(code)) {
+      effects.enter("lineEnding");
+      effects.consume(code);
+      effects.exit("lineEnding");
+      return furtherStart2;
+    }
+    return factorySpace(effects, afterPrefix, "linePrefix", 4 + 1)(code);
   }
-  function s(t) {
-    const i = r.events[r.events.length - 1];
-    return i && i[1].type === "linePrefix" && i[2].sliceSerialize(i[1], !0).length >= 4 ? f(t) : o(t) ? u(t) : l(t);
+  function afterPrefix(code) {
+    const tail = self.events[self.events.length - 1];
+    return tail && tail[1].type === "linePrefix" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? ok(code) : markdownLineEnding(code) ? furtherStart2(code) : nok(code);
   }
 }
 export {
-  P as codeIndented
+  codeIndented
 };
 //# sourceMappingURL=code-indented.es.js.map

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

@@ -1 +1 @@
-{"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":["codeIndented","tokenizeCodeIndented","furtherStart","tokenizeFurtherStart","effects","ok","nok","self","start","code","factorySpace","afterPrefix","tail","atBreak","after","markdownLineEnding","inside"],"mappings":";;AAYY,MAACA,IAAe;AAAA,EAC1B,MAAM;AAAA,EACN,UAAUC;AACZ,GAGMC,IAAe;AAAA,EACnB,SAAS;AAAA,EACT,UAAUC;AACZ;AAOA,SAASF,EAAqBG,GAASC,GAAIC,GAAK;AAC9C,QAAMC,IAAO;AACb,SAAOC;AAgBP,WAASA,EAAMC,GAAM;AAGnB,WAAAL,EAAQ,MAAM,cAAc,GAGrBM,EAAaN,GAASO,GAAa,cAAc,CAAK,EAAEF,CAAI;AAAA,EACvE;AAYE,WAASE,EAAYF,GAAM;AACzB,UAAMG,IAAOL,EAAK,OAAOA,EAAK,OAAO,SAAS,CAAC;AAC/C,WAAOK,KAAQA,EAAK,CAAC,EAAE,SAAS,gBAAgBA,EAAK,CAAC,EAAE,eAAeA,EAAK,CAAC,GAAG,EAAI,EAAE,UAAU,IAAIC,EAAQJ,CAAI,IAAIH,EAAIG,CAAI;AAAA,EAChI;AAYE,WAASI,EAAQJ,GAAM;AACrB,WAAIA,MAAS,OACJK,EAAML,CAAI,IAEfM,EAAmBN,CAAI,IAClBL,EAAQ,QAAQF,GAAcW,GAASC,CAAK,EAAEL,CAAI,KAE3DL,EAAQ,MAAM,eAAe,GACtBY,EAAOP,CAAI;AAAA,EACtB;AAYE,WAASO,EAAOP,GAAM;AACpB,WAAIA,MAAS,QAAQM,EAAmBN,CAAI,KAC1CL,EAAQ,KAAK,eAAe,GACrBS,EAAQJ,CAAI,MAErBL,EAAQ,QAAQK,CAAI,GACbO;AAAA,EACX;AAGE,WAASF,EAAML,GAAM;AACnB,WAAAL,EAAQ,KAAK,cAAc,GAIpBC,EAAGI,CAAI;AAAA,EAClB;AACA;AAOA,SAASN,EAAqBC,GAASC,GAAIC,GAAK;AAC9C,QAAMC,IAAO;AACb,SAAOL;AAaP,WAASA,EAAaO,GAAM;AAG1B,WAAIF,EAAK,OAAO,KAAKA,EAAK,IAAG,EAAG,IAAI,IAC3BD,EAAIG,CAAI,IAEbM,EAAmBN,CAAI,KACzBL,EAAQ,MAAM,YAAY,GAC1BA,EAAQ,QAAQK,CAAI,GACpBL,EAAQ,KAAK,YAAY,GAClBF,KASFQ,EAAaN,GAASO,GAAa,cAAc,CAAK,EAAEF,CAAI;AAAA,EACvE;AAYE,WAASE,EAAYF,GAAM;AACzB,UAAMG,IAAOL,EAAK,OAAOA,EAAK,OAAO,SAAS,CAAC;AAC/C,WAAOK,KAAQA,EAAK,CAAC,EAAE,SAAS,gBAAgBA,EAAK,CAAC,EAAE,eAAeA,EAAK,CAAC,GAAG,EAAI,EAAE,UAAU,IAAIP,EAAGI,CAAI,IAAIM,EAAmBN,CAAI,IAAIP,EAAaO,CAAI,IAAIH,EAAIG,CAAI;AAAA,EAC3K;AACA;","x_google_ignoreList":[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

@@ -1,46 +1,117 @@
-import { markdownLineEnding as d } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
-const m = {
+import { markdownLineEnding } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+const codeText = {
   name: "codeText",
-  previous: g,
-  resolve: y,
-  tokenize: E
+  previous,
+  resolve: resolveCodeText,
+  tokenize: tokenizeCodeText
 };
-function y(e) {
-  let r = e.length - 4, u = 3, t, i;
-  if ((e[u][1].type === "lineEnding" || e[u][1].type === "space") && (e[r][1].type === "lineEnding" || e[r][1].type === "space")) {
-    for (t = u; ++t < r; )
-      if (e[t][1].type === "codeTextData") {
-        e[u][1].type = "codeTextPadding", e[r][1].type = "codeTextPadding", u += 2, r -= 2;
+function resolveCodeText(events) {
+  let tailExitIndex = events.length - 4;
+  let headEnterIndex = 3;
+  let index;
+  let enter;
+  if ((events[headEnterIndex][1].type === "lineEnding" || events[headEnterIndex][1].type === "space") && (events[tailExitIndex][1].type === "lineEnding" || events[tailExitIndex][1].type === "space")) {
+    index = headEnterIndex;
+    while (++index < tailExitIndex) {
+      if (events[index][1].type === "codeTextData") {
+        events[headEnterIndex][1].type = "codeTextPadding";
+        events[tailExitIndex][1].type = "codeTextPadding";
+        headEnterIndex += 2;
+        tailExitIndex -= 2;
         break;
       }
+    }
   }
-  for (t = u - 1, r++; ++t <= r; )
-    i === void 0 ? t !== r && e[t][1].type !== "lineEnding" && (i = t) : (t === r || e[t][1].type === "lineEnding") && (e[i][1].type = "codeTextData", t !== i + 2 && (e[i][1].end = e[t - 1][1].end, e.splice(i + 2, t - i - 2), r -= t - i - 2, t = i + 2), i = void 0);
-  return e;
+  index = headEnterIndex - 1;
+  tailExitIndex++;
+  while (++index <= tailExitIndex) {
+    if (enter === void 0) {
+      if (index !== tailExitIndex && events[index][1].type !== "lineEnding") {
+        enter = index;
+      }
+    } else if (index === tailExitIndex || events[index][1].type === "lineEnding") {
+      events[enter][1].type = "codeTextData";
+      if (index !== enter + 2) {
+        events[enter][1].end = events[index - 1][1].end;
+        events.splice(enter + 2, index - enter - 2);
+        tailExitIndex -= index - enter - 2;
+        index = enter + 2;
+      }
+      enter = void 0;
+    }
+  }
+  return events;
 }
-function g(e) {
-  return e !== 96 || this.events[this.events.length - 1][1].type === "characterEscape";
+function previous(code) {
+  return code !== 96 || this.events[this.events.length - 1][1].type === "characterEscape";
 }
-function E(e, r, u) {
-  let t = 0, i, l;
-  return T;
-  function T(n) {
-    return e.enter("codeText"), e.enter("codeTextSequence"), o(n);
+function tokenizeCodeText(effects, ok, nok) {
+  let sizeOpen = 0;
+  let size;
+  let token;
+  return start;
+  function start(code) {
+    effects.enter("codeText");
+    effects.enter("codeTextSequence");
+    return sequenceOpen(code);
   }
-  function o(n) {
-    return n === 96 ? (e.consume(n), t++, o) : (e.exit("codeTextSequence"), x(n));
+  function sequenceOpen(code) {
+    if (code === 96) {
+      effects.consume(code);
+      sizeOpen++;
+      return sequenceOpen;
+    }
+    effects.exit("codeTextSequence");
+    return between(code);
   }
-  function x(n) {
-    return n === null ? u(n) : n === 32 ? (e.enter("space"), e.consume(n), e.exit("space"), x) : n === 96 ? (l = e.enter("codeTextSequence"), i = 0, p(n)) : d(n) ? (e.enter("lineEnding"), e.consume(n), e.exit("lineEnding"), x) : (e.enter("codeTextData"), a(n));
+  function between(code) {
+    if (code === null) {
+      return nok(code);
+    }
+    if (code === 32) {
+      effects.enter("space");
+      effects.consume(code);
+      effects.exit("space");
+      return between;
+    }
+    if (code === 96) {
+      token = effects.enter("codeTextSequence");
+      size = 0;
+      return sequenceClose(code);
+    }
+    if (markdownLineEnding(code)) {
+      effects.enter("lineEnding");
+      effects.consume(code);
+      effects.exit("lineEnding");
+      return between;
+    }
+    effects.enter("codeTextData");
+    return data(code);
   }
-  function a(n) {
-    return n === null || n === 32 || n === 96 || d(n) ? (e.exit("codeTextData"), x(n)) : (e.consume(n), a);
+  function data(code) {
+    if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {
+      effects.exit("codeTextData");
+      return between(code);
+    }
+    effects.consume(code);
+    return data;
   }
-  function p(n) {
-    return n === 96 ? (e.consume(n), i++, p) : i === t ? (e.exit("codeTextSequence"), e.exit("codeText"), r(n)) : (l.type = "codeTextData", a(n));
+  function sequenceClose(code) {
+    if (code === 96) {
+      effects.consume(code);
+      size++;
+      return sequenceClose;
+    }
+    if (size === sizeOpen) {
+      effects.exit("codeTextSequence");
+      effects.exit("codeText");
+      return ok(code);
+    }
+    token.type = "codeTextData";
+    return data(code);
   }
 }
 export {
-  m as codeText
+  codeText
 };
 //# sourceMappingURL=code-text.es.js.map