@easyv/biz-components 0.0.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"attention.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/attention.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   Construct,\n *   Event,\n *   Point,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { push, splice } from 'micromark-util-chunked';\nimport { classifyCharacter } from 'micromark-util-classify-character';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/** @type {Construct} */\nexport const attention = {\n  name: 'attention',\n  resolveAll: resolveAllAttention,\n  tokenize: tokenizeAttention\n};\n\n/**\n * Take all events and resolve attention to emphasis or strong.\n *\n * @type {Resolver}\n */\n// eslint-disable-next-line complexity\nfunction resolveAllAttention(events, context) {\n  let index = -1;\n  /** @type {number} */\n  let open;\n  /** @type {Token} */\n  let group;\n  /** @type {Token} */\n  let text;\n  /** @type {Token} */\n  let openingSequence;\n  /** @type {Token} */\n  let closingSequence;\n  /** @type {number} */\n  let use;\n  /** @type {Array<Event>} */\n  let nextEvents;\n  /** @type {number} */\n  let offset;\n\n  // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it’s\n  // a bottleneck for malicious stuff.\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (events[index][0] === 'enter' && events[index][1].type === 'attentionSequence' && events[index][1]._close) {\n      open = index;\n\n      // Now walk back to find an opener.\n      while (open--) {\n        // Find a token that can open the closer.\n        if (events[open][0] === 'exit' && events[open][1].type === 'attentionSequence' && events[open][1]._open &&\n        // If the markers are the same:\n        context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {\n          // If the opening can close or the closing can open,\n          // and the close size *is not* a multiple of three,\n          // but the sum of the opening and closing size *is* multiple of three,\n          // then don’t match.\n          if ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) {\n            continue;\n          }\n\n          // Number of markers to use from the sequence.\n          use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1;\n          const start = {\n            ...events[open][1].end\n          };\n          const end = {\n            ...events[index][1].start\n          };\n          movePoint(start, -use);\n          movePoint(end, use);\n          openingSequence = {\n            type: use > 1 ? \"strongSequence\" : \"emphasisSequence\",\n            start,\n            end: {\n              ...events[open][1].end\n            }\n          };\n          closingSequence = {\n            type: use > 1 ? \"strongSequence\" : \"emphasisSequence\",\n            start: {\n              ...events[index][1].start\n            },\n            end\n          };\n          text = {\n            type: use > 1 ? \"strongText\" : \"emphasisText\",\n            start: {\n              ...events[open][1].end\n            },\n            end: {\n              ...events[index][1].start\n            }\n          };\n          group = {\n            type: use > 1 ? \"strong\" : \"emphasis\",\n            start: {\n              ...openingSequence.start\n            },\n            end: {\n              ...closingSequence.end\n            }\n          };\n          events[open][1].end = {\n            ...openingSequence.start\n          };\n          events[index][1].start = {\n            ...closingSequence.end\n          };\n          nextEvents = [];\n\n          // If there are more markers in the opening, add them before.\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = push(nextEvents, [['enter', events[open][1], context], ['exit', events[open][1], context]]);\n          }\n\n          // Opening.\n          nextEvents = push(nextEvents, [['enter', group, context], ['enter', openingSequence, context], ['exit', openingSequence, context], ['enter', text, context]]);\n\n          // Always populated by defaults.\n\n          // Between.\n          nextEvents = push(nextEvents, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context));\n\n          // Closing.\n          nextEvents = push(nextEvents, [['exit', text, context], ['enter', closingSequence, context], ['exit', closingSequence, context], ['exit', group, context]]);\n\n          // If there are more markers in the closing, add them after.\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2;\n            nextEvents = push(nextEvents, [['enter', events[index][1], context], ['exit', events[index][1], context]]);\n          } else {\n            offset = 0;\n          }\n          splice(events, open - 1, index - open + 3, nextEvents);\n          index = open + nextEvents.length - offset - 2;\n          break;\n        }\n      }\n    }\n  }\n\n  // Remove remaining sequences.\n  index = -1;\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data';\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeAttention(effects, ok) {\n  const attentionMarkers = this.parser.constructs.attentionMarkers.null;\n  const previous = this.previous;\n  const before = classifyCharacter(previous);\n\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Before a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    marker = code;\n    effects.enter('attentionSequence');\n    return inside(code);\n  }\n\n  /**\n   * In a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return inside;\n    }\n    const token = effects.exit('attentionSequence');\n\n    // To do: next major: move this to resolver, just like `markdown-rs`.\n    const after = classifyCharacter(code);\n\n    // Always populated by defaults.\n\n    const open = !after || after === 2 && before || attentionMarkers.includes(code);\n    const close = !before || before === 2 && after || attentionMarkers.includes(previous);\n    token._open = Boolean(marker === 42 ? open : open && (before || !close));\n    token._close = Boolean(marker === 42 ? close : close && (after || !open));\n    return ok(code);\n  }\n}\n\n/**\n * Move a point a bit.\n *\n * Note: `move` only works inside lines! It’s not possible to move past other\n * chunks (replacement characters, tabs, or line endings).\n *\n * @param {Point} point\n *   Point.\n * @param {number} offset\n *   Amount to move.\n * @returns {undefined}\n *   Nothing.\n */\nfunction movePoint(point, offset) {\n  point.column += offset;\n  point.offset += offset;\n  point._bufferIndex += offset;\n}"],"names":["attention","resolveAllAttention","tokenizeAttention","events","context","index","open","group","text","openingSequence","closingSequence","use","nextEvents","offset","start","end","movePoint","push","resolveAll","splice","effects","ok","attentionMarkers","previous","before","classifyCharacter","marker","code","inside","token","after","close","point"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -0,0 +1,44 @@
+import { asciiAlpha as z, asciiAlphanumeric as a, asciiControl as E, asciiAtext as O } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+const b = {
+  name: "autolink",
+  tokenize: P
+};
+function P(r, l, t) {
+  let i = 0;
+  return p;
+  function p(n) {
+    return r.enter("autolink"), r.enter("autolinkMarker"), r.consume(n), r.exit("autolinkMarker"), r.enter("autolinkProtocol"), M;
+  }
+  function M(n) {
+    return z(n) ? (r.consume(n), h) : n === 64 ? t(n) : u(n);
+  }
+  function h(n) {
+    return n === 43 || n === 45 || n === 46 || a(n) ? (i = 1, m(n)) : u(n);
+  }
+  function m(n) {
+    return n === 58 ? (r.consume(n), i = 0, k) : (n === 43 || n === 45 || n === 46 || a(n)) && i++ < 32 ? (r.consume(n), m) : (i = 0, u(n));
+  }
+  function k(n) {
+    return n === 62 ? (r.exit("autolinkProtocol"), r.enter("autolinkMarker"), r.consume(n), r.exit("autolinkMarker"), r.exit("autolink"), l) : n === null || n === 32 || n === 60 || E(n) ? t(n) : (r.consume(n), k);
+  }
+  function u(n) {
+    return n === 64 ? (r.consume(n), o) : O(n) ? (r.consume(n), u) : t(n);
+  }
+  function o(n) {
+    return a(n) ? x(n) : t(n);
+  }
+  function x(n) {
+    return n === 46 ? (r.consume(n), i = 0, o) : n === 62 ? (r.exit("autolinkProtocol").type = "autolinkEmail", r.enter("autolinkMarker"), r.consume(n), r.exit("autolinkMarker"), r.exit("autolink"), l) : A(n);
+  }
+  function A(n) {
+    if ((n === 45 || a(n)) && i++ < 63) {
+      const e = n === 45 ? A : x;
+      return r.consume(n), e;
+    }
+    return t(n);
+  }
+}
+export {
+  b as autolink
+};
+//# sourceMappingURL=autolink.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"autolink.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/autolink.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiAlphanumeric, asciiAlpha, asciiAtext, asciiControl } from 'micromark-util-character';\n/** @type {Construct} */\nexport const autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeAutolink(effects, ok, nok) {\n  let size = 0;\n  return start;\n\n  /**\n   * Start of an autolink.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *      ^\n   * > | a<user@example.com>b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"autolink\");\n    effects.enter(\"autolinkMarker\");\n    effects.consume(code);\n    effects.exit(\"autolinkMarker\");\n    effects.enter(\"autolinkProtocol\");\n    return open;\n  }\n\n  /**\n   * After `<`, at protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *       ^\n   * > | a<user@example.com>b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return schemeOrEmailAtext;\n    }\n    if (code === 64) {\n      return nok(code);\n    }\n    return emailAtext(code);\n  }\n\n  /**\n   * At second byte of protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeOrEmailAtext(code) {\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) {\n      // Count the previous alphabetical from `open` too.\n      size = 1;\n      return schemeInsideOrEmailAtext(code);\n    }\n    return emailAtext(code);\n  }\n\n  /**\n   * In ambiguous protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code);\n      size = 0;\n      return urlInside;\n    }\n\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) {\n      effects.consume(code);\n      return schemeInsideOrEmailAtext;\n    }\n    size = 0;\n    return emailAtext(code);\n  }\n\n  /**\n   * After protocol, in URL.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit(\"autolinkProtocol\");\n      effects.enter(\"autolinkMarker\");\n      effects.consume(code);\n      effects.exit(\"autolinkMarker\");\n      effects.exit(\"autolink\");\n      return ok;\n    }\n\n    // ASCII control, space, or `<`.\n    if (code === null || code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return urlInside;\n  }\n\n  /**\n   * In email atext.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code);\n      return emailAtSignOrDot;\n    }\n    if (asciiAtext(code)) {\n      effects.consume(code);\n      return emailAtext;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In label, after at-sign or dot.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                 ^       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code);\n  }\n\n  /**\n   * In label, where `.` and `>` are allowed.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n    if (code === 62) {\n      // Exit, then change the token type.\n      effects.exit(\"autolinkProtocol\").type = \"autolinkEmail\";\n      effects.enter(\"autolinkMarker\");\n      effects.consume(code);\n      effects.exit(\"autolinkMarker\");\n      effects.exit(\"autolink\");\n      return ok;\n    }\n    return emailValue(code);\n  }\n\n  /**\n   * In label, where `.` and `>` are *not* allowed.\n   *\n   * Though, this is also used in `emailLabel` to parse other values.\n   *\n   * ```markdown\n   * > | a<user.name@ex-ample.com>b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailValue(code) {\n    // ASCII alphanumeric or `-`.\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      const next = code === 45 ? emailValue : emailLabel;\n      effects.consume(code);\n      return next;\n    }\n    return nok(code);\n  }\n}"],"names":["autolink","tokenizeAutolink","effects","ok","nok","size","start","code","open","asciiAlpha","schemeOrEmailAtext","emailAtext","asciiAlphanumeric","schemeInsideOrEmailAtext","urlInside","asciiControl","emailAtSignOrDot","asciiAtext","emailLabel","emailValue","next"],"mappings":";AAWY,MAACA,IAAW;AAAA,EACtB,MAAM;AAAA,EACN,UAAUC;AACZ;AAOA,SAASA,EAAiBC,GAASC,GAAIC,GAAK;AAC1C,MAAIC,IAAO;AACX,SAAOC;AAcP,WAASA,EAAMC,GAAM;AACnB,WAAAL,EAAQ,MAAM,UAAU,GACxBA,EAAQ,MAAM,gBAAgB,GAC9BA,EAAQ,QAAQK,CAAI,GACpBL,EAAQ,KAAK,gBAAgB,GAC7BA,EAAQ,MAAM,kBAAkB,GACzBM;AAAA,EACX;AAcE,WAASA,EAAKD,GAAM;AAClB,WAAIE,EAAWF,CAAI,KACjBL,EAAQ,QAAQK,CAAI,GACbG,KAELH,MAAS,KACJH,EAAIG,CAAI,IAEVI,EAAWJ,CAAI;AAAA,EAC1B;AAcE,WAASG,EAAmBH,GAAM;AAEhC,WAAIA,MAAS,MAAMA,MAAS,MAAMA,MAAS,MAAMK,EAAkBL,CAAI,KAErEF,IAAO,GACAQ,EAAyBN,CAAI,KAE/BI,EAAWJ,CAAI;AAAA,EAC1B;AAcE,WAASM,EAAyBN,GAAM;AACtC,WAAIA,MAAS,MACXL,EAAQ,QAAQK,CAAI,GACpBF,IAAO,GACAS,MAIJP,MAAS,MAAMA,MAAS,MAAMA,MAAS,MAAMK,EAAkBL,CAAI,MAAMF,MAAS,MACrFH,EAAQ,QAAQK,CAAI,GACbM,MAETR,IAAO,GACAM,EAAWJ,CAAI;AAAA,EAC1B;AAYE,WAASO,EAAUP,GAAM;AACvB,WAAIA,MAAS,MACXL,EAAQ,KAAK,kBAAkB,GAC/BA,EAAQ,MAAM,gBAAgB,GAC9BA,EAAQ,QAAQK,CAAI,GACpBL,EAAQ,KAAK,gBAAgB,GAC7BA,EAAQ,KAAK,UAAU,GAChBC,KAILI,MAAS,QAAQA,MAAS,MAAMA,MAAS,MAAMQ,EAAaR,CAAI,IAC3DH,EAAIG,CAAI,KAEjBL,EAAQ,QAAQK,CAAI,GACbO;AAAA,EACX;AAYE,WAASH,EAAWJ,GAAM;AACxB,WAAIA,MAAS,MACXL,EAAQ,QAAQK,CAAI,GACbS,KAELC,EAAWV,CAAI,KACjBL,EAAQ,QAAQK,CAAI,GACbI,KAEFP,EAAIG,CAAI;AAAA,EACnB;AAYE,WAASS,EAAiBT,GAAM;AAC9B,WAAOK,EAAkBL,CAAI,IAAIW,EAAWX,CAAI,IAAIH,EAAIG,CAAI;AAAA,EAChE;AAYE,WAASW,EAAWX,GAAM;AACxB,WAAIA,MAAS,MACXL,EAAQ,QAAQK,CAAI,GACpBF,IAAO,GACAW,KAELT,MAAS,MAEXL,EAAQ,KAAK,kBAAkB,EAAE,OAAO,iBACxCA,EAAQ,MAAM,gBAAgB,GAC9BA,EAAQ,QAAQK,CAAI,GACpBL,EAAQ,KAAK,gBAAgB,GAC7BA,EAAQ,KAAK,UAAU,GAChBC,KAEFgB,EAAWZ,CAAI;AAAA,EAC1B;AAcE,WAASY,EAAWZ,GAAM;AAExB,SAAKA,MAAS,MAAMK,EAAkBL,CAAI,MAAMF,MAAS,IAAI;AAC3D,YAAMe,IAAOb,MAAS,KAAKY,IAAaD;AACxC,aAAAhB,EAAQ,QAAQK,CAAI,GACba;AAAA,IACb;AACI,WAAOhB,EAAIG,CAAI;AAAA,EACnB;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,19 @@
+import { factorySpace as o } from "../../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js";
+import { markdownSpace as f, markdownLineEnding as u } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+const p = {
+  partial: !0,
+  tokenize: k
+};
+function k(t, i, e) {
+  return a;
+  function a(n) {
+    return f(n) ? o(t, r, "linePrefix")(n) : r(n);
+  }
+  function r(n) {
+    return n === null || u(n) ? i(n) : e(n);
+  }
+}
+export {
+  p as blankLine
+};
+//# sourceMappingURL=blank-line.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blank-line.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/blank-line.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 blankLine = {\n  partial: true,\n  tokenize: tokenizeBlankLine\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of blank line.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *     ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    return markdownSpace(code) ? factorySpace(effects, after, \"linePrefix\")(code) : after(code);\n  }\n\n  /**\n   * At eof/eol, after optional whitespace.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *       ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}"],"names":["blankLine","tokenizeBlankLine","effects","ok","nok","start","code","markdownSpace","factorySpace","after","markdownLineEnding"],"mappings":";;AAYY,MAACA,IAAY;AAAA,EACvB,SAAS;AAAA,EACT,UAAUC;AACZ;AAOA,SAASA,EAAkBC,GAASC,GAAIC,GAAK;AAC3C,SAAOC;AAgBP,WAASA,EAAMC,GAAM;AACnB,WAAOC,EAAcD,CAAI,IAAIE,EAAaN,GAASO,GAAO,YAAY,EAAEH,CAAI,IAAIG,EAAMH,CAAI;AAAA,EAC9F;AAgBE,WAASG,EAAMH,GAAM;AACnB,WAAOA,MAAS,QAAQI,EAAmBJ,CAAI,IAAIH,EAAGG,CAAI,IAAIF,EAAIE,CAAI;AAAA,EAC1E;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,43 @@
+import { factorySpace as l } from "../../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js";
+import { markdownSpace as a } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+const k = {
+  continuation: {
+    tokenize: Q
+  },
+  exit: b,
+  name: "blockQuote",
+  tokenize: x
+};
+function x(t, e, r) {
+  const i = this;
+  return u;
+  function u(n) {
+    if (n === 62) {
+      const c = i.containerState;
+      return c.open || (t.enter("blockQuote", {
+        _container: !0
+      }), c.open = !0), t.enter("blockQuotePrefix"), t.enter("blockQuoteMarker"), t.consume(n), t.exit("blockQuoteMarker"), o;
+    }
+    return r(n);
+  }
+  function o(n) {
+    return a(n) ? (t.enter("blockQuotePrefixWhitespace"), t.consume(n), t.exit("blockQuotePrefixWhitespace"), t.exit("blockQuotePrefix"), e) : (t.exit("blockQuotePrefix"), e(n));
+  }
+}
+function Q(t, e, r) {
+  const i = this;
+  return u;
+  function u(n) {
+    return a(n) ? l(t, o, "linePrefix", i.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4)(n) : o(n);
+  }
+  function o(n) {
+    return t.attempt(k, e, r)(n);
+  }
+}
+function b(t) {
+  t.exit("blockQuote");
+}
+export {
+  k as blockQuote
+};
+//# sourceMappingURL=block-quote.es.js.map

package/dist/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":["blockQuote","tokenizeBlockQuoteContinuation","exit","tokenizeBlockQuoteStart","effects","ok","nok","self","start","code","state","after","markdownSpace","contStart","factorySpace","contBefore"],"mappings":";;AAaY,MAACA,IAAa;AAAA,EACxB,cAAc;AAAA,IACZ,UAAUC;AAAA,EACX;AAAA,EACD,MAAAC;AAAA,EACA,MAAM;AAAA,EACN,UAAUC;AACZ;AAOA,SAASA,EAAwBC,GAASC,GAAIC,GAAK;AACjD,QAAMC,IAAO;AACb,SAAOC;AAYP,WAASA,EAAMC,GAAM;AACnB,QAAIA,MAAS,IAAI;AACf,YAAMC,IAAQH,EAAK;AACnB,aAAKG,EAAM,SACTN,EAAQ,MAAM,cAAc;AAAA,QAC1B,YAAY;AAAA,MACtB,CAAS,GACDM,EAAM,OAAO,KAEfN,EAAQ,MAAM,kBAAkB,GAChCA,EAAQ,MAAM,kBAAkB,GAChCA,EAAQ,QAAQK,CAAI,GACpBL,EAAQ,KAAK,kBAAkB,GACxBO;AAAA,IACb;AACI,WAAOL,EAAIG,CAAI;AAAA,EACnB;AAYE,WAASE,EAAMF,GAAM;AACnB,WAAIG,EAAcH,CAAI,KACpBL,EAAQ,MAAM,4BAA4B,GAC1CA,EAAQ,QAAQK,CAAI,GACpBL,EAAQ,KAAK,4BAA4B,GACzCA,EAAQ,KAAK,kBAAkB,GACxBC,MAETD,EAAQ,KAAK,kBAAkB,GACxBC,EAAGI,CAAI;AAAA,EAClB;AACA;AAeA,SAASR,EAA+BG,GAASC,GAAIC,GAAK;AACxD,QAAMC,IAAO;AACb,SAAOM;AAeP,WAASA,EAAUJ,GAAM;AACvB,WAAIG,EAAcH,CAAI,IAGbK,EAAaV,GAASW,GAAY,cAAcR,EAAK,OAAO,WAAW,QAAQ,KAAK,SAAS,cAAc,IAAI,SAAY,CAAC,EAAEE,CAAI,IAEpIM,EAAWN,CAAI;AAAA,EAC1B;AAeE,WAASM,EAAWN,GAAM;AACxB,WAAOL,EAAQ,QAAQJ,GAAYK,GAAIC,CAAG,EAAEG,CAAI;AAAA,EACpD;AACA;AAGA,SAASP,EAAKE,GAAS;AACrB,EAAAA,EAAQ,KAAK,YAAY;AAC3B;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,18 @@
+import { asciiPunctuation as i } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+const o = {
+  name: "characterEscape",
+  tokenize: u
+};
+function u(r, e, n) {
+  return t;
+  function t(a) {
+    return r.enter("characterEscape"), r.enter("escapeMarker"), r.consume(a), r.exit("escapeMarker"), c;
+  }
+  function c(a) {
+    return i(a) ? (r.enter("characterEscapeValue"), r.consume(a), r.exit("characterEscapeValue"), r.exit("characterEscape"), e) : n(a);
+  }
+}
+export {
+  o as characterEscape
+};
+//# sourceMappingURL=character-escape.es.js.map

package/dist/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":["characterEscape","tokenizeCharacterEscape","effects","ok","nok","start","code","inside","asciiPunctuation"],"mappings":";AAWY,MAACA,IAAkB;AAAA,EAC7B,MAAM;AAAA,EACN,UAAUC;AACZ;AAOA,SAASA,EAAwBC,GAASC,GAAIC,GAAK;AACjD,SAAOC;AAYP,WAASA,EAAMC,GAAM;AACnB,WAAAJ,EAAQ,MAAM,iBAAiB,GAC/BA,EAAQ,MAAM,cAAc,GAC5BA,EAAQ,QAAQI,CAAI,GACpBJ,EAAQ,KAAK,cAAc,GACpBK;AAAA,EACX;AAYE,WAASA,EAAOD,GAAM;AAEpB,WAAIE,EAAiBF,CAAI,KACvBJ,EAAQ,MAAM,sBAAsB,GACpCA,EAAQ,QAAQI,CAAI,GACpBJ,EAAQ,KAAK,sBAAsB,GACnCA,EAAQ,KAAK,iBAAiB,GACvBC,KAEFC,EAAIE,CAAI;AAAA,EACnB;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,31 @@
+import { decodeNamedCharacterReference as k } from "../../../../decode-named-character-reference@1.1.0/node_modules/decode-named-character-reference/index.dom.es.js";
+import { asciiAlphanumeric as u, asciiHexDigit as M, asciiDigit as p } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+const N = {
+  name: "characterReference",
+  tokenize: z
+};
+function z(e, h, t) {
+  const m = this;
+  let i = 0, n, a;
+  return R;
+  function R(r) {
+    return e.enter("characterReference"), e.enter("characterReferenceMarker"), e.consume(r), e.exit("characterReferenceMarker"), l;
+  }
+  function l(r) {
+    return r === 35 ? (e.enter("characterReferenceMarkerNumeric"), e.consume(r), e.exit("characterReferenceMarkerNumeric"), o) : (e.enter("characterReferenceValue"), n = 31, a = u, c(r));
+  }
+  function o(r) {
+    return r === 88 || r === 120 ? (e.enter("characterReferenceMarkerHexadecimal"), e.consume(r), e.exit("characterReferenceMarkerHexadecimal"), e.enter("characterReferenceValue"), n = 6, a = M, c) : (e.enter("characterReferenceValue"), n = 7, a = p, c(r));
+  }
+  function c(r) {
+    if (r === 59 && i) {
+      const x = e.exit("characterReferenceValue");
+      return a === u && !k(m.sliceSerialize(x)) ? t(r) : (e.enter("characterReferenceMarker"), e.consume(r), e.exit("characterReferenceMarker"), e.exit("characterReference"), h);
+    }
+    return a(r) && i++ < n ? (e.consume(r), c) : t(r);
+  }
+}
+export {
+  N as characterReference
+};
+//# sourceMappingURL=character-reference.es.js.map

package/dist/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":["characterReference","tokenizeCharacterReference","effects","ok","nok","self","size","max","test","start","code","open","numeric","asciiAlphanumeric","value","asciiHexDigit","asciiDigit","token","decodeNamedCharacterReference"],"mappings":";;AAaY,MAACA,IAAqB;AAAA,EAChC,MAAM;AAAA,EACN,UAAUC;AACZ;AAOA,SAASA,EAA2BC,GAASC,GAAIC,GAAK;AACpD,QAAMC,IAAO;AACb,MAAIC,IAAO,GAEPC,GAEAC;AACJ,SAAOC;AAgBP,WAASA,EAAMC,GAAM;AACnB,WAAAR,EAAQ,MAAM,oBAAoB,GAClCA,EAAQ,MAAM,0BAA0B,GACxCA,EAAQ,QAAQQ,CAAI,GACpBR,EAAQ,KAAK,0BAA0B,GAChCS;AAAA,EACX;AAiBE,WAASA,EAAKD,GAAM;AAClB,WAAIA,MAAS,MACXR,EAAQ,MAAM,iCAAiC,GAC/CA,EAAQ,QAAQQ,CAAI,GACpBR,EAAQ,KAAK,iCAAiC,GACvCU,MAETV,EAAQ,MAAM,yBAAyB,GACvCK,IAAM,IACNC,IAAOK,GACAC,EAAMJ,CAAI;AAAA,EACrB;AAcE,WAASE,EAAQF,GAAM;AACrB,WAAIA,MAAS,MAAMA,MAAS,OAC1BR,EAAQ,MAAM,qCAAqC,GACnDA,EAAQ,QAAQQ,CAAI,GACpBR,EAAQ,KAAK,qCAAqC,GAClDA,EAAQ,MAAM,yBAAyB,GACvCK,IAAM,GACNC,IAAOO,GACAD,MAETZ,EAAQ,MAAM,yBAAyB,GACvCK,IAAM,GACNC,IAAOQ,GACAF,EAAMJ,CAAI;AAAA,EACrB;AAmBE,WAASI,EAAMJ,GAAM;AACnB,QAAIA,MAAS,MAAMJ,GAAM;AACvB,YAAMW,IAAQf,EAAQ,KAAK,yBAAyB;AACpD,aAAIM,MAASK,KAAqB,CAACK,EAA8Bb,EAAK,eAAeY,CAAK,CAAC,IAClFb,EAAIM,CAAI,KAKjBR,EAAQ,MAAM,0BAA0B,GACxCA,EAAQ,QAAQQ,CAAI,GACpBR,EAAQ,KAAK,0BAA0B,GACvCA,EAAQ,KAAK,oBAAoB,GAC1BC;AAAA,IACb;AACI,WAAIK,EAAKE,CAAI,KAAKJ,MAASC,KACzBL,EAAQ,QAAQQ,CAAI,GACbI,KAEFV,EAAIM,CAAI;AAAA,EACnB;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,95 @@
+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,
+  name: "codeFenced",
+  tokenize: V
+};
+function V(e, m, l) {
+  const i = this, S = {
+    partial: !0,
+    tokenize: M
+  };
+  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));
+  }
+  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", {
+      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);
+  }
+  function P(n) {
+    return n === null || u(n) ? F(n) : (e.enter("codeFencedFenceMeta"), e.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;
+  }
+  function v(n) {
+    return c > 0 && x(n) ? p(e, g, "linePrefix", c + 1)(n) : g(n);
+  }
+  function g(n) {
+    return n === null || u(n) ? e.check(d, w, h)(n) : (e.enter("codeFlowValue"), y(n));
+  }
+  function y(n) {
+    return n === null || u(n) ? (e.exit("codeFlowValue"), g(n)) : (e.consume(n), y);
+  }
+  function h(n) {
+    return e.exit("codeFenced"), m(n);
+  }
+  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 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);
+    }
+    function s(r) {
+      return r === o ? (n.enter("codeFencedFenceSequence"), B(r)) : k(r);
+    }
+    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 b(r) {
+      return r === null || u(r) ? (n.exit("codeFencedFence"), a(r)) : k(r);
+    }
+  }
+}
+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 c(t) {
+    return i.parser.lazy[i.now().line] ? l(t) : m(t);
+  }
+}
+export {
+  G as 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

@@ -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":["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":";;AAaA,MAAMA,IAAsB;AAAA,EAC1B,SAAS;AAAA,EACT,UAAUC;AACZ,GAGaC,IAAa;AAAA,EACxB,UAAU;AAAA,EACV,MAAM;AAAA,EACN,UAAUC;AACZ;AAOA,SAASA,EAAmBC,GAASC,GAAIC,GAAK;AAC5C,QAAMC,IAAO,MAEPC,IAAa;AAAA,IACjB,SAAS;AAAA,IACT,UAAUC;AAAA,EACX;AACD,MAAIC,IAAgB,GAChBC,IAAW,GAEXC;AACJ,SAAOC;AAcP,WAASA,EAAMC,GAAM;AAEnB,WAAOC,EAAmBD,CAAI;AAAA,EAClC;AAcE,WAASC,EAAmBD,GAAM;AAChC,UAAME,IAAOT,EAAK,OAAOA,EAAK,OAAO,SAAS,CAAC;AAC/C,WAAAG,IAAgBM,KAAQA,EAAK,CAAC,EAAE,SAAS,eAAeA,EAAK,CAAC,EAAE,eAAeA,EAAK,CAAC,GAAG,EAAI,EAAE,SAAS,GACvGJ,IAASE,GACTV,EAAQ,MAAM,YAAY,GAC1BA,EAAQ,MAAM,iBAAiB,GAC/BA,EAAQ,MAAM,yBAAyB,GAChCa,EAAaH,CAAI;AAAA,EAC5B;AAcE,WAASG,EAAaH,GAAM;AAC1B,WAAIA,MAASF,KACXD,KACAP,EAAQ,QAAQU,CAAI,GACbG,KAELN,IAAW,IACNL,EAAIQ,CAAI,KAEjBV,EAAQ,KAAK,yBAAyB,GAC/Bc,EAAcJ,CAAI,IAAIK,EAAaf,GAASgB,GAAY,YAAY,EAAEN,CAAI,IAAIM,EAAWN,CAAI;AAAA,EACxG;AAcE,WAASM,EAAWN,GAAM;AACxB,WAAIA,MAAS,QAAQO,EAAmBP,CAAI,KAC1CV,EAAQ,KAAK,iBAAiB,GACvBG,EAAK,YAAYF,EAAGS,CAAI,IAAIV,EAAQ,MAAMJ,GAAqBsB,GAAgBC,CAAK,EAAET,CAAI,MAEnGV,EAAQ,MAAM,qBAAqB,GACnCA,EAAQ,MAAM,eAAe;AAAA,MAC3B,aAAa;AAAA,IACnB,CAAK,GACMoB,EAAKV,CAAI;AAAA,EACpB;AAcE,WAASU,EAAKV,GAAM;AAClB,WAAIA,MAAS,QAAQO,EAAmBP,CAAI,KAC1CV,EAAQ,KAAK,aAAa,GAC1BA,EAAQ,KAAK,qBAAqB,GAC3BgB,EAAWN,CAAI,KAEpBI,EAAcJ,CAAI,KACpBV,EAAQ,KAAK,aAAa,GAC1BA,EAAQ,KAAK,qBAAqB,GAC3Be,EAAaf,GAASqB,GAAY,YAAY,EAAEX,CAAI,KAEzDA,MAAS,MAAMA,MAASF,IACnBN,EAAIQ,CAAI,KAEjBV,EAAQ,QAAQU,CAAI,GACbU;AAAA,EACX;AAcE,WAASC,EAAWX,GAAM;AACxB,WAAIA,MAAS,QAAQO,EAAmBP,CAAI,IACnCM,EAAWN,CAAI,KAExBV,EAAQ,MAAM,qBAAqB,GACnCA,EAAQ,MAAM,eAAe;AAAA,MAC3B,aAAa;AAAA,IACnB,CAAK,GACMsB,EAAKZ,CAAI;AAAA,EACpB;AAcE,WAASY,EAAKZ,GAAM;AAClB,WAAIA,MAAS,QAAQO,EAAmBP,CAAI,KAC1CV,EAAQ,KAAK,aAAa,GAC1BA,EAAQ,KAAK,qBAAqB,GAC3BgB,EAAWN,CAAI,KAEpBA,MAAS,MAAMA,MAASF,IACnBN,EAAIQ,CAAI,KAEjBV,EAAQ,QAAQU,CAAI,GACbY;AAAA,EACX;AAeE,WAASJ,EAAeR,GAAM;AAC5B,WAAOV,EAAQ,QAAQI,GAAYe,GAAOI,CAAa,EAAEb,CAAI;AAAA,EACjE;AAcE,WAASa,EAAcb,GAAM;AAC3B,WAAAV,EAAQ,MAAM,YAAY,GAC1BA,EAAQ,QAAQU,CAAI,GACpBV,EAAQ,KAAK,YAAY,GAClBwB;AAAA,EACX;AAcE,WAASA,EAAad,GAAM;AAC1B,WAAOJ,IAAgB,KAAKQ,EAAcJ,CAAI,IAAIK,EAAaf,GAASyB,GAAoB,cAAcnB,IAAgB,CAAC,EAAEI,CAAI,IAAIe,EAAmBf,CAAI;AAAA,EAChK;AAcE,WAASe,EAAmBf,GAAM;AAChC,WAAIA,MAAS,QAAQO,EAAmBP,CAAI,IACnCV,EAAQ,MAAMJ,GAAqBsB,GAAgBC,CAAK,EAAET,CAAI,KAEvEV,EAAQ,MAAM,eAAe,GACtB0B,EAAahB,CAAI;AAAA,EAC5B;AAcE,WAASgB,EAAahB,GAAM;AAC1B,WAAIA,MAAS,QAAQO,EAAmBP,CAAI,KAC1CV,EAAQ,KAAK,eAAe,GACrByB,EAAmBf,CAAI,MAEhCV,EAAQ,QAAQU,CAAI,GACbgB;AAAA,EACX;AAcE,WAASP,EAAMT,GAAM;AACnB,WAAAV,EAAQ,KAAK,YAAY,GAClBC,EAAGS,CAAI;AAAA,EAClB;AAOE,WAASL,EAAmBL,GAASC,GAAIC,GAAK;AAC5C,QAAIyB,IAAO;AACX,WAAOC;AAOP,aAASA,EAAYlB,GAAM;AACzB,aAAAV,EAAQ,MAAM,YAAY,GAC1BA,EAAQ,QAAQU,CAAI,GACpBV,EAAQ,KAAK,YAAY,GAClBS;AAAA,IACb;AAcI,aAASA,EAAMC,GAAM;AAInB,aAAAV,EAAQ,MAAM,iBAAiB,GACxBc,EAAcJ,CAAI,IAAIK,EAAaf,GAAS6B,GAAqB,cAAc1B,EAAK,OAAO,WAAW,QAAQ,KAAK,SAAS,cAAc,IAAI,SAAY,CAAC,EAAEO,CAAI,IAAImB,EAAoBnB,CAAI;AAAA,IAC1M;AAcI,aAASmB,EAAoBnB,GAAM;AACjC,aAAIA,MAASF,KACXR,EAAQ,MAAM,yBAAyB,GAChC8B,EAAcpB,CAAI,KAEpBR,EAAIQ,CAAI;AAAA,IACrB;AAcI,aAASoB,EAAcpB,GAAM;AAC3B,aAAIA,MAASF,KACXmB,KACA3B,EAAQ,QAAQU,CAAI,GACboB,KAELH,KAAQpB,KACVP,EAAQ,KAAK,yBAAyB,GAC/Bc,EAAcJ,CAAI,IAAIK,EAAaf,GAAS+B,GAAoB,YAAY,EAAErB,CAAI,IAAIqB,EAAmBrB,CAAI,KAE/GR,EAAIQ,CAAI;AAAA,IACrB;AAcI,aAASqB,EAAmBrB,GAAM;AAChC,aAAIA,MAAS,QAAQO,EAAmBP,CAAI,KAC1CV,EAAQ,KAAK,iBAAiB,GACvBC,EAAGS,CAAI,KAETR,EAAIQ,CAAI;AAAA,IACrB;AAAA,EACA;AACA;AAOA,SAASb,EAA4BG,GAASC,GAAIC,GAAK;AACrD,QAAMC,IAAO;AACb,SAAOM;AAOP,WAASA,EAAMC,GAAM;AACnB,WAAIA,MAAS,OACJR,EAAIQ,CAAI,KAEjBV,EAAQ,MAAM,YAAY,GAC1BA,EAAQ,QAAQU,CAAI,GACpBV,EAAQ,KAAK,YAAY,GAClBgC;AAAA,EACX;AAOE,WAASA,EAAUtB,GAAM;AACvB,WAAOP,EAAK,OAAO,KAAKA,EAAK,IAAG,EAAG,IAAI,IAAID,EAAIQ,CAAI,IAAIT,EAAGS,CAAI;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

@@ -0,0 +1,44 @@
+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 = {
+  name: "codeIndented",
+  tokenize: p
+}, m = {
+  partial: !0,
+  tokenize: d
+};
+function p(e, f, l) {
+  const r = this;
+  return u;
+  function u(n) {
+    return e.enter("codeIndented"), h(e, s, "linePrefix", 5)(n);
+  }
+  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 t(n) {
+    return n === null ? x(n) : o(n) ? e.attempt(m, t, x)(n) : (e.enter("codeFlowValue"), i(n));
+  }
+  function i(n) {
+    return n === null || o(n) ? (e.exit("codeFlowValue"), t(n)) : (e.consume(n), i);
+  }
+  function x(n) {
+    return e.exit("codeIndented"), f(n);
+  }
+}
+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 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);
+  }
+}
+export {
+  P as 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

@@ -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":["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]}

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

