@easyv/biz-components 0.0.1

package/dist/node_modules/.pnpm/micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js

@@ -0,0 +1,16 @@
+import { markdownSpace as m } from "../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+function p(n, t, i, u) {
+  const o = u ? u - 1 : Number.POSITIVE_INFINITY;
+  let I = 0;
+  return a;
+  function a(r) {
+    return m(r) ? (n.enter(i), e(r)) : t(r);
+  }
+  function e(r) {
+    return m(r) && I++ < o ? (n.consume(r), e) : (n.exit(i), t(r));
+  }
+}
+export {
+  p as factorySpace
+};
+//# sourceMappingURL=index.es.js.map

package/dist/node_modules/.pnpm/micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../node_modules/.pnpm/micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.js"],"sourcesContent":["/**\n * @import {Effects, State, TokenType} from 'micromark-util-types'\n */\n\nimport { markdownSpace } from 'micromark-util-character';\n\n// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.\n\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   spaces in markdown are often optional, in which case this factory can be\n *     used and `ok` will be switched to whether spaces were found or not\n * *   one line ending or space can be detected with `markdownSpace(code)` right\n *     before using `factorySpace`\n *\n * ###### Examples\n *\n * Where `␉` represents a tab (plus how much it expands) and `␠` represents a\n * single space.\n *\n * ```markdown\n * ␉\n * ␠␠␠␠\n * ␉␠\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {TokenType} type\n *   Type (`' \\t'`).\n * @param {number | undefined} [max=Infinity]\n *   Max (exclusive).\n * @returns {State}\n *   Start state.\n */\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Number.POSITIVE_INFINITY;\n  let size = 0;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type);\n      return prefix(code);\n    }\n    return ok(code);\n  }\n\n  /** @type {State} */\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code);\n      return prefix;\n    }\n    effects.exit(type);\n    return ok(code);\n  }\n}"],"names":["factorySpace","effects","ok","type","max","limit","size","start","code","markdownSpace","prefix"],"mappings":";AAwCO,SAASA,EAAaC,GAASC,GAAIC,GAAMC,GAAK;AACnD,QAAMC,IAAQD,IAAMA,IAAM,IAAI,OAAO;AACrC,MAAIE,IAAO;AACX,SAAOC;AAGP,WAASA,EAAMC,GAAM;AACnB,WAAIC,EAAcD,CAAI,KACpBP,EAAQ,MAAME,CAAI,GACXO,EAAOF,CAAI,KAEbN,EAAGM,CAAI;AAAA,EAClB;AAGE,WAASE,EAAOF,GAAM;AACpB,WAAIC,EAAcD,CAAI,KAAKF,MAASD,KAClCJ,EAAQ,QAAQO,CAAI,GACbE,MAETT,EAAQ,KAAKE,CAAI,GACVD,EAAGM,CAAI;AAAA,EAClB;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-factory-title@2.0.1/node_modules/micromark-factory-title/index.es.js

@@ -0,0 +1,27 @@
+import { factorySpace as k } from "../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js";
+import { markdownLineEnding as E } from "../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+function B(r, S, m, x, u, a) {
+  let i;
+  return h;
+  function h(n) {
+    return n === 34 || n === 39 || n === 40 ? (r.enter(x), r.enter(u), r.consume(n), r.exit(u), i = n === 40 ? 41 : n, g) : m(n);
+  }
+  function g(n) {
+    return n === i ? (r.enter(u), r.consume(n), r.exit(u), r.exit(x), S) : (r.enter(a), l(n));
+  }
+  function l(n) {
+    return n === i ? (r.exit(a), g(i)) : n === null ? m(n) : E(n) ? (r.enter("lineEnding"), r.consume(n), r.exit("lineEnding"), k(r, l, "linePrefix")) : (r.enter("chunkString", {
+      contentType: "string"
+    }), t(n));
+  }
+  function t(n) {
+    return n === i || n === null || E(n) ? (r.exit("chunkString"), l(n)) : (r.consume(n), n === 92 ? b : t);
+  }
+  function b(n) {
+    return n === i || n === 92 ? (r.consume(n), t) : t(n);
+  }
+}
+export {
+  B as factoryTitle
+};
+//# sourceMappingURL=index.es.js.map

