@easyv/biz-components 0.0.19 → 0.0.21

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

@@ -1 +1 @@
-{"version":3,"file":"code-text.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-text.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   Previous,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const codeText = {\n  name: 'codeText',\n  previous,\n  resolve: resolveCodeText,\n  tokenize: tokenizeCodeText\n};\n\n// To do: next major: don’t resolve, like `markdown-rs`.\n/** @type {Resolver} */\nfunction resolveCodeText(events) {\n  let tailExitIndex = events.length - 4;\n  let headEnterIndex = 3;\n  /** @type {number} */\n  let index;\n  /** @type {number | undefined} */\n  let enter;\n\n  // If we start and end with an EOL or a space.\n  if ((events[headEnterIndex][1].type === \"lineEnding\" || events[headEnterIndex][1].type === 'space') && (events[tailExitIndex][1].type === \"lineEnding\" || events[tailExitIndex][1].type === 'space')) {\n    index = headEnterIndex;\n\n    // And we have data.\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === \"codeTextData\") {\n        // Then we have padding.\n        events[headEnterIndex][1].type = \"codeTextPadding\";\n        events[tailExitIndex][1].type = \"codeTextPadding\";\n        headEnterIndex += 2;\n        tailExitIndex -= 2;\n        break;\n      }\n    }\n  }\n\n  // Merge adjacent spaces and data.\n  index = headEnterIndex - 1;\n  tailExitIndex++;\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== \"lineEnding\") {\n        enter = index;\n      }\n    } else if (index === tailExitIndex || events[index][1].type === \"lineEnding\") {\n      events[enter][1].type = \"codeTextData\";\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end;\n        events.splice(enter + 2, index - enter - 2);\n        tailExitIndex -= index - enter - 2;\n        index = enter + 2;\n      }\n      enter = undefined;\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Previous}\n */\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return code !== 96 || this.events[this.events.length - 1][1].type === \"characterEscape\";\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeText(effects, ok, nok) {\n  const self = this;\n  let sizeOpen = 0;\n  /** @type {number} */\n  let size;\n  /** @type {Token} */\n  let token;\n  return start;\n\n  /**\n   * Start of code (text).\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * > | \\`a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"codeText\");\n    effects.enter(\"codeTextSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 96) {\n      effects.consume(code);\n      sizeOpen++;\n      return sequenceOpen;\n    }\n    effects.exit(\"codeTextSequence\");\n    return between(code);\n  }\n\n  /**\n   * Between something and something else.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function between(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code);\n    }\n\n    // To do: next major: don’t do spaces in resolve, but when compiling,\n    // like `markdown-rs`.\n    // Tabs don’t work, and virtual spaces don’t make sense.\n    if (code === 32) {\n      effects.enter('space');\n      effects.consume(code);\n      effects.exit('space');\n      return between;\n    }\n\n    // Closing fence? Could also be data.\n    if (code === 96) {\n      token = effects.enter(\"codeTextSequence\");\n      size = 0;\n      return sequenceClose(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return between;\n    }\n\n    // Data.\n    effects.enter(\"codeTextData\");\n    return data(code);\n  }\n\n  /**\n   * In data.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {\n      effects.exit(\"codeTextData\");\n      return between(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n\n  /**\n   * In closing sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceClose(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code);\n      size++;\n      return sequenceClose;\n    }\n\n    // Done!\n    if (size === sizeOpen) {\n      effects.exit(\"codeTextSequence\");\n      effects.exit(\"codeText\");\n      return ok(code);\n    }\n\n    // More or less accents: mark as data.\n    token.type = \"codeTextData\";\n    return data(code);\n  }\n}"],"names":["codeText","previous","resolveCodeText","tokenizeCodeText","events","tailExitIndex","headEnterIndex","index","enter","code","effects","ok","nok","sizeOpen","size","token","start","sequenceOpen","between","sequenceClose","markdownLineEnding","data"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"code-text.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-text.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   Previous,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const codeText = {\n  name: 'codeText',\n  previous,\n  resolve: resolveCodeText,\n  tokenize: tokenizeCodeText\n};\n\n// To do: next major: don’t resolve, like `markdown-rs`.\n/** @type {Resolver} */\nfunction resolveCodeText(events) {\n  let tailExitIndex = events.length - 4;\n  let headEnterIndex = 3;\n  /** @type {number} */\n  let index;\n  /** @type {number | undefined} */\n  let enter;\n\n  // If we start and end with an EOL or a space.\n  if ((events[headEnterIndex][1].type === \"lineEnding\" || events[headEnterIndex][1].type === 'space') && (events[tailExitIndex][1].type === \"lineEnding\" || events[tailExitIndex][1].type === 'space')) {\n    index = headEnterIndex;\n\n    // And we have data.\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === \"codeTextData\") {\n        // Then we have padding.\n        events[headEnterIndex][1].type = \"codeTextPadding\";\n        events[tailExitIndex][1].type = \"codeTextPadding\";\n        headEnterIndex += 2;\n        tailExitIndex -= 2;\n        break;\n      }\n    }\n  }\n\n  // Merge adjacent spaces and data.\n  index = headEnterIndex - 1;\n  tailExitIndex++;\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== \"lineEnding\") {\n        enter = index;\n      }\n    } else if (index === tailExitIndex || events[index][1].type === \"lineEnding\") {\n      events[enter][1].type = \"codeTextData\";\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end;\n        events.splice(enter + 2, index - enter - 2);\n        tailExitIndex -= index - enter - 2;\n        index = enter + 2;\n      }\n      enter = undefined;\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Previous}\n */\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return code !== 96 || this.events[this.events.length - 1][1].type === \"characterEscape\";\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeText(effects, ok, nok) {\n  const self = this;\n  let sizeOpen = 0;\n  /** @type {number} */\n  let size;\n  /** @type {Token} */\n  let token;\n  return start;\n\n  /**\n   * Start of code (text).\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * > | \\`a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"codeText\");\n    effects.enter(\"codeTextSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 96) {\n      effects.consume(code);\n      sizeOpen++;\n      return sequenceOpen;\n    }\n    effects.exit(\"codeTextSequence\");\n    return between(code);\n  }\n\n  /**\n   * Between something and something else.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function between(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code);\n    }\n\n    // To do: next major: don’t do spaces in resolve, but when compiling,\n    // like `markdown-rs`.\n    // Tabs don’t work, and virtual spaces don’t make sense.\n    if (code === 32) {\n      effects.enter('space');\n      effects.consume(code);\n      effects.exit('space');\n      return between;\n    }\n\n    // Closing fence? Could also be data.\n    if (code === 96) {\n      token = effects.enter(\"codeTextSequence\");\n      size = 0;\n      return sequenceClose(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return between;\n    }\n\n    // Data.\n    effects.enter(\"codeTextData\");\n    return data(code);\n  }\n\n  /**\n   * In data.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {\n      effects.exit(\"codeTextData\");\n      return between(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n\n  /**\n   * In closing sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceClose(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code);\n      size++;\n      return sequenceClose;\n    }\n\n    // Done!\n    if (size === sizeOpen) {\n      effects.exit(\"codeTextSequence\");\n      effects.exit(\"codeText\");\n      return ok(code);\n    }\n\n    // More or less accents: mark as data.\n    token.type = \"codeTextData\";\n    return data(code);\n  }\n}"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

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

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

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

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

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

@@ -1,81 +1,95 @@
-import { factoryDestination as D } from "../../../../micromark-factory-destination@2.0.1/node_modules/micromark-factory-destination/index.es.js";
-import { factoryLabel as S } from "../../../../micromark-factory-label@2.0.1/node_modules/micromark-factory-label/index.es.js";
-import { factorySpace as s } from "../../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js";
-import { factoryTitle as g } from "../../../../micromark-factory-title@2.0.1/node_modules/micromark-factory-title/index.es.js";
-import { factoryWhitespace as d } from "../../../../micromark-factory-whitespace@2.0.1/node_modules/micromark-factory-whitespace/index.es.js";
-import { markdownLineEndingOrSpace as k, markdownSpace as h, markdownLineEnding as L } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
-import { normalizeIdentifier as w } from "../../../../micromark-util-normalize-identifier@2.0.1/node_modules/micromark-util-normalize-identifier/index.es.js";
-const O = {
+import { factoryDestination } from "../../../../micromark-factory-destination@2.0.1/node_modules/micromark-factory-destination/index.es.js";
+import { factoryLabel } from "../../../../micromark-factory-label@2.0.1/node_modules/micromark-factory-label/index.es.js";
+import { factorySpace } from "../../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js";
+import { factoryTitle } from "../../../../micromark-factory-title@2.0.1/node_modules/micromark-factory-title/index.es.js";
+import { factoryWhitespace } from "../../../../micromark-factory-whitespace@2.0.1/node_modules/micromark-factory-whitespace/index.es.js";
+import { markdownLineEndingOrSpace, markdownSpace, markdownLineEnding } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+import { normalizeIdentifier } from "../../../../micromark-util-normalize-identifier@2.0.1/node_modules/micromark-util-normalize-identifier/index.es.js";
+const definition = {
   name: "definition",
-  tokenize: M
-}, z = {
-  partial: !0,
-  tokenize: y
+  tokenize: tokenizeDefinition
 };
-function M(t, f, e) {
-  const r = this;
-  let o;
-  return u;
-  function u(i) {
-    return t.enter("definition"), a(i);
+const titleBefore = {
+  partial: true,
+  tokenize: tokenizeTitleBefore
+};
+function tokenizeDefinition(effects, ok, nok) {
+  const self = this;
+  let identifier;
+  return start;
+  function start(code) {
+    effects.enter("definition");
+    return before(code);
   }
-  function a(i) {
-    return S.call(
-      r,
-      t,
-      n,
+  function before(code) {
+    return factoryLabel.call(
+      self,
+      effects,
+      labelAfter,
       // Note: we don’t need to reset the way `markdown-rs` does.
-      e,
+      nok,
       "definitionLabel",
       "definitionLabelMarker",
       "definitionLabelString"
-    )(i);
+    )(code);
   }
-  function n(i) {
-    return o = w(r.sliceSerialize(r.events[r.events.length - 1][1]).slice(1, -1)), i === 58 ? (t.enter("definitionMarker"), t.consume(i), t.exit("definitionMarker"), b) : e(i);
+  function labelAfter(code) {
+    identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));
+    if (code === 58) {
+      effects.enter("definitionMarker");
+      effects.consume(code);
+      effects.exit("definitionMarker");
+      return markerAfter;
+    }
+    return nok(code);
   }
-  function b(i) {
-    return k(i) ? d(t, l)(i) : l(i);
+  function markerAfter(code) {
+    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, destinationBefore)(code) : destinationBefore(code);
   }
-  function l(i) {
-    return D(
-      t,
-      c,
+  function destinationBefore(code) {
+    return factoryDestination(
+      effects,
+      destinationAfter,
       // Note: we don’t need to reset the way `markdown-rs` does.
-      e,
+      nok,
       "definitionDestination",
       "definitionDestinationLiteral",
       "definitionDestinationLiteralMarker",
       "definitionDestinationRaw",
       "definitionDestinationString"
-    )(i);
+    )(code);
   }
-  function c(i) {
-    return t.attempt(z, m, m)(i);
+  function destinationAfter(code) {
+    return effects.attempt(titleBefore, after, after)(code);
   }
-  function m(i) {
-    return h(i) ? s(t, p, "whitespace")(i) : p(i);
+  function after(code) {
+    return markdownSpace(code) ? factorySpace(effects, afterWhitespace, "whitespace")(code) : afterWhitespace(code);
   }
-  function p(i) {
-    return i === null || L(i) ? (t.exit("definition"), r.parser.defined.push(o), f(i)) : e(i);
+  function afterWhitespace(code) {
+    if (code === null || markdownLineEnding(code)) {
+      effects.exit("definition");
+      self.parser.defined.push(identifier);
+      return ok(code);
+    }
+    return nok(code);
   }
 }
-function y(t, f, e) {
-  return r;
-  function r(n) {
-    return k(n) ? d(t, o)(n) : e(n);
+function tokenizeTitleBefore(effects, ok, nok) {
+  return titleBefore2;
+  function titleBefore2(code) {
+    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, beforeMarker)(code) : nok(code);
   }
-  function o(n) {
-    return g(t, u, e, "definitionTitle", "definitionTitleMarker", "definitionTitleString")(n);
+  function beforeMarker(code) {
+    return factoryTitle(effects, titleAfter, nok, "definitionTitle", "definitionTitleMarker", "definitionTitleString")(code);
   }
-  function u(n) {
-    return h(n) ? s(t, a, "whitespace")(n) : a(n);
+  function titleAfter(code) {
+    return markdownSpace(code) ? factorySpace(effects, titleAfterOptionalWhitespace, "whitespace")(code) : titleAfterOptionalWhitespace(code);
   }
-  function a(n) {
-    return n === null || L(n) ? f(n) : e(n);
+  function titleAfterOptionalWhitespace(code) {
+    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);
   }
 }
 export {
-  O as definition
+  definition
 };
 //# sourceMappingURL=definition.es.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/definition.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factoryDestination } from 'micromark-factory-destination';\nimport { factoryLabel } from 'micromark-factory-label';\nimport { factorySpace } from 'micromark-factory-space';\nimport { factoryTitle } from 'micromark-factory-title';\nimport { factoryWhitespace } from 'micromark-factory-whitespace';\nimport { markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\n/** @type {Construct} */\nexport const definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n};\n\n/** @type {Construct} */\nconst titleBefore = {\n  partial: true,\n  tokenize: tokenizeTitleBefore\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeDefinition(effects, ok, nok) {\n  const self = this;\n  /** @type {string} */\n  let identifier;\n  return start;\n\n  /**\n   * At start of a definition.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // Do not interrupt paragraphs (but do follow definitions).\n    // To do: do `interrupt` the way `markdown-rs` does.\n    // To do: parse whitespace the way `markdown-rs` does.\n    effects.enter(\"definition\");\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at `[`.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    // To do: parse whitespace the way `markdown-rs` does.\n\n    return factoryLabel.call(self, effects, labelAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionLabel\", \"definitionLabelMarker\", \"definitionLabelString\")(code);\n  }\n\n  /**\n   * After label.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));\n    if (code === 58) {\n      effects.enter(\"definitionMarker\");\n      effects.consume(code);\n      effects.exit(\"definitionMarker\");\n      return markerAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After marker.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function markerAfter(code) {\n    // Note: whitespace is optional.\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, destinationBefore)(code) : destinationBefore(code);\n  }\n\n  /**\n   * Before destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationBefore(code) {\n    return factoryDestination(effects, destinationAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionDestination\", \"definitionDestinationLiteral\", \"definitionDestinationLiteralMarker\", \"definitionDestinationRaw\", \"definitionDestinationString\")(code);\n  }\n\n  /**\n   * After destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationAfter(code) {\n    return effects.attempt(titleBefore, after, after)(code);\n  }\n\n  /**\n   * After definition.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return markdownSpace(code) ? factorySpace(effects, afterWhitespace, \"whitespace\")(code) : afterWhitespace(code);\n  }\n\n  /**\n   * After definition, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterWhitespace(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"definition\");\n\n      // Note: we don’t care about uniqueness.\n      // It’s likely that that doesn’t happen very frequently.\n      // It is more likely that it wastes precious time.\n      self.parser.defined.push(identifier);\n\n      // To do: `markdown-rs` interrupt.\n      // // You’d be interrupting.\n      // tokenizer.interrupt = true\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeTitleBefore(effects, ok, nok) {\n  return titleBefore;\n\n  /**\n   * After destination, at whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleBefore(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, beforeMarker)(code) : nok(code);\n  }\n\n  /**\n   * At title.\n   *\n   * ```markdown\n   *   | [a]: b\n   * > | \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeMarker(code) {\n    return factoryTitle(effects, titleAfter, nok, \"definitionTitle\", \"definitionTitleMarker\", \"definitionTitleString\")(code);\n  }\n\n  /**\n   * After title.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfter(code) {\n    return markdownSpace(code) ? factorySpace(effects, titleAfterOptionalWhitespace, \"whitespace\")(code) : titleAfterOptionalWhitespace(code);\n  }\n\n  /**\n   * After title, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfterOptionalWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}"],"names":["definition","tokenizeDefinition","titleBefore","tokenizeTitleBefore","effects","ok","nok","self","identifier","start","code","before","factoryLabel","labelAfter","normalizeIdentifier","markerAfter","markdownLineEndingOrSpace","factoryWhitespace","destinationBefore","factoryDestination","destinationAfter","after","markdownSpace","factorySpace","afterWhitespace","markdownLineEnding","beforeMarker","factoryTitle","titleAfter","titleAfterOptionalWhitespace"],"mappings":";;;;;;;AAiBY,MAACA,IAAa;AAAA,EACxB,MAAM;AAAA,EACN,UAAUC;AACZ,GAGMC,IAAc;AAAA,EAClB,SAAS;AAAA,EACT,UAAUC;AACZ;AAOA,SAASF,EAAmBG,GAASC,GAAIC,GAAK;AAC5C,QAAMC,IAAO;AAEb,MAAIC;AACJ,SAAOC;AAYP,WAASA,EAAMC,GAAM;AAInB,WAAAN,EAAQ,MAAM,YAAY,GACnBO,EAAOD,CAAI;AAAA,EACtB;AAYE,WAASC,EAAOD,GAAM;AAGpB,WAAOE,EAAa;AAAA,MAAKL;AAAA,MAAMH;AAAA,MAASS;AAAA;AAAA,MAExCP;AAAA,MAAK;AAAA,MAAmB;AAAA,MAAyB;AAAA,IAAuB,EAAEI,CAAI;AAAA,EAClF;AAYE,WAASG,EAAWH,GAAM;AAExB,WADAF,IAAaM,EAAoBP,EAAK,eAAeA,EAAK,OAAOA,EAAK,OAAO,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,EAAE,CAAC,GACrGG,MAAS,MACXN,EAAQ,MAAM,kBAAkB,GAChCA,EAAQ,QAAQM,CAAI,GACpBN,EAAQ,KAAK,kBAAkB,GACxBW,KAEFT,EAAII,CAAI;AAAA,EACnB;AAYE,WAASK,EAAYL,GAAM;AAEzB,WAAOM,EAA0BN,CAAI,IAAIO,EAAkBb,GAASc,CAAiB,EAAER,CAAI,IAAIQ,EAAkBR,CAAI;AAAA,EACzH;AAYE,WAASQ,EAAkBR,GAAM;AAC/B,WAAOS;AAAA,MAAmBf;AAAA,MAASgB;AAAA;AAAA,MAEnCd;AAAA,MAAK;AAAA,MAAyB;AAAA,MAAgC;AAAA,MAAsC;AAAA,MAA4B;AAAA,IAA6B,EAAEI,CAAI;AAAA,EACvK;AAYE,WAASU,EAAiBV,GAAM;AAC9B,WAAON,EAAQ,QAAQF,GAAamB,GAAOA,CAAK,EAAEX,CAAI;AAAA,EAC1D;AAcE,WAASW,EAAMX,GAAM;AACnB,WAAOY,EAAcZ,CAAI,IAAIa,EAAanB,GAASoB,GAAiB,YAAY,EAAEd,CAAI,IAAIc,EAAgBd,CAAI;AAAA,EAClH;AAcE,WAASc,EAAgBd,GAAM;AAC7B,WAAIA,MAAS,QAAQe,EAAmBf,CAAI,KAC1CN,EAAQ,KAAK,YAAY,GAKzBG,EAAK,OAAO,QAAQ,KAAKC,CAAU,GAK5BH,EAAGK,CAAI,KAETJ,EAAII,CAAI;AAAA,EACnB;AACA;AAOA,SAASP,EAAoBC,GAASC,GAAIC,GAAK;AAC7C,SAAOJ;AAcP,WAASA,EAAYQ,GAAM;AACzB,WAAOM,EAA0BN,CAAI,IAAIO,EAAkBb,GAASsB,CAAY,EAAEhB,CAAI,IAAIJ,EAAII,CAAI;AAAA,EACtG;AAaE,WAASgB,EAAahB,GAAM;AAC1B,WAAOiB,EAAavB,GAASwB,GAAYtB,GAAK,mBAAmB,yBAAyB,uBAAuB,EAAEI,CAAI;AAAA,EAC3H;AAYE,WAASkB,EAAWlB,GAAM;AACxB,WAAOY,EAAcZ,CAAI,IAAIa,EAAanB,GAASyB,GAA8B,YAAY,EAAEnB,CAAI,IAAImB,EAA6BnB,CAAI;AAAA,EAC5I;AAYE,WAASmB,EAA6BnB,GAAM;AAC1C,WAAOA,MAAS,QAAQe,EAAmBf,CAAI,IAAIL,EAAGK,CAAI,IAAIJ,EAAII,CAAI;AAAA,EAC1E;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"definition.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/definition.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factoryDestination } from 'micromark-factory-destination';\nimport { factoryLabel } from 'micromark-factory-label';\nimport { factorySpace } from 'micromark-factory-space';\nimport { factoryTitle } from 'micromark-factory-title';\nimport { factoryWhitespace } from 'micromark-factory-whitespace';\nimport { markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\n/** @type {Construct} */\nexport const definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n};\n\n/** @type {Construct} */\nconst titleBefore = {\n  partial: true,\n  tokenize: tokenizeTitleBefore\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeDefinition(effects, ok, nok) {\n  const self = this;\n  /** @type {string} */\n  let identifier;\n  return start;\n\n  /**\n   * At start of a definition.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // Do not interrupt paragraphs (but do follow definitions).\n    // To do: do `interrupt` the way `markdown-rs` does.\n    // To do: parse whitespace the way `markdown-rs` does.\n    effects.enter(\"definition\");\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at `[`.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    // To do: parse whitespace the way `markdown-rs` does.\n\n    return factoryLabel.call(self, effects, labelAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionLabel\", \"definitionLabelMarker\", \"definitionLabelString\")(code);\n  }\n\n  /**\n   * After label.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));\n    if (code === 58) {\n      effects.enter(\"definitionMarker\");\n      effects.consume(code);\n      effects.exit(\"definitionMarker\");\n      return markerAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After marker.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function markerAfter(code) {\n    // Note: whitespace is optional.\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, destinationBefore)(code) : destinationBefore(code);\n  }\n\n  /**\n   * Before destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationBefore(code) {\n    return factoryDestination(effects, destinationAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionDestination\", \"definitionDestinationLiteral\", \"definitionDestinationLiteralMarker\", \"definitionDestinationRaw\", \"definitionDestinationString\")(code);\n  }\n\n  /**\n   * After destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationAfter(code) {\n    return effects.attempt(titleBefore, after, after)(code);\n  }\n\n  /**\n   * After definition.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return markdownSpace(code) ? factorySpace(effects, afterWhitespace, \"whitespace\")(code) : afterWhitespace(code);\n  }\n\n  /**\n   * After definition, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterWhitespace(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"definition\");\n\n      // Note: we don’t care about uniqueness.\n      // It’s likely that that doesn’t happen very frequently.\n      // It is more likely that it wastes precious time.\n      self.parser.defined.push(identifier);\n\n      // To do: `markdown-rs` interrupt.\n      // // You’d be interrupting.\n      // tokenizer.interrupt = true\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeTitleBefore(effects, ok, nok) {\n  return titleBefore;\n\n  /**\n   * After destination, at whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleBefore(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, beforeMarker)(code) : nok(code);\n  }\n\n  /**\n   * At title.\n   *\n   * ```markdown\n   *   | [a]: b\n   * > | \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeMarker(code) {\n    return factoryTitle(effects, titleAfter, nok, \"definitionTitle\", \"definitionTitleMarker\", \"definitionTitleString\")(code);\n  }\n\n  /**\n   * After title.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfter(code) {\n    return markdownSpace(code) ? factorySpace(effects, titleAfterOptionalWhitespace, \"whitespace\")(code) : titleAfterOptionalWhitespace(code);\n  }\n\n  /**\n   * After title, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfterOptionalWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}"],"names":["titleBefore"],"mappings":";;;;;;;AAiBY,MAAC,aAAa;AAAA,EACxB,MAAM;AAAA,EACN,UAAU;AACZ;AAGA,MAAM,cAAc;AAAA,EAClB,SAAS;AAAA,EACT,UAAU;AACZ;AAOA,SAAS,mBAAmB,SAAS,IAAI,KAAK;AAC5C,QAAM,OAAO;AAEb,MAAI;AACJ,SAAO;AAYP,WAAS,MAAM,MAAM;AAInB,YAAQ,MAAM,YAAY;AAC1B,WAAO,OAAO,IAAI;AAAA,EACtB;AAYE,WAAS,OAAO,MAAM;AAGpB,WAAO,aAAa;AAAA,MAAK;AAAA,MAAM;AAAA,MAAS;AAAA;AAAA,MAExC;AAAA,MAAK;AAAA,MAAmB;AAAA,MAAyB;AAAA,IAAuB,EAAE,IAAI;AAAA,EAClF;AAYE,WAAS,WAAW,MAAM;AACxB,iBAAa,oBAAoB,KAAK,eAAe,KAAK,OAAO,KAAK,OAAO,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,EAAE,CAAC;AACzG,QAAI,SAAS,IAAI;AACf,cAAQ,MAAM,kBAAkB;AAChC,cAAQ,QAAQ,IAAI;AACpB,cAAQ,KAAK,kBAAkB;AAC/B,aAAO;AAAA,IACb;AACI,WAAO,IAAI,IAAI;AAAA,EACnB;AAYE,WAAS,YAAY,MAAM;AAEzB,WAAO,0BAA0B,IAAI,IAAI,kBAAkB,SAAS,iBAAiB,EAAE,IAAI,IAAI,kBAAkB,IAAI;AAAA,EACzH;AAYE,WAAS,kBAAkB,MAAM;AAC/B,WAAO;AAAA,MAAmB;AAAA,MAAS;AAAA;AAAA,MAEnC;AAAA,MAAK;AAAA,MAAyB;AAAA,MAAgC;AAAA,MAAsC;AAAA,MAA4B;AAAA,IAA6B,EAAE,IAAI;AAAA,EACvK;AAYE,WAAS,iBAAiB,MAAM;AAC9B,WAAO,QAAQ,QAAQ,aAAa,OAAO,KAAK,EAAE,IAAI;AAAA,EAC1D;AAcE,WAAS,MAAM,MAAM;AACnB,WAAO,cAAc,IAAI,IAAI,aAAa,SAAS,iBAAiB,YAAY,EAAE,IAAI,IAAI,gBAAgB,IAAI;AAAA,EAClH;AAcE,WAAS,gBAAgB,MAAM;AAC7B,QAAI,SAAS,QAAQ,mBAAmB,IAAI,GAAG;AAC7C,cAAQ,KAAK,YAAY;AAKzB,WAAK,OAAO,QAAQ,KAAK,UAAU;AAKnC,aAAO,GAAG,IAAI;AAAA,IACpB;AACI,WAAO,IAAI,IAAI;AAAA,EACnB;AACA;AAOA,SAAS,oBAAoB,SAAS,IAAI,KAAK;AAC7C,SAAOA;AAcP,WAASA,aAAY,MAAM;AACzB,WAAO,0BAA0B,IAAI,IAAI,kBAAkB,SAAS,YAAY,EAAE,IAAI,IAAI,IAAI,IAAI;AAAA,EACtG;AAaE,WAAS,aAAa,MAAM;AAC1B,WAAO,aAAa,SAAS,YAAY,KAAK,mBAAmB,yBAAyB,uBAAuB,EAAE,IAAI;AAAA,EAC3H;AAYE,WAAS,WAAW,MAAM;AACxB,WAAO,cAAc,IAAI,IAAI,aAAa,SAAS,8BAA8B,YAAY,EAAE,IAAI,IAAI,6BAA6B,IAAI;AAAA,EAC5I;AAYE,WAAS,6BAA6B,MAAM;AAC1C,WAAO,SAAS,QAAQ,mBAAmB,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,IAAI;AAAA,EAC1E;AACA;","x_google_ignoreList":[0]}

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

@@ -1,18 +1,24 @@
-import { markdownLineEnding as o } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
-const p = {
+import { markdownLineEnding } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+const hardBreakEscape = {
   name: "hardBreakEscape",
-  tokenize: k
+  tokenize: tokenizeHardBreakEscape
 };
-function k(e, n, a) {
-  return t;
-  function t(r) {
-    return e.enter("hardBreakEscape"), e.consume(r), i;
+function tokenizeHardBreakEscape(effects, ok, nok) {
+  return start;
+  function start(code) {
+    effects.enter("hardBreakEscape");
+    effects.consume(code);
+    return after;
   }
-  function i(r) {
-    return o(r) ? (e.exit("hardBreakEscape"), n(r)) : a(r);
+  function after(code) {
+    if (markdownLineEnding(code)) {
+      effects.exit("hardBreakEscape");
+      return ok(code);
+    }
+    return nok(code);
   }
 }
 export {
-  p as hardBreakEscape
+  hardBreakEscape
 };
 //# sourceMappingURL=hard-break-escape.es.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"hard-break-escape.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/hard-break-escape.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of a hard break (escape).\n   *\n   * ```markdown\n   * > | a\\\n   *      ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"hardBreakEscape\");\n    effects.consume(code);\n    return after;\n  }\n\n  /**\n   * After `\\`, at eol.\n   *\n   * ```markdown\n   * > | a\\\n   *       ^\n   *   | b\n   * ```\n   *\n   *  @type {State}\n   */\n  function after(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit(\"hardBreakEscape\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n}"],"names":["hardBreakEscape","tokenizeHardBreakEscape","effects","ok","nok","start","code","after","markdownLineEnding"],"mappings":";AAWY,MAACA,IAAkB;AAAA,EAC7B,MAAM;AAAA,EACN,UAAUC;AACZ;AAOA,SAASA,EAAwBC,GAASC,GAAIC,GAAK;AACjD,SAAOC;AAaP,WAASA,EAAMC,GAAM;AACnB,WAAAJ,EAAQ,MAAM,iBAAiB,GAC/BA,EAAQ,QAAQI,CAAI,GACbC;AAAA,EACX;AAaE,WAASA,EAAMD,GAAM;AACnB,WAAIE,EAAmBF,CAAI,KACzBJ,EAAQ,KAAK,iBAAiB,GACvBC,EAAGG,CAAI,KAETF,EAAIE,CAAI;AAAA,EACnB;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"hard-break-escape.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/hard-break-escape.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of a hard break (escape).\n   *\n   * ```markdown\n   * > | a\\\n   *      ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"hardBreakEscape\");\n    effects.consume(code);\n    return after;\n  }\n\n  /**\n   * After `\\`, at eol.\n   *\n   * ```markdown\n   * > | a\\\n   *       ^\n   *   | b\n   * ```\n   *\n   *  @type {State}\n   */\n  function after(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit(\"hardBreakEscape\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n}"],"names":[],"mappings":";AAWY,MAAC,kBAAkB;AAAA,EAC7B,MAAM;AAAA,EACN,UAAU;AACZ;AAOA,SAAS,wBAAwB,SAAS,IAAI,KAAK;AACjD,SAAO;AAaP,WAAS,MAAM,MAAM;AACnB,YAAQ,MAAM,iBAAiB;AAC/B,YAAQ,QAAQ,IAAI;AACpB,WAAO;AAAA,EACX;AAaE,WAAS,MAAM,MAAM;AACnB,QAAI,mBAAmB,IAAI,GAAG;AAC5B,cAAQ,KAAK,iBAAiB;AAC9B,aAAO,GAAG,IAAI;AAAA,IACpB;AACI,WAAO,IAAI,IAAI;AAAA,EACnB;AACA;","x_google_ignoreList":[0]}

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

@@ -1,47 +1,96 @@
-import { factorySpace as H } from "../../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js";
-import { markdownLineEndingOrSpace as m, markdownLineEnding as o, markdownSpace as h } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
-import { splice as S } from "../../../../micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.es.js";
-const T = {
+import { factorySpace } from "../../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js";
+import { markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+import { splice } from "../../../../micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.es.js";
+const headingAtx = {
   name: "headingAtx",
-  resolve: y,
-  tokenize: d
+  resolve: resolveHeadingAtx,
+  tokenize: tokenizeHeadingAtx
 };
-function y(t, i) {
-  let e = t.length - 2, r = 3, a, u;
-  return t[r][1].type === "whitespace" && (r += 2), e - 2 > r && t[e][1].type === "whitespace" && (e -= 2), t[e][1].type === "atxHeadingSequence" && (r === e - 1 || e - 4 > r && t[e - 2][1].type === "whitespace") && (e -= r + 1 === e ? 2 : 4), e > r && (a = {
-    type: "atxHeadingText",
-    start: t[r][1].start,
-    end: t[e][1].end
-  }, u = {
-    type: "chunkText",
-    start: t[r][1].start,
-    end: t[e][1].end,
-    contentType: "text"
-  }, S(t, r, e - r + 1, [["enter", a, i], ["enter", u, i], ["exit", u, i], ["exit", a, i]])), t;
+function resolveHeadingAtx(events, context) {
+  let contentEnd = events.length - 2;
+  let contentStart = 3;
+  let content;
+  let text;
+  if (events[contentStart][1].type === "whitespace") {
+    contentStart += 2;
+  }
+  if (contentEnd - 2 > contentStart && events[contentEnd][1].type === "whitespace") {
+    contentEnd -= 2;
+  }
+  if (events[contentEnd][1].type === "atxHeadingSequence" && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === "whitespace")) {
+    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;
+  }
+  if (contentEnd > contentStart) {
+    content = {
+      type: "atxHeadingText",
+      start: events[contentStart][1].start,
+      end: events[contentEnd][1].end
+    };
+    text = {
+      type: "chunkText",
+      start: events[contentStart][1].start,
+      end: events[contentEnd][1].end,
+      contentType: "text"
+    };
+    splice(events, contentStart, contentEnd - contentStart + 1, [["enter", content, context], ["enter", text, context], ["exit", text, context], ["exit", content, context]]);
+  }
+  return events;
 }
-function d(t, i, e) {
-  let r = 0;
-  return a;
-  function a(n) {
-    return t.enter("atxHeading"), u(n);
+function tokenizeHeadingAtx(effects, ok, nok) {
+  let size = 0;
+  return start;
+  function start(code) {
+    effects.enter("atxHeading");
+    return before(code);
   }
-  function u(n) {
-    return t.enter("atxHeadingSequence"), p(n);
+  function before(code) {
+    effects.enter("atxHeadingSequence");
+    return sequenceOpen(code);
   }
-  function p(n) {
-    return n === 35 && r++ < 6 ? (t.consume(n), p) : n === null || m(n) ? (t.exit("atxHeadingSequence"), x(n)) : e(n);
+  function sequenceOpen(code) {
+    if (code === 35 && size++ < 6) {
+      effects.consume(code);
+      return sequenceOpen;
+    }
+    if (code === null || markdownLineEndingOrSpace(code)) {
+      effects.exit("atxHeadingSequence");
+      return atBreak(code);
+    }
+    return nok(code);
   }
-  function x(n) {
-    return n === 35 ? (t.enter("atxHeadingSequence"), g(n)) : n === null || o(n) ? (t.exit("atxHeading"), i(n)) : h(n) ? H(t, x, "whitespace")(n) : (t.enter("atxHeadingText"), l(n));
+  function atBreak(code) {
+    if (code === 35) {
+      effects.enter("atxHeadingSequence");
+      return sequenceFurther(code);
+    }
+    if (code === null || markdownLineEnding(code)) {
+      effects.exit("atxHeading");
+      return ok(code);
+    }
+    if (markdownSpace(code)) {
+      return factorySpace(effects, atBreak, "whitespace")(code);
+    }
+    effects.enter("atxHeadingText");
+    return data(code);
   }
-  function g(n) {
-    return n === 35 ? (t.consume(n), g) : (t.exit("atxHeadingSequence"), x(n));
+  function sequenceFurther(code) {
+    if (code === 35) {
+      effects.consume(code);
+      return sequenceFurther;
+    }
+    effects.exit("atxHeadingSequence");
+    return atBreak(code);
   }
-  function l(n) {
-    return n === null || n === 35 || m(n) ? (t.exit("atxHeadingText"), x(n)) : (t.consume(n), l);
+  function data(code) {
+    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {
+      effects.exit("atxHeadingText");
+      return atBreak(code);
+    }
+    effects.consume(code);
+    return data;
   }
 }
 export {
-  T as headingAtx
+  headingAtx
 };
 //# sourceMappingURL=heading-atx.es.js.map