@easyv/biz-components 1.0.28 → 1.0.30

package/dist/lib/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/block-quote.es.js

@@ -0,0 +1,62 @@
+import { factorySpace } from "../../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js";
+import { markdownSpace } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+const blockQuote = {
+  continuation: {
+    tokenize: tokenizeBlockQuoteContinuation
+  },
+  exit,
+  name: "blockQuote",
+  tokenize: tokenizeBlockQuoteStart
+};
+function tokenizeBlockQuoteStart(effects, ok, nok) {
+  const self = this;
+  return start;
+  function start(code) {
+    if (code === 62) {
+      const state = self.containerState;
+      if (!state.open) {
+        effects.enter("blockQuote", {
+          _container: true
+        });
+        state.open = true;
+      }
+      effects.enter("blockQuotePrefix");
+      effects.enter("blockQuoteMarker");
+      effects.consume(code);
+      effects.exit("blockQuoteMarker");
+      return after;
+    }
+    return nok(code);
+  }
+  function after(code) {
+    if (markdownSpace(code)) {
+      effects.enter("blockQuotePrefixWhitespace");
+      effects.consume(code);
+      effects.exit("blockQuotePrefixWhitespace");
+      effects.exit("blockQuotePrefix");
+      return ok;
+    }
+    effects.exit("blockQuotePrefix");
+    return ok(code);
+  }
+}
+function tokenizeBlockQuoteContinuation(effects, ok, nok) {
+  const self = this;
+  return contStart;
+  function contStart(code) {
+    if (markdownSpace(code)) {
+      return factorySpace(effects, contBefore, "linePrefix", self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4)(code);
+    }
+    return contBefore(code);
+  }
+  function contBefore(code) {
+    return effects.attempt(blockQuote, ok, nok)(code);
+  }
+}
+function exit(effects) {
+  effects.exit("blockQuote");
+}
+export {
+  blockQuote
+};
+//# sourceMappingURL=block-quote.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"block-quote.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/block-quote.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   Exiter,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blockQuote = {\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit,\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of block quote.\n   *\n   * ```markdown\n   * > | > a\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 62) {\n      const state = self.containerState;\n      if (!state.open) {\n        effects.enter(\"blockQuote\", {\n          _container: true\n        });\n        state.open = true;\n      }\n      effects.enter(\"blockQuotePrefix\");\n      effects.enter(\"blockQuoteMarker\");\n      effects.consume(code);\n      effects.exit(\"blockQuoteMarker\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `>`, before optional whitespace.\n   *\n   * ```markdown\n   * > | > a\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter(\"blockQuotePrefixWhitespace\");\n      effects.consume(code);\n      effects.exit(\"blockQuotePrefixWhitespace\");\n      effects.exit(\"blockQuotePrefix\");\n      return ok;\n    }\n    effects.exit(\"blockQuotePrefix\");\n    return ok(code);\n  }\n}\n\n/**\n * Start of block quote continuation.\n *\n * ```markdown\n *   | > a\n * > | > b\n *     ^\n * ```\n *\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  const self = this;\n  return contStart;\n\n  /**\n   * Start of block quote continuation.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contStart(code) {\n    if (markdownSpace(code)) {\n      // Always populated by defaults.\n\n      return factorySpace(effects, contBefore, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n    }\n    return contBefore(code);\n  }\n\n  /**\n   * At `>`, after optional whitespace.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contBefore(code) {\n    return effects.attempt(blockQuote, ok, nok)(code);\n  }\n}\n\n/** @type {Exiter} */\nfunction exit(effects) {\n  effects.exit(\"blockQuote\");\n}"],"names":[],"mappings":";;AAaY,MAAC,aAAa;AAAA,EACxB,cAAc;AAAA,IACZ,UAAU;AAAA,EACX;AAAA,EACD;AAAA,EACA,MAAM;AAAA,EACN,UAAU;AACZ;AAOA,SAAS,wBAAwB,SAAS,IAAI,KAAK;AACjD,QAAM,OAAO;AACb,SAAO;AAYP,WAAS,MAAM,MAAM;AACnB,QAAI,SAAS,IAAI;AACf,YAAM,QAAQ,KAAK;AACnB,UAAI,CAAC,MAAM,MAAM;AACf,gBAAQ,MAAM,cAAc;AAAA,UAC1B,YAAY;AAAA,QACtB,CAAS;AACD,cAAM,OAAO;AAAA,MACrB;AACM,cAAQ,MAAM,kBAAkB;AAChC,cAAQ,MAAM,kBAAkB;AAChC,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,kBAAkB;AAC/B,aAAO;AAAA,IACb;AACI,WAAO,IAAI,IAAI;AAAA,EACnB;AAYE,WAAS,MAAM,MAAM;AACnB,QAAI,cAAc,IAAI,GAAG;AACvB,cAAQ,MAAM,4BAA4B;AAC1C,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,4BAA4B;AACzC,cAAQ,KAAK,kBAAkB;AAC/B,aAAO;AAAA,IACb;AACI,YAAQ,KAAK,kBAAkB;AAC/B,WAAO,GAAG,IAAI;AAAA,EAClB;AACA;AAeA,SAAS,+BAA+B,SAAS,IAAI,KAAK;AACxD,QAAM,OAAO;AACb,SAAO;AAeP,WAAS,UAAU,MAAM;AACvB,QAAI,cAAc,IAAI,GAAG;AAGvB,aAAO,aAAa,SAAS,YAAY,cAAc,KAAK,OAAO,WAAW,QAAQ,KAAK,SAAS,cAAc,IAAI,SAAY,CAAC,EAAE,IAAI;AAAA,IAC/I;AACI,WAAO,WAAW,IAAI;AAAA,EAC1B;AAeE,WAAS,WAAW,MAAM;AACxB,WAAO,QAAQ,QAAQ,YAAY,IAAI,GAAG,EAAE,IAAI;AAAA,EACpD;AACA;AAGA,SAAS,KAAK,SAAS;AACrB,UAAQ,KAAK,YAAY;AAC3B;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,29 @@
+import { asciiPunctuation } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+const characterEscape = {
+  name: "characterEscape",
+  tokenize: tokenizeCharacterEscape
+};
+function tokenizeCharacterEscape(effects, ok, nok) {
+  return start;
+  function start(code) {
+    effects.enter("characterEscape");
+    effects.enter("escapeMarker");
+    effects.consume(code);
+    effects.exit("escapeMarker");
+    return inside;
+  }
+  function inside(code) {
+    if (asciiPunctuation(code)) {
+      effects.enter("characterEscapeValue");
+      effects.consume(code);
+      effects.exit("characterEscapeValue");
+      effects.exit("characterEscape");
+      return ok;
+    }
+    return nok(code);
+  }
+}
+export {
+  characterEscape
+};
+//# sourceMappingURL=character-escape.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"character-escape.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/character-escape.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiPunctuation } from 'micromark-util-character';\n/** @type {Construct} */\nexport const characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of character escape.\n   *\n   * ```markdown\n   * > | a\\*b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"characterEscape\");\n    effects.enter(\"escapeMarker\");\n    effects.consume(code);\n    effects.exit(\"escapeMarker\");\n    return inside;\n  }\n\n  /**\n   * After `\\`, at punctuation.\n   *\n   * ```markdown\n   * > | a\\*b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    // ASCII punctuation.\n    if (asciiPunctuation(code)) {\n      effects.enter(\"characterEscapeValue\");\n      effects.consume(code);\n      effects.exit(\"characterEscapeValue\");\n      effects.exit(\"characterEscape\");\n      return ok;\n    }\n    return nok(code);\n  }\n}"],"names":[],"mappings":";AAWY,MAAC,kBAAkB;AAAA,EAC7B,MAAM;AAAA,EACN,UAAU;AACZ;AAOA,SAAS,wBAAwB,SAAS,IAAI,KAAK;AACjD,SAAO;AAYP,WAAS,MAAM,MAAM;AACnB,YAAQ,MAAM,iBAAiB;AAC/B,YAAQ,MAAM,cAAc;AAC5B,YAAQ,QAAQ,IAAI;AACpB,YAAQ,KAAK,cAAc;AAC3B,WAAO;AAAA,EACX;AAYE,WAAS,OAAO,MAAM;AAEpB,QAAI,iBAAiB,IAAI,GAAG;AAC1B,cAAQ,MAAM,sBAAsB;AACpC,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,sBAAsB;AACnC,cAAQ,KAAK,iBAAiB;AAC9B,aAAO;AAAA,IACb;AACI,WAAO,IAAI,IAAI;AAAA,EACnB;AACA;","x_google_ignoreList":[0]}