package/dist/node_modules/.pnpm/micromark-factory-title@2.0.1/node_modules/micromark-factory-title/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../node_modules/.pnpm/micromark-factory-title@2.0.1/node_modules/micromark-factory-title/index.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   Effects,\n *   State,\n *   TokenType\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/**\n * Parse titles.\n *\n * ###### Examples\n *\n * ```markdown\n * \"a\"\n * 'b'\n * (c)\n * \"a\n * b\"\n * 'a\n *     b'\n * (a\\)b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole title (`\"a\"`, `'b'`, `(c)`).\n * @param {TokenType} markerType\n *   Type for the markers (`\"`, `'`, `(`, and `)`).\n * @param {TokenType} stringType\n *   Type for the value (`a`).\n * @returns {State}\n *   Start state.\n */\nexport function factoryTitle(effects, ok, nok, type, markerType, stringType) {\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of title.\n   *\n   * ```markdown\n   * > | \"a\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      effects.enter(type);\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      marker = code === 40 ? 41 : code;\n      return begin;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After opening marker.\n   *\n   * This is also used at the closing marker.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function begin(code) {\n    if (code === marker) {\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n    effects.enter(stringType);\n    return atBreak(code);\n  }\n\n  /**\n   * At something, before something else.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType);\n      return begin(marker);\n    }\n    if (code === null) {\n      return nok(code);\n    }\n\n    // Note: blank lines can’t exist in content.\n    if (markdownLineEnding(code)) {\n      // To do: use `space_or_tab_eol_with_options`, connect.\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return factorySpace(effects, atBreak, \"linePrefix\");\n    }\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return inside(code);\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return code === 92 ? escape : inside;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | \"a\\*b\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function escape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code);\n      return inside;\n    }\n    return inside(code);\n  }\n}"],"names":["factoryTitle","effects","ok","nok","type","markerType","stringType","marker","start","code","begin","atBreak","markdownLineEnding","factorySpace","inside","escape"],"mappings":";;AA0CO,SAASA,EAAaC,GAASC,GAAIC,GAAKC,GAAMC,GAAYC,GAAY;AAE3E,MAAIC;AACJ,SAAOC;AAYP,WAASA,EAAMC,GAAM;AACnB,WAAIA,MAAS,MAAMA,MAAS,MAAMA,MAAS,MACzCR,EAAQ,MAAMG,CAAI,GAClBH,EAAQ,MAAMI,CAAU,GACxBJ,EAAQ,QAAQQ,CAAI,GACpBR,EAAQ,KAAKI,CAAU,GACvBE,IAASE,MAAS,KAAK,KAAKA,GACrBC,KAEFP,EAAIM,CAAI;AAAA,EACnB;AAcE,WAASC,EAAMD,GAAM;AACnB,WAAIA,MAASF,KACXN,EAAQ,MAAMI,CAAU,GACxBJ,EAAQ,QAAQQ,CAAI,GACpBR,EAAQ,KAAKI,CAAU,GACvBJ,EAAQ,KAAKG,CAAI,GACVF,MAETD,EAAQ,MAAMK,CAAU,GACjBK,EAAQF,CAAI;AAAA,EACvB;AAYE,WAASE,EAAQF,GAAM;AACrB,WAAIA,MAASF,KACXN,EAAQ,KAAKK,CAAU,GAChBI,EAAMH,CAAM,KAEjBE,MAAS,OACJN,EAAIM,CAAI,IAIbG,EAAmBH,CAAI,KAEzBR,EAAQ,MAAM,YAAY,GAC1BA,EAAQ,QAAQQ,CAAI,GACpBR,EAAQ,KAAK,YAAY,GAClBY,EAAaZ,GAASU,GAAS,YAAY,MAEpDV,EAAQ,MAAM,eAAe;AAAA,MAC3B,aAAa;AAAA,IACnB,CAAK,GACMa,EAAOL,CAAI;AAAA,EACtB;AAOE,WAASK,EAAOL,GAAM;AACpB,WAAIA,MAASF,KAAUE,MAAS,QAAQG,EAAmBH,CAAI,KAC7DR,EAAQ,KAAK,aAAa,GACnBU,EAAQF,CAAI,MAErBR,EAAQ,QAAQQ,CAAI,GACbA,MAAS,KAAKM,IAASD;AAAA,EAClC;AAYE,WAASC,EAAON,GAAM;AACpB,WAAIA,MAASF,KAAUE,MAAS,MAC9BR,EAAQ,QAAQQ,CAAI,GACbK,KAEFA,EAAOL,CAAI;AAAA,EACtB;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-factory-whitespace@2.0.1/node_modules/micromark-factory-whitespace/index.es.js

@@ -0,0 +1,13 @@
+import { factorySpace as u } from "../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js";
+import { markdownLineEnding as a, markdownSpace as o } from "../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+function f(r, e) {
+  let t;
+  return i;
+  function i(n) {
+    return a(n) ? (r.enter("lineEnding"), r.consume(n), r.exit("lineEnding"), t = !0, i) : o(n) ? u(r, i, t ? "linePrefix" : "lineSuffix")(n) : e(n);
+  }
+}
+export {
+  f as factoryWhitespace
+};
+//# sourceMappingURL=index.es.js.map

package/dist/node_modules/.pnpm/micromark-factory-whitespace@2.0.1/node_modules/micromark-factory-whitespace/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../node_modules/.pnpm/micromark-factory-whitespace@2.0.1/node_modules/micromark-factory-whitespace/index.js"],"sourcesContent":["/**\n * @import {Effects, State} from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   line endings or spaces in markdown are often optional, in which case this\n *     factory can be used and `ok` will be switched to whether spaces were found\n *     or not\n * *   one line ending or space can be detected with\n *     `markdownLineEndingOrSpace(code)` right before using `factoryWhitespace`\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @returns {State}\n *   Start state.\n */\nexport function factoryWhitespace(effects, ok) {\n  /** @type {boolean} */\n  let seen;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      seen = true;\n      return start;\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, start, seen ? \"linePrefix\" : \"lineSuffix\")(code);\n    }\n    return ok(code);\n  }\n}"],"names":["factoryWhitespace","effects","ok","seen","start","code","markdownLineEnding","markdownSpace","factorySpace"],"mappings":";;AAwBO,SAASA,EAAkBC,GAASC,GAAI;AAE7C,MAAIC;AACJ,SAAOC;AAGP,WAASA,EAAMC,GAAM;AACnB,WAAIC,EAAmBD,CAAI,KACzBJ,EAAQ,MAAM,YAAY,GAC1BA,EAAQ,QAAQI,CAAI,GACpBJ,EAAQ,KAAK,YAAY,GACzBE,IAAO,IACAC,KAELG,EAAcF,CAAI,IACbG,EAAaP,GAASG,GAAOD,IAAO,eAAe,YAAY,EAAEE,CAAI,IAEvEH,EAAGG,CAAI;AAAA,EAClB;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js

@@ -0,0 +1,40 @@
+const c = i(/[A-Za-z]/), r = i(/[\dA-Za-z]/), a = i(/[#-'*+\--9=?A-Z^-~]/);
+function s(n) {
+  return (
+    // Special whitespace codes (which have negative values), C0 and Control
+    // character DEL
+    n !== null && (n < 32 || n === 127)
+  );
+}
+const o = i(/\d/), e = i(/[\dA-Fa-f]/), l = i(/[!-/:-@[-`{-~]/);
+function f(n) {
+  return n !== null && n < -2;
+}
+function p(n) {
+  return n !== null && (n < 0 || n === 32);
+}
+function A(n) {
+  return n === -2 || n === -1 || n === 32;
+}
+const g = i(new RegExp("\\p{P}|\\p{S}", "u")), h = i(/\s/);
+function i(n) {
+  return u;
+  function u(t) {
+    return t !== null && t > -1 && n.test(String.fromCharCode(t));
+  }
+}
+export {
+  c as asciiAlpha,
+  r as asciiAlphanumeric,
+  a as asciiAtext,
+  s as asciiControl,
+  o as asciiDigit,
+  e as asciiHexDigit,
+  l as asciiPunctuation,
+  f as markdownLineEnding,
+  p as markdownLineEndingOrSpace,
+  A as markdownSpace,
+  g as unicodePunctuation,
+  h as unicodeWhitespace
+};
+//# sourceMappingURL=index.es.js.map

package/dist/node_modules/.pnpm/micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../node_modules/.pnpm/micromark-util-character@2.1.1/node_modules/micromark-util-character/index.js"],"sourcesContent":["/**\n * @import {Code} from 'micromark-util-types'\n */\n\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlpha = regexCheck(/[A-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\n\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  );\n}\n\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiDigit = regexCheck(/\\d/);\n\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\n\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\n\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2;\n}\n\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32);\n}\n\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32;\n}\n\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodePunctuation = regexCheck(/\\p{P}|\\p{S}/u);\n\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/);\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n *   Expression.\n * @returns {(code: Code) => boolean}\n *   Check.\n */\nfunction regexCheck(regex) {\n  return check;\n\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code\n   *   Character code.\n   * @returns {boolean}\n   *   Whether the character code matches the bound regex.\n   */\n  function check(code) {\n    return code !== null && code > -1 && regex.test(String.fromCharCode(code));\n  }\n}"],"names":["asciiAlpha","regexCheck","asciiAlphanumeric","asciiAtext","asciiControl","code","asciiDigit","asciiHexDigit","asciiPunctuation","markdownLineEnding","markdownLineEndingOrSpace","markdownSpace","unicodePunctuation","unicodeWhitespace","regex","check"],"mappings":"AAqBY,MAACA,IAAaC,EAAW,UAAU,GAclCC,IAAoBD,EAAW,YAAY,GAuB3CE,IAAaF,EAAW,qBAAqB;AAanD,SAASG,EAAaC,GAAM;AACjC;AAAA;AAAA;AAAA,IAGEA,MAAS,SAASA,IAAO,MAAMA,MAAS;AAAA;AAE5C;AAaY,MAACC,IAAaL,EAAW,IAAI,GAoB5BM,IAAgBN,EAAW,YAAY,GAevCO,IAAmBP,EAAW,gBAAgB;AAiBpD,SAASQ,EAAmBJ,GAAM;AACvC,SAAOA,MAAS,QAAQA,IAAO;AACjC;AAWO,SAASK,EAA0BL,GAAM;AAC9C,SAAOA,MAAS,SAASA,IAAO,KAAKA,MAAS;AAChD;AAiBO,SAASM,EAAcN,GAAM;AAClC,SAAOA,MAAS,MAAMA,MAAS,MAAMA,MAAS;AAChD;AAuBY,MAACO,IAAqBX,EAAW,WAAc,iBAAA,GAAA,IAsB9CY,IAAoBZ,EAAW,IAAI;AAUhD,SAASA,EAAWa,GAAO;AACzB,SAAOC;AAUP,WAASA,EAAMV,GAAM;AACnB,WAAOA,MAAS,QAAQA,IAAO,MAAMS,EAAM,KAAK,OAAO,aAAaT,CAAI,CAAC;AAAA,EAC7E;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.es.js

