@easyv/biz-components 0.0.20 → 0.0.22

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

@@ -1 +1 @@
-{"version":3,"file":"index.es.js","sources":["../../../../../../../../node_modules/.pnpm/micromark-factory-label@2.0.1/node_modules/micromark-factory-label/index.js"],"sourcesContent":["/**\n * @import {\n *   Effects,\n *   State,\n *   TokenizeContext,\n *   TokenType\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/**\n * Parse labels.\n *\n * > 👉 **Note**: labels in markdown are capped at 999 characters in the string.\n *\n * ###### Examples\n *\n * ```markdown\n * [a]\n * [a\n * b]\n * [a\\]b]\n * ```\n *\n * @this {TokenizeContext}\n *   Tokenize context.\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 label (`[a]`).\n * @param {TokenType} markerType\n *   Type for the markers (`[` and `]`).\n * @param {TokenType} stringType\n *   Type for the identifier (`a`).\n * @returns {State}\n *   Start state.\n */\nexport function factoryLabel(effects, ok, nok, type, markerType, stringType) {\n  const self = this;\n  let size = 0;\n  /** @type {boolean} */\n  let seen;\n  return start;\n\n  /**\n   * Start of label.\n   *\n   * ```markdown\n   * > | [a]\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(type);\n    effects.enter(markerType);\n    effects.consume(code);\n    effects.exit(markerType);\n    effects.enter(stringType);\n    return atBreak;\n  }\n\n  /**\n   * In label, at something, before something else.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (size > 999 || code === null || code === 91 || code === 93 && !seen ||\n    // To do: remove in the future once we’ve switched from\n    // `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n    // which doesn’t need this.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    code === 94 && !size && '_hiddenFootnoteSupport' in self.parser.constructs) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.exit(stringType);\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n\n    // To do: indent? Link chunks and EOLs together?\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return atBreak;\n    }\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return labelInside(code);\n  }\n\n  /**\n   * In label, in text.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelInside(code) {\n    if (code === null || code === 91 || code === 93 || markdownLineEnding(code) || size++ > 999) {\n      effects.exit(\"chunkString\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    if (!seen) seen = !markdownSpace(code);\n    return code === 92 ? labelEscape : labelInside;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | [a\\*a]\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return labelInside;\n    }\n    return labelInside(code);\n  }\n}"],"names":["factoryLabel","effects","ok","nok","type","markerType","stringType","self","size","seen","start","code","atBreak","markdownLineEnding","labelInside","markdownSpace","labelEscape"],"mappings":";AAyCO,SAASA,EAAaC,GAASC,GAAIC,GAAKC,GAAMC,GAAYC,GAAY;AAC3E,QAAMC,IAAO;AACb,MAAIC,IAAO,GAEPC;AACJ,SAAOC;AAYP,WAASA,EAAMC,GAAM;AACnB,WAAAV,EAAQ,MAAMG,CAAI,GAClBH,EAAQ,MAAMI,CAAU,GACxBJ,EAAQ,QAAQU,CAAI,GACpBV,EAAQ,KAAKI,CAAU,GACvBJ,EAAQ,MAAMK,CAAU,GACjBM;AAAA,EACX;AAYE,WAASA,EAAQD,GAAM;AACrB,WAAIH,IAAO,OAAOG,MAAS,QAAQA,MAAS,MAAMA,MAAS,MAAM,CAACF;AAAA;AAAA;AAAA;AAAA;AAAA,IAMlEE,MAAS,MAAM,CAACH,KAAQ,4BAA4BD,EAAK,OAAO,aACvDJ,EAAIQ,CAAI,IAEbA,MAAS,MACXV,EAAQ,KAAKK,CAAU,GACvBL,EAAQ,MAAMI,CAAU,GACxBJ,EAAQ,QAAQU,CAAI,GACpBV,EAAQ,KAAKI,CAAU,GACvBJ,EAAQ,KAAKG,CAAI,GACVF,KAILW,EAAmBF,CAAI,KACzBV,EAAQ,MAAM,YAAY,GAC1BA,EAAQ,QAAQU,CAAI,GACpBV,EAAQ,KAAK,YAAY,GAClBW,MAETX,EAAQ,MAAM,eAAe;AAAA,MAC3B,aAAa;AAAA,IACnB,CAAK,GACMa,EAAYH,CAAI;AAAA,EAC3B;AAYE,WAASG,EAAYH,GAAM;AACzB,WAAIA,MAAS,QAAQA,MAAS,MAAMA,MAAS,MAAME,EAAmBF,CAAI,KAAKH,MAAS,OACtFP,EAAQ,KAAK,aAAa,GACnBW,EAAQD,CAAI,MAErBV,EAAQ,QAAQU,CAAI,GACfF,MAAMA,IAAO,CAACM,EAAcJ,CAAI,IAC9BA,MAAS,KAAKK,IAAcF;AAAA,EACvC;AAYE,WAASE,EAAYL,GAAM;AACzB,WAAIA,MAAS,MAAMA,MAAS,MAAMA,MAAS,MACzCV,EAAQ,QAAQU,CAAI,GACpBH,KACOM,KAEFA,EAAYH,CAAI;AAAA,EAC3B;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../node_modules/.pnpm/micromark-factory-label@2.0.1/node_modules/micromark-factory-label/index.js"],"sourcesContent":["/**\n * @import {\n *   Effects,\n *   State,\n *   TokenizeContext,\n *   TokenType\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/**\n * Parse labels.\n *\n * > 👉 **Note**: labels in markdown are capped at 999 characters in the string.\n *\n * ###### Examples\n *\n * ```markdown\n * [a]\n * [a\n * b]\n * [a\\]b]\n * ```\n *\n * @this {TokenizeContext}\n *   Tokenize context.\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 label (`[a]`).\n * @param {TokenType} markerType\n *   Type for the markers (`[` and `]`).\n * @param {TokenType} stringType\n *   Type for the identifier (`a`).\n * @returns {State}\n *   Start state.\n */\nexport function factoryLabel(effects, ok, nok, type, markerType, stringType) {\n  const self = this;\n  let size = 0;\n  /** @type {boolean} */\n  let seen;\n  return start;\n\n  /**\n   * Start of label.\n   *\n   * ```markdown\n   * > | [a]\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(type);\n    effects.enter(markerType);\n    effects.consume(code);\n    effects.exit(markerType);\n    effects.enter(stringType);\n    return atBreak;\n  }\n\n  /**\n   * In label, at something, before something else.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (size > 999 || code === null || code === 91 || code === 93 && !seen ||\n    // To do: remove in the future once we’ve switched from\n    // `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n    // which doesn’t need this.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    code === 94 && !size && '_hiddenFootnoteSupport' in self.parser.constructs) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.exit(stringType);\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n\n    // To do: indent? Link chunks and EOLs together?\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return atBreak;\n    }\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return labelInside(code);\n  }\n\n  /**\n   * In label, in text.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelInside(code) {\n    if (code === null || code === 91 || code === 93 || markdownLineEnding(code) || size++ > 999) {\n      effects.exit(\"chunkString\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    if (!seen) seen = !markdownSpace(code);\n    return code === 92 ? labelEscape : labelInside;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | [a\\*a]\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return labelInside;\n    }\n    return labelInside(code);\n  }\n}"],"names":[],"mappings":";AAyCO,SAAS,aAAa,SAAS,IAAI,KAAK,MAAM,YAAY,YAAY;AAC3E,QAAM,OAAO;AACb,MAAI,OAAO;AAEX,MAAI;AACJ,SAAO;AAYP,WAAS,MAAM,MAAM;AACnB,YAAQ,MAAM,IAAI;AAClB,YAAQ,MAAM,UAAU;AACxB,YAAQ,QAAQ,IAAI;AACpB,YAAQ,KAAK,UAAU;AACvB,YAAQ,MAAM,UAAU;AACxB,WAAO;AAAA,EACX;AAYE,WAAS,QAAQ,MAAM;AACrB,QAAI,OAAO,OAAO,SAAS,QAAQ,SAAS,MAAM,SAAS,MAAM,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,IAMlE,SAAS,MAAM,CAAC,QAAQ,4BAA4B,KAAK,OAAO,YAAY;AAC1E,aAAO,IAAI,IAAI;AAAA,IACrB;AACI,QAAI,SAAS,IAAI;AACf,cAAQ,KAAK,UAAU;AACvB,cAAQ,MAAM,UAAU;AACxB,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,UAAU;AACvB,cAAQ,KAAK,IAAI;AACjB,aAAO;AAAA,IACb;AAGI,QAAI,mBAAmB,IAAI,GAAG;AAC5B,cAAQ,MAAM,YAAY;AAC1B,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,YAAY;AACzB,aAAO;AAAA,IACb;AACI,YAAQ,MAAM,eAAe;AAAA,MAC3B,aAAa;AAAA,IACnB,CAAK;AACD,WAAO,YAAY,IAAI;AAAA,EAC3B;AAYE,WAAS,YAAY,MAAM;AACzB,QAAI,SAAS,QAAQ,SAAS,MAAM,SAAS,MAAM,mBAAmB,IAAI,KAAK,SAAS,KAAK;AAC3F,cAAQ,KAAK,aAAa;AAC1B,aAAO,QAAQ,IAAI;AAAA,IACzB;AACI,YAAQ,QAAQ,IAAI;AACpB,QAAI,CAAC,KAAM,QAAO,CAAC,cAAc,IAAI;AACrC,WAAO,SAAS,KAAK,cAAc;AAAA,EACvC;AAYE,WAAS,YAAY,MAAM;AACzB,QAAI,SAAS,MAAM,SAAS,MAAM,SAAS,IAAI;AAC7C,cAAQ,QAAQ,IAAI;AACpB;AACA,aAAO;AAAA,IACb;AACI,WAAO,YAAY,IAAI;AAAA,EAC3B;AACA;","x_google_ignoreList":[0]}

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