package/dist/lib/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/character-reference.es.js

@@ -0,0 +1,69 @@
+import { decodeNamedCharacterReference } from "../../../../decode-named-character-reference@1.1.0/node_modules/decode-named-character-reference/index.dom.es.js";
+import { asciiAlphanumeric, asciiHexDigit, asciiDigit } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+const characterReference = {
+  name: "characterReference",
+  tokenize: tokenizeCharacterReference
+};
+function tokenizeCharacterReference(effects, ok, nok) {
+  const self = this;
+  let size = 0;
+  let max;
+  let test;
+  return start;
+  function start(code) {
+    effects.enter("characterReference");
+    effects.enter("characterReferenceMarker");
+    effects.consume(code);
+    effects.exit("characterReferenceMarker");
+    return open;
+  }
+  function open(code) {
+    if (code === 35) {
+      effects.enter("characterReferenceMarkerNumeric");
+      effects.consume(code);
+      effects.exit("characterReferenceMarkerNumeric");
+      return numeric;
+    }
+    effects.enter("characterReferenceValue");
+    max = 31;
+    test = asciiAlphanumeric;
+    return value(code);
+  }
+  function numeric(code) {
+    if (code === 88 || code === 120) {
+      effects.enter("characterReferenceMarkerHexadecimal");
+      effects.consume(code);
+      effects.exit("characterReferenceMarkerHexadecimal");
+      effects.enter("characterReferenceValue");
+      max = 6;
+      test = asciiHexDigit;
+      return value;
+    }
+    effects.enter("characterReferenceValue");
+    max = 7;
+    test = asciiDigit;
+    return value(code);
+  }
+  function value(code) {
+    if (code === 59 && size) {
+      const token = effects.exit("characterReferenceValue");
+      if (test === asciiAlphanumeric && !decodeNamedCharacterReference(self.sliceSerialize(token))) {
+        return nok(code);
+      }
+      effects.enter("characterReferenceMarker");
+      effects.consume(code);
+      effects.exit("characterReferenceMarker");
+      effects.exit("characterReference");
+      return ok;
+    }
+    if (test(code) && size++ < max) {
+      effects.consume(code);
+      return value;
+    }
+    return nok(code);
+  }
+}
+export {
+  characterReference
+};
+//# sourceMappingURL=character-reference.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"character-reference.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/character-reference.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { asciiAlphanumeric, asciiDigit, asciiHexDigit } from 'micromark-util-character';\n/** @type {Construct} */\nexport const characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  const self = this;\n  let size = 0;\n  /** @type {number} */\n  let max;\n  /** @type {(code: Code) => boolean} */\n  let test;\n  return start;\n\n  /**\n   * Start of character reference.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *      ^\n   * > | a&#123;b\n   *      ^\n   * > | a&#x9;b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"characterReference\");\n    effects.enter(\"characterReferenceMarker\");\n    effects.consume(code);\n    effects.exit(\"characterReferenceMarker\");\n    return open;\n  }\n\n  /**\n   * After `&`, at `#` for numeric references or alphanumeric for named\n   * references.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^\n   * > | a&#123;b\n   *       ^\n   * > | a&#x9;b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 35) {\n      effects.enter(\"characterReferenceMarkerNumeric\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarkerNumeric\");\n      return numeric;\n    }\n    effects.enter(\"characterReferenceValue\");\n    max = 31;\n    test = asciiAlphanumeric;\n    return value(code);\n  }\n\n  /**\n   * After `#`, at `x` for hexadecimals or digit for decimals.\n   *\n   * ```markdown\n   * > | a&#123;b\n   *        ^\n   * > | a&#x9;b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter(\"characterReferenceMarkerHexadecimal\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarkerHexadecimal\");\n      effects.enter(\"characterReferenceValue\");\n      max = 6;\n      test = asciiHexDigit;\n      return value;\n    }\n    effects.enter(\"characterReferenceValue\");\n    max = 7;\n    test = asciiDigit;\n    return value(code);\n  }\n\n  /**\n   * After markers (`&#x`, `&#`, or `&`), in value, before `;`.\n   *\n   * The character reference kind defines what and how many characters are\n   * allowed.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^^^\n   * > | a&#123;b\n   *        ^^^\n   * > | a&#x9;b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function value(code) {\n    if (code === 59 && size) {\n      const token = effects.exit(\"characterReferenceValue\");\n      if (test === asciiAlphanumeric && !decodeNamedCharacterReference(self.sliceSerialize(token))) {\n        return nok(code);\n      }\n\n      // To do: `markdown-rs` uses a different name:\n      // `CharacterReferenceMarkerSemi`.\n      effects.enter(\"characterReferenceMarker\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarker\");\n      effects.exit(\"characterReference\");\n      return ok;\n    }\n    if (test(code) && size++ < max) {\n      effects.consume(code);\n      return value;\n    }\n    return nok(code);\n  }\n}"],"names":[],"mappings":";;AAaY,MAAC,qBAAqB;AAAA,EAChC,MAAM;AAAA,EACN,UAAU;AACZ;AAOA,SAAS,2BAA2B,SAAS,IAAI,KAAK;AACpD,QAAM,OAAO;AACb,MAAI,OAAO;AAEX,MAAI;AAEJ,MAAI;AACJ,SAAO;AAgBP,WAAS,MAAM,MAAM;AACnB,YAAQ,MAAM,oBAAoB;AAClC,YAAQ,MAAM,0BAA0B;AACxC,YAAQ,QAAQ,IAAI;AACpB,YAAQ,KAAK,0BAA0B;AACvC,WAAO;AAAA,EACX;AAiBE,WAAS,KAAK,MAAM;AAClB,QAAI,SAAS,IAAI;AACf,cAAQ,MAAM,iCAAiC;AAC/C,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,iCAAiC;AAC9C,aAAO;AAAA,IACb;AACI,YAAQ,MAAM,yBAAyB;AACvC,UAAM;AACN,WAAO;AACP,WAAO,MAAM,IAAI;AAAA,EACrB;AAcE,WAAS,QAAQ,MAAM;AACrB,QAAI,SAAS,MAAM,SAAS,KAAK;AAC/B,cAAQ,MAAM,qCAAqC;AACnD,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,qCAAqC;AAClD,cAAQ,MAAM,yBAAyB;AACvC,YAAM;AACN,aAAO;AACP,aAAO;AAAA,IACb;AACI,YAAQ,MAAM,yBAAyB;AACvC,UAAM;AACN,WAAO;AACP,WAAO,MAAM,IAAI;AAAA,EACrB;AAmBE,WAAS,MAAM,MAAM;AACnB,QAAI,SAAS,MAAM,MAAM;AACvB,YAAM,QAAQ,QAAQ,KAAK,yBAAyB;AACpD,UAAI,SAAS,qBAAqB,CAAC,8BAA8B,KAAK,eAAe,KAAK,CAAC,GAAG;AAC5F,eAAO,IAAI,IAAI;AAAA,MACvB;AAIM,cAAQ,MAAM,0BAA0B;AACxC,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,0BAA0B;AACvC,cAAQ,KAAK,oBAAoB;AACjC,aAAO;AAAA,IACb;AACI,QAAI,KAAK,IAAI,KAAK,SAAS,KAAK;AAC9B,cAAQ,QAAQ,IAAI;AACpB,aAAO;AAAA,IACb;AACI,WAAO,IAAI,IAAI;AAAA,EACnB;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,187 @@
+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: tokenizeCodeFenced
+};
+function tokenizeCodeFenced(effects, ok, nok) {
+  const self = this;
+  const closeStart = {
+    partial: true,
+    tokenize: tokenizeCloseStart
+  };
+  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 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"
+    });
+    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 metaBefore(code) {
+    if (code === null || markdownLineEnding(code)) {
+      return infoBefore(code);
+    }
+    effects.enter("codeFencedFenceMeta");
+    effects.enter("chunkString", {
+      contentType: "string"
+    });
+    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 atNonLazyBreak(code) {
+    return effects.attempt(closeStart, after, contentBefore)(code);
+  }
+  function contentBefore(code) {
+    effects.enter("lineEnding");
+    effects.consume(code);
+    effects.exit("lineEnding");
+    return contentStart;
+  }
+  function contentStart(code) {
+    return initialPrefix > 0 && markdownSpace(code) ? factorySpace(effects, beforeContentChunk, "linePrefix", initialPrefix + 1)(code) : beforeContentChunk(code);
+  }
+  function beforeContentChunk(code) {
+    if (code === null || markdownLineEnding(code)) {
+      return effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);
+    }
+    effects.enter("codeFlowValue");
+    return contentChunk(code);
+  }
+  function contentChunk(code) {
+    if (code === null || markdownLineEnding(code)) {
+      effects.exit("codeFlowValue");
+      return beforeContentChunk(code);
+    }
+    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 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 beforeSequenceClose(code) {
+      if (code === marker) {
+        effects2.enter("codeFencedFenceSequence");
+        return sequenceClose(code);
+      }
+      return nok2(code);
+    }
+    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 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 lineStart(code) {
+    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);
+  }
+}
+export {
+  codeFenced
+};
+//# sourceMappingURL=code-fenced.es.js.map

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