@@ -0,0 +1,17 @@
+function p(h, n, c, f) {
+  const l = h.length;
+  let u = 0, e;
+  if (n < 0 ? n = -n > l ? 0 : l + n : n = n > l ? l : n, c = c > 0 ? c : 0, f.length < 1e4)
+    e = Array.from(f), e.unshift(n, c), h.splice(...e);
+  else
+    for (c && h.splice(n, c); u < f.length; )
+      e = f.slice(u, u + 1e4), e.unshift(n, 0), h.splice(...e), u += 1e4, n += 1e4;
+}
+function g(h, n) {
+  return h.length > 0 ? (p(h, h.length, 0, n), h) : n;
+}
+export {
+  g as push,
+  p as splice
+};
+//# sourceMappingURL=index.es.js.map

package/dist/node_modules/.pnpm/micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../node_modules/.pnpm/micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.js"],"sourcesContent":["/**\n * Like `Array#splice`, but smarter for giant arrays.\n *\n * `Array#splice` takes all items to be inserted as individual argument which\n * causes a stack overflow in V8 when trying to insert 100k items for instance.\n *\n * Otherwise, this does not return the removed items, and takes `items` as an\n * array instead of rest parameters.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {number} start\n *   Index to remove/insert at (can be negative).\n * @param {number} remove\n *   Number of items to remove.\n * @param {Array<T>} items\n *   Items to inject into `list`.\n * @returns {undefined}\n *   Nothing.\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length;\n  let chunkStart = 0;\n  /** @type {Array<unknown>} */\n  let parameters;\n\n  // Make start between zero and `end` (included).\n  if (start < 0) {\n    start = -start > end ? 0 : end + start;\n  } else {\n    start = start > end ? end : start;\n  }\n  remove = remove > 0 ? remove : 0;\n\n  // No need to chunk the items if there’s only a couple (10k) items.\n  if (items.length < 10000) {\n    parameters = Array.from(items);\n    parameters.unshift(start, remove);\n    // @ts-expect-error Hush, it’s fine.\n    list.splice(...parameters);\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) list.splice(start, remove);\n\n    // Insert the items in chunks to not cause stack overflows.\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000);\n      parameters.unshift(start, 0);\n      // @ts-expect-error Hush, it’s fine.\n      list.splice(...parameters);\n      chunkStart += 10000;\n      start += 10000;\n    }\n  }\n}\n\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {Array<T>} items\n *   Items to add to `list`.\n * @returns {Array<T>}\n *   Either `list` or `items`.\n */\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items);\n    return list;\n  }\n  return items;\n}"],"names":["splice","list","start","remove","items","end","chunkStart","parameters","push"],"mappings":"AAsBO,SAASA,EAAOC,GAAMC,GAAOC,GAAQC,GAAO;AACjD,QAAMC,IAAMJ,EAAK;AACjB,MAAIK,IAAa,GAEbC;AAWJ,MARIL,IAAQ,IACVA,IAAQ,CAACA,IAAQG,IAAM,IAAIA,IAAMH,IAEjCA,IAAQA,IAAQG,IAAMA,IAAMH,GAE9BC,IAASA,IAAS,IAAIA,IAAS,GAG3BC,EAAM,SAAS;AACjB,IAAAG,IAAa,MAAM,KAAKH,CAAK,GAC7BG,EAAW,QAAQL,GAAOC,CAAM,GAEhCF,EAAK,OAAO,GAAGM,CAAU;AAAA;AAMzB,SAHIJ,KAAQF,EAAK,OAAOC,GAAOC,CAAM,GAG9BG,IAAaF,EAAM;AACxB,MAAAG,IAAaH,EAAM,MAAME,GAAYA,IAAa,GAAK,GACvDC,EAAW,QAAQL,GAAO,CAAC,GAE3BD,EAAK,OAAO,GAAGM,CAAU,GACzBD,KAAc,KACdJ,KAAS;AAGf;AAkBO,SAASM,EAAKP,GAAMG,GAAO;AAChC,SAAIH,EAAK,SAAS,KAChBD,EAAOC,GAAMA,EAAK,QAAQ,GAAGG,CAAK,GAC3BH,KAEFG;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-util-classify-character@2.0.1/node_modules/micromark-util-classify-character/index.es.js

@@ -0,0 +1,11 @@
+import { markdownLineEndingOrSpace as i, unicodeWhitespace as r, unicodePunctuation as t } from "../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+function a(n) {
+  if (n === null || i(n) || r(n))
+    return 1;
+  if (t(n))
+    return 2;
+}
+export {
+  a as classifyCharacter
+};
+//# sourceMappingURL=index.es.js.map

package/dist/node_modules/.pnpm/micromark-util-classify-character@2.0.1/node_modules/micromark-util-classify-character/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../node_modules/.pnpm/micromark-util-classify-character@2.0.1/node_modules/micromark-util-classify-character/index.js"],"sourcesContent":["/**\n * @import {Code} from 'micromark-util-types'\n */\n\nimport { markdownLineEndingOrSpace, unicodePunctuation, unicodeWhitespace } from 'micromark-util-character';\n/**\n * Classify whether a code represents whitespace, punctuation, or something\n * else.\n *\n * Used for attention (emphasis, strong), whose sequences can open or close\n * based on the class of surrounding characters.\n *\n * > 👉 **Note**: eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n *   Code.\n * @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined}\n *   Group.\n */\nexport function classifyCharacter(code) {\n  if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n    return 1;\n  }\n  if (unicodePunctuation(code)) {\n    return 2;\n  }\n}"],"names":["classifyCharacter","code","markdownLineEndingOrSpace","unicodeWhitespace","unicodePunctuation"],"mappings":";AAmBO,SAASA,EAAkBC,GAAM;AACtC,MAAIA,MAAS,QAAQC,EAA0BD,CAAI,KAAKE,EAAkBF,CAAI;AAC5E,WAAO;AAET,MAAIG,EAAmBH,CAAI;AACzB,WAAO;AAEX;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-util-combine-extensions@2.0.1/node_modules/micromark-util-combine-extensions/index.es.js

@@ -0,0 +1,37 @@
+import { splice as a } from "../../../micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.es.js";
+const s = {}.hasOwnProperty;
+function d(t) {
+  const e = {};
+  let n = -1;
+  for (; ++n < t.length; )
+    l(e, t[n]);
+  return e;
+}
+function l(t, e) {
+  let n;
+  for (n in e) {
+    const i = (s.call(t, n) ? t[n] : void 0) || (t[n] = {}), f = e[n];
+    let o;
+    if (f)
+      for (o in f) {
+        s.call(i, o) || (i[o] = []);
+        const r = f[o];
+        h(
+          // @ts-expect-error Looks like a list.
+          i[o],
+          Array.isArray(r) ? r : r ? [r] : []
+        );
+      }
+  }
+}
+function h(t, e) {
+  let n = -1;
+  const c = [];
+  for (; ++n < e.length; )
+    (e[n].add === "after" ? t : c).push(e[n]);
+  a(t, 0, 0, c);
+}
+export {
+  d as combineExtensions
+};
+//# sourceMappingURL=index.es.js.map