@@ -0,0 +1,46 @@
+import { markdownLineEnding as d } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+const m = {
+  name: "codeText",
+  previous: g,
+  resolve: y,
+  tokenize: E
+};
+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;
+        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;
+}
+function g(e) {
+  return e !== 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 o(n) {
+    return n === 96 ? (e.consume(n), t++, o) : (e.exit("codeTextSequence"), x(n));
+  }
+  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 a(n) {
+    return n === null || n === 32 || n === 96 || d(n) ? (e.exit("codeTextData"), x(n)) : (e.consume(n), a);
+  }
+  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));
+  }
+}
+export {
+  m as codeText
+};
+//# sourceMappingURL=code-text.es.js.map

package/dist/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":["codeText","previous","resolveCodeText","tokenizeCodeText","events","tailExitIndex","headEnterIndex","index","enter","code","effects","ok","nok","sizeOpen","size","token","start","sequenceOpen","between","sequenceClose","markdownLineEnding","data"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -0,0 +1,51 @@
+import { factorySpace as a } from "../../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js";
+import { markdownLineEnding as l } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+import { subtokenize as p } from "../../../../micromark-util-subtokenize@2.1.0/node_modules/micromark-util-subtokenize/index.es.js";
+const d = {
+  resolve: s,
+  tokenize: h
+}, k = {
+  partial: !0,
+  tokenize: x
+};
+function s(n) {
+  return p(n), n;
+}
+function h(n, u) {
+  let r;
+  return i;
+  function i(t) {
+    return n.enter("content"), r = n.enter("chunkContent", {
+      contentType: "content"
+    }), o(t);
+  }
+  function o(t) {
+    return t === null ? c(t) : l(t) ? n.check(k, e, c)(t) : (n.consume(t), o);
+  }
+  function c(t) {
+    return n.exit("chunkContent"), n.exit("content"), u(t);
+  }
+  function e(t) {
+    return n.consume(t), n.exit("chunkContent"), r.next = n.enter("chunkContent", {
+      contentType: "content",
+      previous: r
+    }), r = r.next, o;
+  }
+}
+function x(n, u, r) {
+  const i = this;
+  return o;
+  function o(e) {
+    return n.exit("chunkContent"), n.enter("lineEnding"), n.consume(e), n.exit("lineEnding"), a(n, c, "linePrefix");
+  }
+  function c(e) {
+    if (e === null || l(e))
+      return r(e);
+    const t = i.events[i.events.length - 1];
+    return !i.parser.constructs.disable.null.includes("codeIndented") && t && t[1].type === "linePrefix" && t[2].sliceSerialize(t[1], !0).length >= 4 ? u(e) : n.interrupt(i.parser.constructs.flow, r, u)(e);
+  }
+}
+export {
+  d as content
+};
+//# sourceMappingURL=content.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"content.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/content.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { subtokenize } from 'micromark-util-subtokenize';\n/**\n * No name because it must not be turned off.\n * @type {Construct}\n */\nexport const content = {\n  resolve: resolveContent,\n  tokenize: tokenizeContent\n};\n\n/** @type {Construct} */\nconst continuationConstruct = {\n  partial: true,\n  tokenize: tokenizeContinuation\n};\n\n/**\n * Content is transparent: it’s parsed right now. That way, definitions are also\n * parsed right now: before text in paragraphs (specifically, media) are parsed.\n *\n * @type {Resolver}\n */\nfunction resolveContent(events) {\n  subtokenize(events);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeContent(effects, ok) {\n  /** @type {Token | undefined} */\n  let previous;\n  return chunkStart;\n\n  /**\n   * Before a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkStart(code) {\n    effects.enter(\"content\");\n    previous = effects.enter(\"chunkContent\", {\n      contentType: \"content\"\n    });\n    return chunkInside(code);\n  }\n\n  /**\n   * In a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkInside(code) {\n    if (code === null) {\n      return contentEnd(code);\n    }\n\n    // To do: in `markdown-rs`, each line is parsed on its own, and everything\n    // is stitched together resolving.\n    if (markdownLineEnding(code)) {\n      return effects.check(continuationConstruct, contentContinue, contentEnd)(code);\n    }\n\n    // Data.\n    effects.consume(code);\n    return chunkInside;\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentEnd(code) {\n    effects.exit(\"chunkContent\");\n    effects.exit(\"content\");\n    return ok(code);\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentContinue(code) {\n    effects.consume(code);\n    effects.exit(\"chunkContent\");\n    previous.next = effects.enter(\"chunkContent\", {\n      contentType: \"content\",\n      previous\n    });\n    previous = previous.next;\n    return chunkInside;\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeContinuation(effects, ok, nok) {\n  const self = this;\n  return startLookahead;\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function startLookahead(code) {\n    effects.exit(\"chunkContent\");\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, prefixed, \"linePrefix\");\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    // Always populated by defaults.\n\n    const tail = self.events[self.events.length - 1];\n    if (!self.parser.constructs.disable.null.includes('codeIndented') && tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4) {\n      return ok(code);\n    }\n    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code);\n  }\n}"],"names":["content","resolveContent","tokenizeContent","continuationConstruct","tokenizeContinuation","events","subtokenize","effects","ok","previous","chunkStart","code","chunkInside","contentEnd","markdownLineEnding","contentContinue","nok","self","startLookahead","factorySpace","prefixed","tail"],"mappings":";;;AAkBY,MAACA,IAAU;AAAA,EACrB,SAASC;AAAA,EACT,UAAUC;AACZ,GAGMC,IAAwB;AAAA,EAC5B,SAAS;AAAA,EACT,UAAUC;AACZ;AAQA,SAASH,EAAeI,GAAQ;AAC9B,SAAAC,EAAYD,CAAM,GACXA;AACT;AAOA,SAASH,EAAgBK,GAASC,GAAI;AAEpC,MAAIC;AACJ,SAAOC;AAYP,WAASA,EAAWC,GAAM;AACxB,WAAAJ,EAAQ,MAAM,SAAS,GACvBE,IAAWF,EAAQ,MAAM,gBAAgB;AAAA,MACvC,aAAa;AAAA,IACnB,CAAK,GACMK,EAAYD,CAAI;AAAA,EAC3B;AAYE,WAASC,EAAYD,GAAM;AACzB,WAAIA,MAAS,OACJE,EAAWF,CAAI,IAKpBG,EAAmBH,CAAI,IAClBJ,EAAQ,MAAMJ,GAAuBY,GAAiBF,CAAU,EAAEF,CAAI,KAI/EJ,EAAQ,QAAQI,CAAI,GACbC;AAAA,EACX;AAOE,WAASC,EAAWF,GAAM;AACxB,WAAAJ,EAAQ,KAAK,cAAc,GAC3BA,EAAQ,KAAK,SAAS,GACfC,EAAGG,CAAI;AAAA,EAClB;AAOE,WAASI,EAAgBJ,GAAM;AAC7B,WAAAJ,EAAQ,QAAQI,CAAI,GACpBJ,EAAQ,KAAK,cAAc,GAC3BE,EAAS,OAAOF,EAAQ,MAAM,gBAAgB;AAAA,MAC5C,aAAa;AAAA,MACb,UAAAE;AAAA,IACN,CAAK,GACDA,IAAWA,EAAS,MACbG;AAAA,EACX;AACA;AAOA,SAASR,EAAqBG,GAASC,GAAIQ,GAAK;AAC9C,QAAMC,IAAO;AACb,SAAOC;AAOP,WAASA,EAAeP,GAAM;AAC5B,WAAAJ,EAAQ,KAAK,cAAc,GAC3BA,EAAQ,MAAM,YAAY,GAC1BA,EAAQ,QAAQI,CAAI,GACpBJ,EAAQ,KAAK,YAAY,GAClBY,EAAaZ,GAASa,GAAU,YAAY;AAAA,EACvD;AAOE,WAASA,EAAST,GAAM;AACtB,QAAIA,MAAS,QAAQG,EAAmBH,CAAI;AAC1C,aAAOK,EAAIL,CAAI;AAKjB,UAAMU,IAAOJ,EAAK,OAAOA,EAAK,OAAO,SAAS,CAAC;AAC/C,WAAI,CAACA,EAAK,OAAO,WAAW,QAAQ,KAAK,SAAS,cAAc,KAAKI,KAAQA,EAAK,CAAC,EAAE,SAAS,gBAAgBA,EAAK,CAAC,EAAE,eAAeA,EAAK,CAAC,GAAG,EAAI,EAAE,UAAU,IACrJb,EAAGG,CAAI,IAETJ,EAAQ,UAAUU,EAAK,OAAO,WAAW,MAAMD,GAAKR,CAAE,EAAEG,CAAI;AAAA,EACvE;AACA;","x_google_ignoreList":[0]}