@@ -0,0 +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":["effects","ok","nok","start"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -0,0 +1,68 @@
+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: tokenizeCodeIndented
+};
+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 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 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 inside(code) {
+    if (code === null || markdownLineEnding(code)) {
+      effects.exit("codeFlowValue");
+      return atBreak(code);
+    }
+    effects.consume(code);
+    return inside;
+  }
+  function after(code) {
+    effects.exit("codeIndented");
+    return ok(code);
+  }
+}
+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 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 {
+  codeIndented
+};
+//# sourceMappingURL=code-indented.es.js.map

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

@@ -0,0 +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":["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/lib/node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-text.es.js

@@ -0,0 +1,117 @@
+import { markdownLineEnding } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+const codeText = {
+  name: "codeText",
+  previous,
+  resolve: resolveCodeText,
+  tokenize: tokenizeCodeText
+};
+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;
+      }
+    }
+  }
+  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 previous(code) {
+  return code !== 96 || this.events[this.events.length - 1][1].type === "characterEscape";
+}
+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 sequenceOpen(code) {
+    if (code === 96) {
+      effects.consume(code);
+      sizeOpen++;
+      return sequenceOpen;
+    }
+    effects.exit("codeTextSequence");
+    return between(code);
+  }
+  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 data(code) {
+    if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {
+      effects.exit("codeTextData");
+      return between(code);
+    }
+    effects.consume(code);
+    return data;
+  }
+  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 {
+  codeText
+};
+//# sourceMappingURL=code-text.es.js.map

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

@@ -0,0 +1 @@
+{"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]}