package/dist/node_modules/.pnpm/micromark-util-combine-extensions@2.0.1/node_modules/micromark-util-combine-extensions/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../node_modules/.pnpm/micromark-util-combine-extensions@2.0.1/node_modules/micromark-util-combine-extensions/index.js"],"sourcesContent":["/**\n * @import {\n *   Extension,\n *   Handles,\n *   HtmlExtension,\n *   NormalizedExtension\n * } from 'micromark-util-types'\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine multiple syntax extensions into one.\n *\n * @param {ReadonlyArray<Extension>} extensions\n *   List of syntax extensions.\n * @returns {NormalizedExtension}\n *   A single combined extension.\n */\nexport function combineExtensions(extensions) {\n  /** @type {NormalizedExtension} */\n  const all = {}\n  let index = -1\n\n  while (++index < extensions.length) {\n    syntaxExtension(all, extensions[index])\n  }\n\n  return all\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {NormalizedExtension} all\n *   Extension to merge into.\n * @param {Extension} extension\n *   Extension to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction syntaxExtension(all, extension) {\n  /** @type {keyof Extension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    /** @type {Record<string, unknown>} */\n    const left = maybe || (all[hook] = {})\n    /** @type {Record<string, unknown> | undefined} */\n    const right = extension[hook]\n    /** @type {string} */\n    let code\n\n    if (right) {\n      for (code in right) {\n        if (!hasOwnProperty.call(left, code)) left[code] = []\n        const value = right[code]\n        constructs(\n          // @ts-expect-error Looks like a list.\n          left[code],\n          Array.isArray(value) ? value : value ? [value] : []\n        )\n      }\n    }\n  }\n}\n\n/**\n * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {Array<unknown>} existing\n *   List of constructs to merge into.\n * @param {Array<unknown>} list\n *   List of constructs to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction constructs(existing, list) {\n  let index = -1\n  /** @type {Array<unknown>} */\n  const before = []\n\n  while (++index < list.length) {\n    // @ts-expect-error Looks like an object.\n    ;(list[index].add === 'after' ? existing : before).push(list[index])\n  }\n\n  splice(existing, 0, 0, before)\n}\n\n/**\n * Combine multiple HTML extensions into one.\n *\n * @param {ReadonlyArray<HtmlExtension>} htmlExtensions\n *   List of HTML extensions.\n * @returns {HtmlExtension}\n *   Single combined HTML extension.\n */\nexport function combineHtmlExtensions(htmlExtensions) {\n  /** @type {HtmlExtension} */\n  const handlers = {}\n  let index = -1\n\n  while (++index < htmlExtensions.length) {\n    htmlExtension(handlers, htmlExtensions[index])\n  }\n\n  return handlers\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {HtmlExtension} all\n *   Extension to merge into.\n * @param {HtmlExtension} extension\n *   Extension to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction htmlExtension(all, extension) {\n  /** @type {keyof HtmlExtension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    const left = maybe || (all[hook] = {})\n    const right = extension[hook]\n    /** @type {keyof Handles} */\n    let type\n\n    if (right) {\n      for (type in right) {\n        // @ts-expect-error assume document vs regular handler are managed correctly.\n        left[type] = right[type]\n      }\n    }\n  }\n}\n"],"names":["hasOwnProperty","combineExtensions","extensions","all","index","syntaxExtension","extension","hook","left","right","code","value","constructs","existing","list","before","splice"],"mappings":";AAWA,MAAMA,IAAiB,CAAA,EAAG;AAUnB,SAASC,EAAkBC,GAAY;AAE5C,QAAMC,IAAM,CAAA;AACZ,MAAIC,IAAQ;AAEZ,SAAO,EAAEA,IAAQF,EAAW;AAC1B,IAAAG,EAAgBF,GAAKD,EAAWE,CAAK,CAAC;AAGxC,SAAOD;AACT;AAYA,SAASE,EAAgBF,GAAKG,GAAW;AAEvC,MAAIC;AAEJ,OAAKA,KAAQD,GAAW;AAGtB,UAAME,KAFQR,EAAe,KAAKG,GAAKI,CAAI,IAAIJ,EAAII,CAAI,IAAI,YAEpCJ,EAAII,CAAI,IAAI,CAAE,IAE/BE,IAAQH,EAAUC,CAAI;AAE5B,QAAIG;AAEJ,QAAID;AACF,WAAKC,KAAQD,GAAO;AAClB,QAAKT,EAAe,KAAKQ,GAAME,CAAI,MAAGF,EAAKE,CAAI,IAAI,CAAA;AACnD,cAAMC,IAAQF,EAAMC,CAAI;AACxB,QAAAE;AAAA;AAAA,UAEEJ,EAAKE,CAAI;AAAA,UACT,MAAM,QAAQC,CAAK,IAAIA,IAAQA,IAAQ,CAACA,CAAK,IAAI,CAAA;AAAA,QAC3D;AAAA,MACA;AAAA,EAEA;AACA;AAaA,SAASC,EAAWC,GAAUC,GAAM;AAClC,MAAIV,IAAQ;AAEZ,QAAMW,IAAS,CAAA;AAEf,SAAO,EAAEX,IAAQU,EAAK;AAEnB,KAACA,EAAKV,CAAK,EAAE,QAAQ,UAAUS,IAAWE,GAAQ,KAAKD,EAAKV,CAAK,CAAC;AAGrE,EAAAY,EAAOH,GAAU,GAAG,GAAGE,CAAM;AAC/B;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-util-decode-numeric-character-reference@2.0.2/node_modules/micromark-util-decode-numeric-character-reference/index.es.js

@@ -0,0 +1,17 @@
+function n(r, _) {
+  const e = Number.parseInt(r, _);
+  return (
+    // C0 except for HT, LF, FF, CR, space.
+    e < 9 || e === 11 || e > 13 && e < 32 || // Control character (DEL) of C0, and C1 controls.
+    e > 126 && e < 160 || // Lone high surrogates and low surrogates.
+    e > 55295 && e < 57344 || // Noncharacters.
+    e > 64975 && e < 65008 || /* eslint-disable no-bitwise */
+    (e & 65535) === 65535 || (e & 65535) === 65534 || /* eslint-enable no-bitwise */
+    // Out of range
+    e > 1114111 ? "�" : String.fromCodePoint(e)
+  );
+}
+export {
+  n as decodeNumericCharacterReference
+};
+//# sourceMappingURL=index.es.js.map

package/dist/node_modules/.pnpm/micromark-util-decode-numeric-character-reference@2.0.2/node_modules/micromark-util-decode-numeric-character-reference/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../node_modules/.pnpm/micromark-util-decode-numeric-character-reference@2.0.2/node_modules/micromark-util-decode-numeric-character-reference/index.js"],"sourcesContent":["/**\n * Turn the number (in string form as either hexa- or plain decimal) coming from\n * a numeric character reference into a character.\n *\n * Sort of like `String.fromCodePoint(Number.parseInt(value, base))`, but makes\n * non-characters and control characters safe.\n *\n * @param {string} value\n *   Value to decode.\n * @param {number} base\n *   Numeric base.\n * @returns {string}\n *   Character.\n */\nexport function decodeNumericCharacterReference(value, base) {\n  const code = Number.parseInt(value, base);\n  if (\n  // C0 except for HT, LF, FF, CR, space.\n  code < 9 || code === 11 || code > 13 && code < 32 ||\n  // Control character (DEL) of C0, and C1 controls.\n  code > 126 && code < 160 ||\n  // Lone high surrogates and low surrogates.\n  code > 55_295 && code < 57_344 ||\n  // Noncharacters.\n  code > 64_975 && code < 65_008 || /* eslint-disable no-bitwise */\n  (code & 65_535) === 65_535 || (code & 65_535) === 65_534 || /* eslint-enable no-bitwise */\n  // Out of range\n  code > 1_114_111) {\n    return \"\\uFFFD\";\n  }\n  return String.fromCodePoint(code);\n}"],"names":["decodeNumericCharacterReference","value","base","code"],"mappings":"AAcO,SAASA,EAAgCC,GAAOC,GAAM;AAC3D,QAAMC,IAAO,OAAO,SAASF,GAAOC,CAAI;AACxC;AAAA;AAAA,IAEAC,IAAO,KAAKA,MAAS,MAAMA,IAAO,MAAMA,IAAO;AAAA,IAE/CA,IAAO,OAAOA,IAAO;AAAA,IAErBA,IAAO,SAAUA,IAAO;AAAA,IAExBA,IAAO,SAAUA,IAAO;AAAA,KACvBA,IAAO,WAAY,UAAWA,IAAO,WAAY;AAAA;AAAA,IAElDA,IAAO,UACE,MAEF,OAAO,cAAcA,CAAI;AAAA;AAClC;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-util-decode-string@2.0.1/node_modules/micromark-util-decode-string/index.es.js

@@ -0,0 +1,19 @@
+import { decodeNamedCharacterReference as o } from "../../../decode-named-character-reference@1.1.0/node_modules/decode-named-character-reference/index.dom.es.js";
+import { decodeNumericCharacterReference as a } from "../../../micromark-util-decode-numeric-character-reference@2.0.2/node_modules/micromark-util-decode-numeric-character-reference/index.es.js";
+const n = /\\([!-/:-@[-`{-~])|&(#(?:\d{1,7}|x[\da-f]{1,6})|[\da-z]{1,31});/gi;
+function m(r) {
+  return r.replace(n, f);
+}
+function f(r, c, e) {
+  if (c)
+    return c;
+  if (e.charCodeAt(0) === 35) {
+    const t = e.charCodeAt(1), d = t === 120 || t === 88;
+    return a(e.slice(d ? 2 : 1), d ? 16 : 10);
+  }
+  return o(e) || r;
+}
+export {
+  m as decodeString
+};
+//# sourceMappingURL=index.es.js.map

package/dist/node_modules/.pnpm/micromark-util-decode-string@2.0.1/node_modules/micromark-util-decode-string/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../node_modules/.pnpm/micromark-util-decode-string@2.0.1/node_modules/micromark-util-decode-string/index.js"],"sourcesContent":["import { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { decodeNumericCharacterReference } from 'micromark-util-decode-numeric-character-reference';\nconst characterEscapeOrReference = /\\\\([!-/:-@[-`{-~])|&(#(?:\\d{1,7}|x[\\da-f]{1,6})|[\\da-z]{1,31});/gi;\n\n/**\n * Decode markdown strings (which occur in places such as fenced code info\n * strings, destinations, labels, and titles).\n *\n * The “string” content type allows character escapes and -references.\n * This decodes those.\n *\n * @param {string} value\n *   Value to decode.\n * @returns {string}\n *   Decoded value.\n */\nexport function decodeString(value) {\n  return value.replace(characterEscapeOrReference, decode);\n}\n\n/**\n * @param {string} $0\n *   Match.\n * @param {string} $1\n *   Character escape.\n * @param {string} $2\n *   Character reference.\n * @returns {string}\n *   Decoded value\n */\nfunction decode($0, $1, $2) {\n  if ($1) {\n    // Escape.\n    return $1;\n  }\n\n  // Reference.\n  const head = $2.charCodeAt(0);\n  if (head === 35) {\n    const head = $2.charCodeAt(1);\n    const hex = head === 120 || head === 88;\n    return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10);\n  }\n  return decodeNamedCharacterReference($2) || $0;\n}"],"names":["characterEscapeOrReference","decodeString","value","decode","$0","$1","$2","head","hex","decodeNumericCharacterReference","decodeNamedCharacterReference"],"mappings":";;AAEA,MAAMA,IAA6B;AAc5B,SAASC,EAAaC,GAAO;AAClC,SAAOA,EAAM,QAAQF,GAA4BG,CAAM;AACzD;AAYA,SAASA,EAAOC,GAAIC,GAAIC,GAAI;AAC1B,MAAID;AAEF,WAAOA;AAKT,MADaC,EAAG,WAAW,CAAC,MACf,IAAI;AACf,UAAMC,IAAOD,EAAG,WAAW,CAAC,GACtBE,IAAMD,MAAS,OAAOA,MAAS;AACrC,WAAOE,EAAgCH,EAAG,MAAME,IAAM,IAAI,CAAC,GAAGA,IAAM,KAAK,EAAE;AAAA,EAC/E;AACE,SAAOE,EAA8BJ,CAAE,KAAKF;AAC9C;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-util-html-tag-name@2.0.1/node_modules/micromark-util-html-tag-name/index.es.js

@@ -0,0 +1,69 @@
+const e = [
+  "address",
+  "article",
+  "aside",
+  "base",
+  "basefont",
+  "blockquote",
+  "body",
+  "caption",
+  "center",
+  "col",
+  "colgroup",
+  "dd",
+  "details",
+  "dialog",
+  "dir",
+  "div",
+  "dl",
+  "dt",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "frame",
+  "frameset",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "header",
+  "hr",
+  "html",
+  "iframe",
+  "legend",
+  "li",
+  "link",
+  "main",
+  "menu",
+  "menuitem",
+  "nav",
+  "noframes",
+  "ol",
+  "optgroup",
+  "option",
+  "p",
+  "param",
+  "search",
+  "section",
+  "summary",
+  "table",
+  "tbody",
+  "td",
+  "tfoot",
+  "th",
+  "thead",
+  "title",
+  "tr",
+  "track",
+  "ul"
+], t = ["pre", "script", "style", "textarea"];
+export {
+  e as htmlBlockNames,
+  t as htmlRawNames
+};
+//# sourceMappingURL=index.es.js.map

package/dist/node_modules/.pnpm/micromark-util-html-tag-name@2.0.1/node_modules/micromark-util-html-tag-name/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../node_modules/.pnpm/micromark-util-html-tag-name@2.0.1/node_modules/micromark-util-html-tag-name/index.js"],"sourcesContent":["/**\n * List of lowercase HTML “block” tag names.\n *\n * The list, when parsing HTML (flow), results in more relaxed rules (condition\n * 6).\n * Because they are known blocks, the HTML-like syntax doesn’t have to be\n * strictly parsed.\n * For tag names not in this list, a more strict algorithm (condition 7) is used\n * to detect whether the HTML-like syntax is seen as HTML (flow) or not.\n *\n * This is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `search` was added in `CommonMark@0.31`.\n */\nexport const htmlBlockNames = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'search',\n  'section',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n]\n\n/**\n * List of lowercase HTML “raw” tag names.\n *\n * The list, when parsing HTML (flow), results in HTML that can include lines\n * without exiting, until a closing tag also in this list is found (condition\n * 1).\n *\n * This module is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `textarea` was added in `CommonMark@0.30`.\n */\nexport const htmlRawNames = ['pre', 'script', 'style', 'textarea']\n"],"names":["htmlBlockNames","htmlRawNames"],"mappings":"AAeY,MAACA,IAAiB;AAAA,EAC5B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAcaC,IAAe,CAAC,OAAO,UAAU,SAAS,UAAU;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-util-normalize-identifier@2.0.1/node_modules/micromark-util-normalize-identifier/index.es.js

@@ -0,0 +1,7 @@
+function r(e) {
+  return e.replace(/[\t\n\r ]+/g, " ").replace(/^ | $/g, "").toLowerCase().toUpperCase();
+}
+export {
+  r as normalizeIdentifier
+};
+//# sourceMappingURL=index.es.js.map

package/dist/node_modules/.pnpm/micromark-util-normalize-identifier@2.0.1/node_modules/micromark-util-normalize-identifier/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../node_modules/.pnpm/micromark-util-normalize-identifier@2.0.1/node_modules/micromark-util-normalize-identifier/index.js"],"sourcesContent":["/**\n * Normalize an identifier (as found in references, definitions).\n *\n * Collapses markdown whitespace, trim, and then lower- and uppercase.\n *\n * Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their\n * lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different\n * uppercase character (U+0398 (`Θ`)).\n * So, to get a canonical form, we perform both lower- and uppercase.\n *\n * Using uppercase last makes sure keys will never interact with default\n * prototypal values (such as `constructor`): nothing in the prototype of\n * `Object` is uppercase.\n *\n * @param {string} value\n *   Identifier to normalize.\n * @returns {string}\n *   Normalized identifier.\n */\nexport function normalizeIdentifier(value) {\n  return value\n  // Collapse markdown whitespace.\n  .replace(/[\\t\\n\\r ]+/g, \" \")\n  // Trim.\n  .replace(/^ | $/g, '')\n  // Some characters are considered “uppercase”, but if their lowercase\n  // counterpart is uppercased will result in a different uppercase\n  // character.\n  // Hence, to get that form, we perform both lower- and uppercase.\n  // Upper case makes sure keys will not interact with default prototypal\n  // methods: no method is uppercase.\n  .toLowerCase().toUpperCase();\n}"],"names":["normalizeIdentifier","value"],"mappings":"AAmBO,SAASA,EAAoBC,GAAO;AACzC,SAAOA,EAEN,QAAQ,eAAe,GAAG,EAE1B,QAAQ,UAAU,EAAE,EAOpB,YAAW,EAAG,YAAa;AAC9B;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-util-resolve-all@2.0.1/node_modules/micromark-util-resolve-all/index.es.js

@@ -0,0 +1,13 @@
+function c(o, e, r) {
+  const i = [];
+  let n = -1;
+  for (; ++n < o.length; ) {
+    const l = o[n].resolveAll;
+    l && !i.includes(l) && (e = l(e, r), i.push(l));
+  }
+  return e;
+}
+export {
+  c as resolveAll
+};
+//# sourceMappingURL=index.es.js.map

package/dist/node_modules/.pnpm/micromark-util-resolve-all@2.0.1/node_modules/micromark-util-resolve-all/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../node_modules/.pnpm/micromark-util-resolve-all@2.0.1/node_modules/micromark-util-resolve-all/index.js"],"sourcesContent":["/**\n * @import {Event, Resolver, TokenizeContext} from 'micromark-util-types'\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {ReadonlyArray<{resolveAll?: Resolver | undefined}>} constructs\n *   List of constructs, optionally with `resolveAll`s.\n * @param {Array<Event>} events\n *   List of events.\n * @param {TokenizeContext} context\n *   Context used by `tokenize`.\n * @returns {Array<Event>}\n *   Changed events.\n */\nexport function resolveAll(constructs, events, context) {\n  /** @type {Array<Resolver>} */\n  const called = []\n  let index = -1\n\n  while (++index < constructs.length) {\n    const resolve = constructs[index].resolveAll\n\n    if (resolve && !called.includes(resolve)) {\n      events = resolve(events, context)\n      called.push(resolve)\n    }\n  }\n\n  return events\n}\n"],"names":["resolveAll","constructs","events","context","called","index","resolve"],"mappings":"AAgBO,SAASA,EAAWC,GAAYC,GAAQC,GAAS;AAEtD,QAAMC,IAAS,CAAA;AACf,MAAIC,IAAQ;AAEZ,SAAO,EAAEA,IAAQJ,EAAW,UAAQ;AAClC,UAAMK,IAAUL,EAAWI,CAAK,EAAE;AAElC,IAAIC,KAAW,CAACF,EAAO,SAASE,CAAO,MACrCJ,IAASI,EAAQJ,GAAQC,CAAO,GAChCC,EAAO,KAAKE,CAAO;AAAA,EAEzB;AAEE,SAAOJ;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-util-sanitize-uri@2.0.1/node_modules/micromark-util-sanitize-uri/index.es.js

@@ -0,0 +1,24 @@
+import { asciiAlphanumeric as f } from "../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+function h(t) {
+  const s = [];
+  let r = -1, n = 0, i = 0;
+  for (; ++r < t.length; ) {
+    const e = t.charCodeAt(r);
+    let o = "";
+    if (e === 37 && f(t.charCodeAt(r + 1)) && f(t.charCodeAt(r + 2)))
+      i = 2;
+    else if (e < 128)
+      /[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(e)) || (o = String.fromCharCode(e));
+    else if (e > 55295 && e < 57344) {
+      const c = t.charCodeAt(r + 1);
+      e < 56320 && c > 56319 && c < 57344 ? (o = String.fromCharCode(e, c), i = 1) : o = "�";
+    } else
+      o = String.fromCharCode(e);
+    o && (s.push(t.slice(n, r), encodeURIComponent(o)), n = r + i + 1, o = ""), i && (r += i, i = 0);
+  }
+  return s.join("") + t.slice(n);
+}
+export {
+  h as normalizeUri
+};
+//# sourceMappingURL=index.es.js.map

package/dist/node_modules/.pnpm/micromark-util-sanitize-uri@2.0.1/node_modules/micromark-util-sanitize-uri/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../node_modules/.pnpm/micromark-util-sanitize-uri@2.0.1/node_modules/micromark-util-sanitize-uri/index.js"],"sourcesContent":["import { asciiAlphanumeric } from 'micromark-util-character';\nimport { encode } from 'micromark-util-encode';\n/**\n * Make a value safe for injection as a URL.\n *\n * This encodes unsafe characters with percent-encoding and skips already\n * encoded sequences (see `normalizeUri`).\n * Further unsafe characters are encoded as character references (see\n * `micromark-util-encode`).\n *\n * A regex of allowed protocols can be given, in which case the URL is\n * sanitized.\n * For example, `/^(https?|ircs?|mailto|xmpp)$/i` can be used for `a[href]`, or\n * `/^https?$/i` for `img[src]` (this is what `github.com` allows).\n * If the URL includes an unknown protocol (one not matched by `protocol`, such\n * as a dangerous example, `javascript:`), the value is ignored.\n *\n * @param {string | null | undefined} url\n *   URI to sanitize.\n * @param {RegExp | null | undefined} [protocol]\n *   Allowed protocols.\n * @returns {string}\n *   Sanitized URI.\n */\nexport function sanitizeUri(url, protocol) {\n  const value = encode(normalizeUri(url || ''));\n  if (!protocol) {\n    return value;\n  }\n  const colon = value.indexOf(':');\n  const questionMark = value.indexOf('?');\n  const numberSign = value.indexOf('#');\n  const slash = value.indexOf('/');\n  if (\n  // If there is no protocol, it’s relative.\n  colon < 0 ||\n  // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.\n  slash > -1 && colon > slash || questionMark > -1 && colon > questionMark || numberSign > -1 && colon > numberSign ||\n  // It is a protocol, it should be allowed.\n  protocol.test(value.slice(0, colon))) {\n    return value;\n  }\n  return '';\n}\n\n/**\n * Normalize a URL.\n *\n * Encode unsafe characters with percent-encoding, skipping already encoded\n * sequences.\n *\n * @param {string} value\n *   URI to normalize.\n * @returns {string}\n *   Normalized URI.\n */\nexport function normalizeUri(value) {\n  /** @type {Array<string>} */\n  const result = [];\n  let index = -1;\n  let start = 0;\n  let skip = 0;\n  while (++index < value.length) {\n    const code = value.charCodeAt(index);\n    /** @type {string} */\n    let replace = '';\n\n    // A correct percent encoded value.\n    if (code === 37 && asciiAlphanumeric(value.charCodeAt(index + 1)) && asciiAlphanumeric(value.charCodeAt(index + 2))) {\n      skip = 2;\n    }\n    // ASCII.\n    else if (code < 128) {\n      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {\n        replace = String.fromCharCode(code);\n      }\n    }\n    // Astral.\n    else if (code > 55_295 && code < 57_344) {\n      const next = value.charCodeAt(index + 1);\n\n      // A correct surrogate pair.\n      if (code < 56_320 && next > 56_319 && next < 57_344) {\n        replace = String.fromCharCode(code, next);\n        skip = 1;\n      }\n      // Lone surrogate.\n      else {\n        replace = \"\\uFFFD\";\n      }\n    }\n    // Unicode.\n    else {\n      replace = String.fromCharCode(code);\n    }\n    if (replace) {\n      result.push(value.slice(start, index), encodeURIComponent(replace));\n      start = index + skip + 1;\n      replace = '';\n    }\n    if (skip) {\n      index += skip;\n      skip = 0;\n    }\n  }\n  return result.join('') + value.slice(start);\n}"],"names":["normalizeUri","value","result","index","start","skip","code","replace","asciiAlphanumeric","next"],"mappings":";AAwDO,SAASA,EAAaC,GAAO;AAElC,QAAMC,IAAS,CAAE;AACjB,MAAIC,IAAQ,IACRC,IAAQ,GACRC,IAAO;AACX,SAAO,EAAEF,IAAQF,EAAM,UAAQ;AAC7B,UAAMK,IAAOL,EAAM,WAAWE,CAAK;AAEnC,QAAII,IAAU;AAGd,QAAID,MAAS,MAAME,EAAkBP,EAAM,WAAWE,IAAQ,CAAC,CAAC,KAAKK,EAAkBP,EAAM,WAAWE,IAAQ,CAAC,CAAC;AAChH,MAAAE,IAAO;AAAA,aAGAC,IAAO;AACd,MAAK,oBAAoB,KAAK,OAAO,aAAaA,CAAI,CAAC,MACrDC,IAAU,OAAO,aAAaD,CAAI;AAAA,aAI7BA,IAAO,SAAUA,IAAO,OAAQ;AACvC,YAAMG,IAAOR,EAAM,WAAWE,IAAQ,CAAC;AAGvC,MAAIG,IAAO,SAAUG,IAAO,SAAUA,IAAO,SAC3CF,IAAU,OAAO,aAAaD,GAAMG,CAAI,GACxCJ,IAAO,KAIPE,IAAU;AAAA,IAElB;AAGM,MAAAA,IAAU,OAAO,aAAaD,CAAI;AAEpC,IAAIC,MACFL,EAAO,KAAKD,EAAM,MAAMG,GAAOD,CAAK,GAAG,mBAAmBI,CAAO,CAAC,GAClEH,IAAQD,IAAQE,IAAO,GACvBE,IAAU,KAERF,MACFF,KAASE,GACTA,IAAO;AAAA,EAEb;AACE,SAAOH,EAAO,KAAK,EAAE,IAAID,EAAM,MAAMG,CAAK;AAC5C;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark-util-subtokenize@2.1.0/node_modules/micromark-util-subtokenize/index.es.js

@@ -0,0 +1,56 @@
+import { splice as I } from "../../../micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.es.js";
+import { SpliceBuffer as _ } from "./lib/splice-buffer.es.js";
+function b(u) {
+  const c = {};
+  let e = -1, p, o, n, s, f, l, g;
+  const r = new _(u);
+  for (; ++e < r.length; ) {
+    for (; e in c; )
+      e = c[e];
+    if (p = r.get(e), e && p[1].type === "chunkFlow" && r.get(e - 1)[1].type === "listItemPrefix" && (l = p[1]._tokenizer.events, n = 0, n < l.length && l[n][1].type === "lineEndingBlank" && (n += 2), n < l.length && l[n][1].type === "content"))
+      for (; ++n < l.length && l[n][1].type !== "content"; )
+        l[n][1].type === "chunkText" && (l[n][1]._isInFirstContentOfListItem = !0, n++);
+    if (p[0] === "enter")
+      p[1].contentType && (Object.assign(c, x(r, e)), e = c[e], g = !0);
+    else if (p[1]._container) {
+      for (n = e, o = void 0; n--; )
+        if (s = r.get(n), s[1].type === "lineEnding" || s[1].type === "lineEndingBlank")
+          s[0] === "enter" && (o && (r.get(o)[1].type = "lineEndingBlank"), s[1].type = "lineEnding", o = n);
+        else if (!(s[1].type === "linePrefix" || s[1].type === "listItemIndent")) break;
+      o && (p[1].end = {
+        ...r.get(o)[1].start
+      }, f = r.slice(o, e), f.unshift(p), r.splice(o, e - o + 1, f));
+    }
+  }
+  return I(u, 0, Number.POSITIVE_INFINITY, r.slice(0)), !g;
+}
+function x(u, c) {
+  const e = u.get(c)[1], p = u.get(c)[2];
+  let o = c - 1;
+  const n = [];
+  let s = e._tokenizer;
+  s || (s = p.parser[e.contentType](e.start), e._contentTypeTextTrailing && (s._contentTypeTextTrailing = !0));
+  const f = s.events, l = [], g = {};
+  let r, k, i = -1, t = e, a = 0, d = 0;
+  const h = [d];
+  for (; t; ) {
+    for (; u.get(++o)[1] !== t; )
+      ;
+    n.push(o), t._tokenizer || (r = p.sliceStream(t), t.next || r.push(null), k && s.defineSkip(t.start), t._isInFirstContentOfListItem && (s._gfmTasklistFirstContentOfListItem = !0), s.write(r), t._isInFirstContentOfListItem && (s._gfmTasklistFirstContentOfListItem = void 0)), k = t, t = t.next;
+  }
+  for (t = e; ++i < f.length; )
+    // Find a void token that includes a break.
+    f[i][0] === "exit" && f[i - 1][0] === "enter" && f[i][1].type === f[i - 1][1].type && f[i][1].start.line !== f[i][1].end.line && (d = i + 1, h.push(d), t._tokenizer = void 0, t.previous = void 0, t = t.next);
+  for (s.events = [], t ? (t._tokenizer = void 0, t.previous = void 0) : h.pop(), i = h.length; i--; ) {
+    const y = f.slice(h[i], h[i + 1]), m = n.pop();
+    l.push([m, m + y.length - 1]), u.splice(m, 2, y);
+  }
+  for (l.reverse(), i = -1; ++i < l.length; )
+    g[a + l[i][0]] = a + l[i][1], a += l[i][1] - l[i][0] - 1;
+  return g;
+}
+export {
+  _ as SpliceBuffer,
+  b as subtokenize
+};
+//# sourceMappingURL=index.es.js.map

package/dist/node_modules/.pnpm/micromark-util-subtokenize@2.1.0/node_modules/micromark-util-subtokenize/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../node_modules/.pnpm/micromark-util-subtokenize@2.1.0/node_modules/micromark-util-subtokenize/index.js"],"sourcesContent":["/**\n * @import {Chunk, Event, Token} from 'micromark-util-types'\n */\n\nimport { splice } from 'micromark-util-chunked';\nimport { SpliceBuffer } from './lib/splice-buffer.js';\n\n// Hidden API exposed for testing.\nexport { SpliceBuffer } from './lib/splice-buffer.js';\n\n/**\n * Tokenize subcontent.\n *\n * @param {Array<Event>} eventsArray\n *   List of events.\n * @returns {boolean}\n *   Whether subtokens were found.\n */\n// eslint-disable-next-line complexity\nexport function subtokenize(eventsArray) {\n  /** @type {Record<string, number>} */\n  const jumps = {};\n  let index = -1;\n  /** @type {Event} */\n  let event;\n  /** @type {number | undefined} */\n  let lineIndex;\n  /** @type {number} */\n  let otherIndex;\n  /** @type {Event} */\n  let otherEvent;\n  /** @type {Array<Event>} */\n  let parameters;\n  /** @type {Array<Event>} */\n  let subevents;\n  /** @type {boolean | undefined} */\n  let more;\n  const events = new SpliceBuffer(eventsArray);\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index];\n    }\n    event = events.get(index);\n\n    // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n    if (index && event[1].type === \"chunkFlow\" && events.get(index - 1)[1].type === \"listItemPrefix\") {\n      subevents = event[1]._tokenizer.events;\n      otherIndex = 0;\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === \"lineEndingBlank\") {\n        otherIndex += 2;\n      }\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === \"content\") {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === \"content\") {\n            break;\n          }\n          if (subevents[otherIndex][1].type === \"chunkText\") {\n            subevents[otherIndex][1]._isInFirstContentOfListItem = true;\n            otherIndex++;\n          }\n        }\n      }\n    }\n\n    // Enter.\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        Object.assign(jumps, subcontent(events, index));\n        index = jumps[index];\n        more = true;\n      }\n    }\n    // Exit.\n    else if (event[1]._container) {\n      otherIndex = index;\n      lineIndex = undefined;\n      while (otherIndex--) {\n        otherEvent = events.get(otherIndex);\n        if (otherEvent[1].type === \"lineEnding\" || otherEvent[1].type === \"lineEndingBlank\") {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events.get(lineIndex)[1].type = \"lineEndingBlank\";\n            }\n            otherEvent[1].type = \"lineEnding\";\n            lineIndex = otherIndex;\n          }\n        } else if (otherEvent[1].type === \"linePrefix\" || otherEvent[1].type === \"listItemIndent\") {\n          // Move past.\n        } else {\n          break;\n        }\n      }\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = {\n          ...events.get(lineIndex)[1].start\n        };\n\n        // Switch container exit w/ line endings.\n        parameters = events.slice(lineIndex, index);\n        parameters.unshift(event);\n        events.splice(lineIndex, index - lineIndex + 1, parameters);\n      }\n    }\n  }\n\n  // The changes to the `events` buffer must be copied back into the eventsArray\n  splice(eventsArray, 0, Number.POSITIVE_INFINITY, events.slice(0));\n  return !more;\n}\n\n/**\n * Tokenize embedded tokens.\n *\n * @param {SpliceBuffer<Event>} events\n *   Events.\n * @param {number} eventIndex\n *   Index.\n * @returns {Record<string, number>}\n *   Gaps.\n */\nfunction subcontent(events, eventIndex) {\n  const token = events.get(eventIndex)[1];\n  const context = events.get(eventIndex)[2];\n  let startPosition = eventIndex - 1;\n  /** @type {Array<number>} */\n  const startPositions = [];\n  let tokenizer = token._tokenizer;\n  if (!tokenizer) {\n    tokenizer = context.parser[token.contentType](token.start);\n    if (token._contentTypeTextTrailing) {\n      tokenizer._contentTypeTextTrailing = true;\n    }\n  }\n  const childEvents = tokenizer.events;\n  /** @type {Array<[number, number]>} */\n  const jumps = [];\n  /** @type {Record<string, number>} */\n  const gaps = {};\n  /** @type {Array<Chunk>} */\n  let stream;\n  /** @type {Token | undefined} */\n  let previous;\n  let index = -1;\n  /** @type {Token | undefined} */\n  let current = token;\n  let adjust = 0;\n  let start = 0;\n  const breaks = [start];\n\n  // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n  while (current) {\n    // Find the position of the event for this token.\n    while (events.get(++startPosition)[1] !== current) {\n      // Empty.\n    }\n    startPositions.push(startPosition);\n    if (!current._tokenizer) {\n      stream = context.sliceStream(current);\n      if (!current.next) {\n        stream.push(null);\n      }\n      if (previous) {\n        tokenizer.defineSkip(current.start);\n      }\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true;\n      }\n      tokenizer.write(stream);\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined;\n      }\n    }\n\n    // Unravel the next token.\n    previous = current;\n    current = current.next;\n  }\n\n  // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n  current = token;\n  while (++index < childEvents.length) {\n    if (\n    // Find a void token that includes a break.\n    childEvents[index][0] === 'exit' && childEvents[index - 1][0] === 'enter' && childEvents[index][1].type === childEvents[index - 1][1].type && childEvents[index][1].start.line !== childEvents[index][1].end.line) {\n      start = index + 1;\n      breaks.push(start);\n      // Help GC.\n      current._tokenizer = undefined;\n      current.previous = undefined;\n      current = current.next;\n    }\n  }\n\n  // Help GC.\n  tokenizer.events = [];\n\n  // If there’s one more token (which is the cases for lines that end in an\n  // EOF), that’s perfect: the last point we found starts it.\n  // If there isn’t then make sure any remaining content is added to it.\n  if (current) {\n    // Help GC.\n    current._tokenizer = undefined;\n    current.previous = undefined;\n  } else {\n    breaks.pop();\n  }\n\n  // Now splice the events from the subtokenizer into the current events,\n  // moving back to front so that splice indices aren’t affected.\n  index = breaks.length;\n  while (index--) {\n    const slice = childEvents.slice(breaks[index], breaks[index + 1]);\n    const start = startPositions.pop();\n    jumps.push([start, start + slice.length - 1]);\n    events.splice(start, 2, slice);\n  }\n  jumps.reverse();\n  index = -1;\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1];\n    adjust += jumps[index][1] - jumps[index][0] - 1;\n  }\n  return gaps;\n}"],"names":["subtokenize","eventsArray","jumps","index","event","lineIndex","otherIndex","otherEvent","parameters","subevents","more","events","SpliceBuffer","subcontent","splice","eventIndex","token","context","startPosition","startPositions","tokenizer","childEvents","gaps","stream","previous","current","adjust","start","breaks","slice"],"mappings":"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","x_google_ignoreList":[0]}