@@ -1,16 +1,25 @@
-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);
+import { markdownSpace } from "../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+function factorySpace(effects, ok, type, max) {
+  const limit = max ? max - 1 : Number.POSITIVE_INFINITY;
+  let size = 0;
+  return start;
+  function start(code) {
+    if (markdownSpace(code)) {
+      effects.enter(type);
+      return prefix(code);
+    }
+    return ok(code);
   }
-  function e(r) {
-    return m(r) && I++ < o ? (n.consume(r), e) : (n.exit(i), t(r));
+  function prefix(code) {
+    if (markdownSpace(code) && size++ < limit) {
+      effects.consume(code);
+      return prefix;
+    }
+    effects.exit(type);
+    return ok(code);
   }
 }
 export {
-  p as factorySpace
+  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

@@ -1 +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]}
+{"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":[],"mappings":";AAwCO,SAAS,aAAa,SAAS,IAAI,MAAM,KAAK;AACnD,QAAM,QAAQ,MAAM,MAAM,IAAI,OAAO;AACrC,MAAI,OAAO;AACX,SAAO;AAGP,WAAS,MAAM,MAAM;AACnB,QAAI,cAAc,IAAI,GAAG;AACvB,cAAQ,MAAM,IAAI;AAClB,aAAO,OAAO,IAAI;AAAA,IACxB;AACI,WAAO,GAAG,IAAI;AAAA,EAClB;AAGE,WAAS,OAAO,MAAM;AACpB,QAAI,cAAc,IAAI,KAAK,SAAS,OAAO;AACzC,cAAQ,QAAQ,IAAI;AACpB,aAAO;AAAA,IACb;AACI,YAAQ,KAAK,IAAI;AACjB,WAAO,GAAG,IAAI;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

@@ -1,27 +1,66 @@
-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);
+import { factorySpace } from "../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js";
+import { markdownLineEnding } from "../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+function factoryTitle(effects, ok, nok, type, markerType, stringType) {
+  let marker;
+  return start;
+  function start(code) {
+    if (code === 34 || code === 39 || code === 40) {
+      effects.enter(type);
+      effects.enter(markerType);
+      effects.consume(code);
+      effects.exit(markerType);
+      marker = code === 40 ? 41 : code;
+      return begin;
+    }
+    return nok(code);
   }
-  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 begin(code) {
+    if (code === marker) {
+      effects.enter(markerType);
+      effects.consume(code);
+      effects.exit(markerType);
+      effects.exit(type);
+      return ok;
+    }
+    effects.enter(stringType);
+    return atBreak(code);
   }
-  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", {
+  function atBreak(code) {
+    if (code === marker) {
+      effects.exit(stringType);
+      return begin(marker);
+    }
+    if (code === null) {
+      return nok(code);
+    }
+    if (markdownLineEnding(code)) {
+      effects.enter("lineEnding");
+      effects.consume(code);
+      effects.exit("lineEnding");
+      return factorySpace(effects, atBreak, "linePrefix");
+    }
+    effects.enter("chunkString", {
       contentType: "string"
-    }), t(n));
+    });
+    return inside(code);
   }
-  function t(n) {
-    return n === i || n === null || E(n) ? (r.exit("chunkString"), l(n)) : (r.consume(n), n === 92 ? b : t);
+  function inside(code) {
+    if (code === marker || code === null || markdownLineEnding(code)) {
+      effects.exit("chunkString");
+      return atBreak(code);
+    }
+    effects.consume(code);
+    return code === 92 ? escape : inside;
   }
-  function b(n) {
-    return n === i || n === 92 ? (r.consume(n), t) : t(n);
+  function escape(code) {
+    if (code === marker || code === 92) {
+      effects.consume(code);
+      return inside;
+    }
+    return inside(code);
   }
 }
 export {
-  B as factoryTitle
+  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

@@ -1 +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]}
+{"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":[],"mappings":";;AA0CO,SAAS,aAAa,SAAS,IAAI,KAAK,MAAM,YAAY,YAAY;AAE3E,MAAI;AACJ,SAAO;AAYP,WAAS,MAAM,MAAM;AACnB,QAAI,SAAS,MAAM,SAAS,MAAM,SAAS,IAAI;AAC7C,cAAQ,MAAM,IAAI;AAClB,cAAQ,MAAM,UAAU;AACxB,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,UAAU;AACvB,eAAS,SAAS,KAAK,KAAK;AAC5B,aAAO;AAAA,IACb;AACI,WAAO,IAAI,IAAI;AAAA,EACnB;AAcE,WAAS,MAAM,MAAM;AACnB,QAAI,SAAS,QAAQ;AACnB,cAAQ,MAAM,UAAU;AACxB,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,UAAU;AACvB,cAAQ,KAAK,IAAI;AACjB,aAAO;AAAA,IACb;AACI,YAAQ,MAAM,UAAU;AACxB,WAAO,QAAQ,IAAI;AAAA,EACvB;AAYE,WAAS,QAAQ,MAAM;AACrB,QAAI,SAAS,QAAQ;AACnB,cAAQ,KAAK,UAAU;AACvB,aAAO,MAAM,MAAM;AAAA,IACzB;AACI,QAAI,SAAS,MAAM;AACjB,aAAO,IAAI,IAAI;AAAA,IACrB;AAGI,QAAI,mBAAmB,IAAI,GAAG;AAE5B,cAAQ,MAAM,YAAY;AAC1B,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,YAAY;AACzB,aAAO,aAAa,SAAS,SAAS,YAAY;AAAA,IACxD;AACI,YAAQ,MAAM,eAAe;AAAA,MAC3B,aAAa;AAAA,IACnB,CAAK;AACD,WAAO,OAAO,IAAI;AAAA,EACtB;AAOE,WAAS,OAAO,MAAM;AACpB,QAAI,SAAS,UAAU,SAAS,QAAQ,mBAAmB,IAAI,GAAG;AAChE,cAAQ,KAAK,aAAa;AAC1B,aAAO,QAAQ,IAAI;AAAA,IACzB;AACI,YAAQ,QAAQ,IAAI;AACpB,WAAO,SAAS,KAAK,SAAS;AAAA,EAClC;AAYE,WAAS,OAAO,MAAM;AACpB,QAAI,SAAS,UAAU,SAAS,IAAI;AAClC,cAAQ,QAAQ,IAAI;AACpB,aAAO;AAAA,IACb;AACI,WAAO,OAAO,IAAI;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

@@ -1,13 +1,23 @@
-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);
+import { factorySpace } from "../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js";
+import { markdownLineEnding, markdownSpace } from "../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+function factoryWhitespace(effects, ok) {
+  let seen;
+  return start;
+  function start(code) {
+    if (markdownLineEnding(code)) {
+      effects.enter("lineEnding");
+      effects.consume(code);
+      effects.exit("lineEnding");
+      seen = true;
+      return start;
+    }
+    if (markdownSpace(code)) {
+      return factorySpace(effects, start, seen ? "linePrefix" : "lineSuffix")(code);
+    }
+    return ok(code);
   }
 }
 export {
-  f as factoryWhitespace
+  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

@@ -1 +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]}
+{"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":[],"mappings":";;AAwBO,SAAS,kBAAkB,SAAS,IAAI;AAE7C,MAAI;AACJ,SAAO;AAGP,WAAS,MAAM,MAAM;AACnB,QAAI,mBAAmB,IAAI,GAAG;AAC5B,cAAQ,MAAM,YAAY;AAC1B,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,YAAY;AACzB,aAAO;AACP,aAAO;AAAA,IACb;AACI,QAAI,cAAc,IAAI,GAAG;AACvB,aAAO,aAAa,SAAS,OAAO,OAAO,eAAe,YAAY,EAAE,IAAI;AAAA,IAClF;AACI,WAAO,GAAG,IAAI;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

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

@@ -1 +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]}
+{"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":[],"mappings":"AAqBY,MAAC,aAAa,WAAW,UAAU;AAcnC,MAAC,oBAAoB,WAAW,YAAY;AAuB5C,MAAC,aAAa,WAAW,qBAAqB;AAanD,SAAS,aAAa,MAAM;AACjC;AAAA;AAAA;AAAA,IAGE,SAAS,SAAS,OAAO,MAAM,SAAS;AAAA;AAE5C;AAaY,MAAC,aAAa,WAAW,IAAI;AAoB7B,MAAC,gBAAgB,WAAW,YAAY;AAexC,MAAC,mBAAmB,WAAW,gBAAgB;AAiBpD,SAAS,mBAAmB,MAAM;AACvC,SAAO,SAAS,QAAQ,OAAO;AACjC;AAWO,SAAS,0BAA0B,MAAM;AAC9C,SAAO,SAAS,SAAS,OAAO,KAAK,SAAS;AAChD;AAiBO,SAAS,cAAc,MAAM;AAClC,SAAO,SAAS,MAAM,SAAS,MAAM,SAAS;AAChD;AAuBY,MAAC,qBAAqB,WAAW,WAAc,iBAAA,GAAA;AAsB/C,MAAC,oBAAoB,WAAW,IAAI;AAUhD,SAAS,WAAW,OAAO;AACzB,SAAO;AAUP,WAAS,MAAM,MAAM;AACnB,WAAO,SAAS,QAAQ,OAAO,MAAM,MAAM,KAAK,OAAO,aAAa,IAAI,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

@@ -1,17 +1,37 @@
-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 splice(list, start, remove, items) {
+  const end = list.length;
+  let chunkStart = 0;
+  let parameters;
+  if (start < 0) {
+    start = -start > end ? 0 : end + start;
+  } else {
+    start = start > end ? end : start;
+  }
+  remove = remove > 0 ? remove : 0;
+  if (items.length < 1e4) {
+    parameters = Array.from(items);
+    parameters.unshift(start, remove);
+    list.splice(...parameters);
+  } else {
+    if (remove) list.splice(start, remove);
+    while (chunkStart < items.length) {
+      parameters = items.slice(chunkStart, chunkStart + 1e4);
+      parameters.unshift(start, 0);
+      list.splice(...parameters);
+      chunkStart += 1e4;
+      start += 1e4;
+    }
+  }
 }
-function g(h, n) {
-  return h.length > 0 ? (p(h, h.length, 0, n), h) : n;
+function push(list, items) {
+  if (list.length > 0) {
+    splice(list, list.length, 0, items);
+    return list;
+  }
+  return items;
 }
 export {
-  g as push,
-  p as splice
+  push,
+  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

@@ -1 +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]}
+{"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":[],"mappings":"AAsBO,SAAS,OAAO,MAAM,OAAO,QAAQ,OAAO;AACjD,QAAM,MAAM,KAAK;AACjB,MAAI,aAAa;AAEjB,MAAI;AAGJ,MAAI,QAAQ,GAAG;AACb,YAAQ,CAAC,QAAQ,MAAM,IAAI,MAAM;AAAA,EACrC,OAAS;AACL,YAAQ,QAAQ,MAAM,MAAM;AAAA,EAChC;AACE,WAAS,SAAS,IAAI,SAAS;AAG/B,MAAI,MAAM,SAAS,KAAO;AACxB,iBAAa,MAAM,KAAK,KAAK;AAC7B,eAAW,QAAQ,OAAO,MAAM;AAEhC,SAAK,OAAO,GAAG,UAAU;AAAA,EAC7B,OAAS;AAEL,QAAI,OAAQ,MAAK,OAAO,OAAO,MAAM;AAGrC,WAAO,aAAa,MAAM,QAAQ;AAChC,mBAAa,MAAM,MAAM,YAAY,aAAa,GAAK;AACvD,iBAAW,QAAQ,OAAO,CAAC;AAE3B,WAAK,OAAO,GAAG,UAAU;AACzB,oBAAc;AACd,eAAS;AAAA,IACf;AAAA,EACA;AACA;AAkBO,SAAS,KAAK,MAAM,OAAO;AAChC,MAAI,KAAK,SAAS,GAAG;AACnB,WAAO,MAAM,KAAK,QAAQ,GAAG,KAAK;AAClC,WAAO;AAAA,EACX;AACE,SAAO;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

@@ -1,11 +1,13 @@
-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))
+import { markdownLineEndingOrSpace, unicodeWhitespace, unicodePunctuation } from "../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+function classifyCharacter(code) {
+  if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {
     return 1;
-  if (t(n))
+  }
+  if (unicodePunctuation(code)) {
     return 2;
+  }
 }
 export {
-  a as classifyCharacter
+  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

@@ -1 +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]}
+{"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":[],"mappings":";AAmBO,SAAS,kBAAkB,MAAM;AACtC,MAAI,SAAS,QAAQ,0BAA0B,IAAI,KAAK,kBAAkB,IAAI,GAAG;AAC/E,WAAO;AAAA,EACX;AACE,MAAI,mBAAmB,IAAI,GAAG;AAC5B,WAAO;AAAA,EACX;AACA;","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

@@ -1,37 +1,42 @@
-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;
+import { splice } from "../../../micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.es.js";
+const hasOwnProperty = {}.hasOwnProperty;
+function combineExtensions(extensions) {
+  const all = {};
+  let index = -1;
+  while (++index < extensions.length) {
+    syntaxExtension(all, extensions[index]);
+  }
+  return all;
 }
-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(
+function syntaxExtension(all, extension) {
+  let hook;
+  for (hook in extension) {
+    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : void 0;
+    const left = maybe || (all[hook] = {});
+    const right = extension[hook];
+    let code;
+    if (right) {
+      for (code in right) {
+        if (!hasOwnProperty.call(left, code)) left[code] = [];
+        const value = right[code];
+        constructs(
           // @ts-expect-error Looks like a list.
-          i[o],
-          Array.isArray(r) ? r : r ? [r] : []
+          left[code],
+          Array.isArray(value) ? value : value ? [value] : []
         );
       }
+    }
   }
 }
-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);
+function constructs(existing, list) {
+  let index = -1;
+  const before = [];
+  while (++index < list.length) {
+    (list[index].add === "after" ? existing : before).push(list[index]);
+  }
+  splice(existing, 0, 0, before);
 }
 export {
-  d as combineExtensions
+  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

@@ -1 +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]}
+{"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":[],"mappings":";AAWA,MAAM,iBAAiB,CAAA,EAAG;AAUnB,SAAS,kBAAkB,YAAY;AAE5C,QAAM,MAAM,CAAA;AACZ,MAAI,QAAQ;AAEZ,SAAO,EAAE,QAAQ,WAAW,QAAQ;AAClC,oBAAgB,KAAK,WAAW,KAAK,CAAC;AAAA,EAC1C;AAEE,SAAO;AACT;AAYA,SAAS,gBAAgB,KAAK,WAAW;AAEvC,MAAI;AAEJ,OAAK,QAAQ,WAAW;AACtB,UAAM,QAAQ,eAAe,KAAK,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI;AAE3D,UAAM,OAAO,UAAU,IAAI,IAAI,IAAI,CAAE;AAErC,UAAM,QAAQ,UAAU,IAAI;AAE5B,QAAI;AAEJ,QAAI,OAAO;AACT,WAAK,QAAQ,OAAO;AAClB,YAAI,CAAC,eAAe,KAAK,MAAM,IAAI,EAAG,MAAK,IAAI,IAAI,CAAA;AACnD,cAAM,QAAQ,MAAM,IAAI;AACxB;AAAA;AAAA,UAEE,KAAK,IAAI;AAAA,UACT,MAAM,QAAQ,KAAK,IAAI,QAAQ,QAAQ,CAAC,KAAK,IAAI,CAAA;AAAA,QAC3D;AAAA,MACA;AAAA,IACA;AAAA,EACA;AACA;AAaA,SAAS,WAAW,UAAU,MAAM;AAClC,MAAI,QAAQ;AAEZ,QAAM,SAAS,CAAA;AAEf,SAAO,EAAE,QAAQ,KAAK,QAAQ;AAE3B,KAAC,KAAK,KAAK,EAAE,QAAQ,UAAU,WAAW,QAAQ,KAAK,KAAK,KAAK,CAAC;AAAA,EACvE;AAEE,SAAO,UAAU,GAAG,GAAG,MAAM;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

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