@easyv/biz-components 0.0.1

package/dist/node_modules/.pnpm/micromark-util-subtokenize@2.1.0/node_modules/micromark-util-subtokenize/lib/splice-buffer.es.js

@@ -0,0 +1,176 @@
+class n {
+  /**
+   * @param {ReadonlyArray<T> | null | undefined} [initial]
+   *   Initial items (optional).
+   * @returns
+   *   Splice buffer.
+   */
+  constructor(t) {
+    this.left = t ? [...t] : [], this.right = [];
+  }
+  /**
+   * Array access;
+   * does not move the cursor.
+   *
+   * @param {number} index
+   *   Index.
+   * @return {T}
+   *   Item.
+   */
+  get(t) {
+    if (t < 0 || t >= this.left.length + this.right.length)
+      throw new RangeError("Cannot access index `" + t + "` in a splice buffer of size `" + (this.left.length + this.right.length) + "`");
+    return t < this.left.length ? this.left[t] : this.right[this.right.length - t + this.left.length - 1];
+  }
+  /**
+   * The length of the splice buffer, one greater than the largest index in the
+   * array.
+   */
+  get length() {
+    return this.left.length + this.right.length;
+  }
+  /**
+   * Remove and return `list[0]`;
+   * moves the cursor to `0`.
+   *
+   * @returns {T | undefined}
+   *   Item, optional.
+   */
+  shift() {
+    return this.setCursor(0), this.right.pop();
+  }
+  /**
+   * Slice the buffer to get an array;
+   * does not move the cursor.
+   *
+   * @param {number} start
+   *   Start.
+   * @param {number | null | undefined} [end]
+   *   End (optional).
+   * @returns {Array<T>}
+   *   Array of items.
+   */
+  slice(t, e) {
+    const h = e ?? Number.POSITIVE_INFINITY;
+    return h < this.left.length ? this.left.slice(t, h) : t > this.left.length ? this.right.slice(this.right.length - h + this.left.length, this.right.length - t + this.left.length).reverse() : this.left.slice(t).concat(this.right.slice(this.right.length - h + this.left.length).reverse());
+  }
+  /**
+   * Mimics the behavior of Array.prototype.splice() except for the change of
+   * interface necessary to avoid segfaults when patching in very large arrays.
+   *
+   * This operation moves cursor is moved to `start` and results in the cursor
+   * placed after any inserted items.
+   *
+   * @param {number} start
+   *   Start;
+   *   zero-based index at which to start changing the array;
+   *   negative numbers count backwards from the end of the array and values
+   *   that are out-of bounds are clamped to the appropriate end of the array.
+   * @param {number | null | undefined} [deleteCount=0]
+   *   Delete count (default: `0`);
+   *   maximum number of elements to delete, starting from start.
+   * @param {Array<T> | null | undefined} [items=[]]
+   *   Items to include in place of the deleted items (default: `[]`).
+   * @return {Array<T>}
+   *   Any removed items.
+   */
+  splice(t, e, h) {
+    const r = e || 0;
+    this.setCursor(Math.trunc(t));
+    const l = this.right.splice(this.right.length - r, Number.POSITIVE_INFINITY);
+    return h && s(this.left, h), l.reverse();
+  }
+  /**
+   * Remove and return the highest-numbered item in the array, so
+   * `list[list.length - 1]`;
+   * Moves the cursor to `length`.
+   *
+   * @returns {T | undefined}
+   *   Item, optional.
+   */
+  pop() {
+    return this.setCursor(Number.POSITIVE_INFINITY), this.left.pop();
+  }
+  /**
+   * Inserts a single item to the high-numbered side of the array;
+   * moves the cursor to `length`.
+   *
+   * @param {T} item
+   *   Item.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  push(t) {
+    this.setCursor(Number.POSITIVE_INFINITY), this.left.push(t);
+  }
+  /**
+   * Inserts many items to the high-numbered side of the array.
+   * Moves the cursor to `length`.
+   *
+   * @param {Array<T>} items
+   *   Items.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  pushMany(t) {
+    this.setCursor(Number.POSITIVE_INFINITY), s(this.left, t);
+  }
+  /**
+   * Inserts a single item to the low-numbered side of the array;
+   * Moves the cursor to `0`.
+   *
+   * @param {T} item
+   *   Item.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  unshift(t) {
+    this.setCursor(0), this.right.push(t);
+  }
+  /**
+   * Inserts many items to the low-numbered side of the array;
+   * moves the cursor to `0`.
+   *
+   * @param {Array<T>} items
+   *   Items.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  unshiftMany(t) {
+    this.setCursor(0), s(this.right, t.reverse());
+  }
+  /**
+   * Move the cursor to a specific position in the array. Requires
+   * time proportional to the distance moved.
+   *
+   * If `n < 0`, the cursor will end up at the beginning.
+   * If `n > length`, the cursor will end up at the end.
+   *
+   * @param {number} n
+   *   Position.
+   * @return {undefined}
+   *   Nothing.
+   */
+  setCursor(t) {
+    if (!(t === this.left.length || t > this.left.length && this.right.length === 0 || t < 0 && this.left.length === 0))
+      if (t < this.left.length) {
+        const e = this.left.splice(t, Number.POSITIVE_INFINITY);
+        s(this.right, e.reverse());
+      } else {
+        const e = this.right.splice(this.left.length + this.right.length - t, Number.POSITIVE_INFINITY);
+        s(this.left, e.reverse());
+      }
+  }
+}
+function s(i, t) {
+  let e = 0;
+  if (t.length < 1e4)
+    i.push(...t);
+  else
+    for (; e < t.length; )
+      i.push(...t.slice(e, e + 1e4)), e += 1e4;
+}
+export {
+  n as SpliceBuffer
+};
+//# sourceMappingURL=splice-buffer.es.js.map

package/dist/node_modules/.pnpm/micromark-util-subtokenize@2.1.0/node_modules/micromark-util-subtokenize/lib/splice-buffer.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"splice-buffer.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark-util-subtokenize@2.1.0/node_modules/micromark-util-subtokenize/lib/splice-buffer.js"],"sourcesContent":["/**\n * Some of the internal operations of micromark do lots of editing\n * operations on very large arrays. This runs into problems with two\n * properties of most circa-2020 JavaScript interpreters:\n *\n *  - Array-length modifications at the high end of an array (push/pop) are\n *    expected to be common and are implemented in (amortized) time\n *    proportional to the number of elements added or removed, whereas\n *    other operations (shift/unshift and splice) are much less efficient.\n *  - Function arguments are passed on the stack, so adding tens of thousands\n *    of elements to an array with `arr.push(...newElements)` will frequently\n *    cause stack overflows. (see <https://stackoverflow.com/questions/22123769/rangeerror-maximum-call-stack-size-exceeded-why>)\n *\n * SpliceBuffers are an implementation of gap buffers, which are a\n * generalization of the \"queue made of two stacks\" idea. The splice buffer\n * maintains a cursor, and moving the cursor has cost proportional to the\n * distance the cursor moves, but inserting, deleting, or splicing in\n * new information at the cursor is as efficient as the push/pop operation.\n * This allows for an efficient sequence of splices (or pushes, pops, shifts,\n * or unshifts) as long such edits happen at the same part of the array or\n * generally sweep through the array from the beginning to the end.\n *\n * The interface for splice buffers also supports large numbers of inputs by\n * passing a single array argument rather passing multiple arguments on the\n * function call stack.\n *\n * @template T\n *   Item type.\n */\nexport class SpliceBuffer {\n  /**\n   * @param {ReadonlyArray<T> | null | undefined} [initial]\n   *   Initial items (optional).\n   * @returns\n   *   Splice buffer.\n   */\n  constructor(initial) {\n    /** @type {Array<T>} */\n    this.left = initial ? [...initial] : [];\n    /** @type {Array<T>} */\n    this.right = [];\n  }\n\n  /**\n   * Array access;\n   * does not move the cursor.\n   *\n   * @param {number} index\n   *   Index.\n   * @return {T}\n   *   Item.\n   */\n  get(index) {\n    if (index < 0 || index >= this.left.length + this.right.length) {\n      throw new RangeError('Cannot access index `' + index + '` in a splice buffer of size `' + (this.left.length + this.right.length) + '`');\n    }\n    if (index < this.left.length) return this.left[index];\n    return this.right[this.right.length - index + this.left.length - 1];\n  }\n\n  /**\n   * The length of the splice buffer, one greater than the largest index in the\n   * array.\n   */\n  get length() {\n    return this.left.length + this.right.length;\n  }\n\n  /**\n   * Remove and return `list[0]`;\n   * moves the cursor to `0`.\n   *\n   * @returns {T | undefined}\n   *   Item, optional.\n   */\n  shift() {\n    this.setCursor(0);\n    return this.right.pop();\n  }\n\n  /**\n   * Slice the buffer to get an array;\n   * does not move the cursor.\n   *\n   * @param {number} start\n   *   Start.\n   * @param {number | null | undefined} [end]\n   *   End (optional).\n   * @returns {Array<T>}\n   *   Array of items.\n   */\n  slice(start, end) {\n    /** @type {number} */\n    const stop = end === null || end === undefined ? Number.POSITIVE_INFINITY : end;\n    if (stop < this.left.length) {\n      return this.left.slice(start, stop);\n    }\n    if (start > this.left.length) {\n      return this.right.slice(this.right.length - stop + this.left.length, this.right.length - start + this.left.length).reverse();\n    }\n    return this.left.slice(start).concat(this.right.slice(this.right.length - stop + this.left.length).reverse());\n  }\n\n  /**\n   * Mimics the behavior of Array.prototype.splice() except for the change of\n   * interface necessary to avoid segfaults when patching in very large arrays.\n   *\n   * This operation moves cursor is moved to `start` and results in the cursor\n   * placed after any inserted items.\n   *\n   * @param {number} start\n   *   Start;\n   *   zero-based index at which to start changing the array;\n   *   negative numbers count backwards from the end of the array and values\n   *   that are out-of bounds are clamped to the appropriate end of the array.\n   * @param {number | null | undefined} [deleteCount=0]\n   *   Delete count (default: `0`);\n   *   maximum number of elements to delete, starting from start.\n   * @param {Array<T> | null | undefined} [items=[]]\n   *   Items to include in place of the deleted items (default: `[]`).\n   * @return {Array<T>}\n   *   Any removed items.\n   */\n  splice(start, deleteCount, items) {\n    /** @type {number} */\n    const count = deleteCount || 0;\n    this.setCursor(Math.trunc(start));\n    const removed = this.right.splice(this.right.length - count, Number.POSITIVE_INFINITY);\n    if (items) chunkedPush(this.left, items);\n    return removed.reverse();\n  }\n\n  /**\n   * Remove and return the highest-numbered item in the array, so\n   * `list[list.length - 1]`;\n   * Moves the cursor to `length`.\n   *\n   * @returns {T | undefined}\n   *   Item, optional.\n   */\n  pop() {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    return this.left.pop();\n  }\n\n  /**\n   * Inserts a single item to the high-numbered side of the array;\n   * moves the cursor to `length`.\n   *\n   * @param {T} item\n   *   Item.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  push(item) {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    this.left.push(item);\n  }\n\n  /**\n   * Inserts many items to the high-numbered side of the array.\n   * Moves the cursor to `length`.\n   *\n   * @param {Array<T>} items\n   *   Items.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  pushMany(items) {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    chunkedPush(this.left, items);\n  }\n\n  /**\n   * Inserts a single item to the low-numbered side of the array;\n   * Moves the cursor to `0`.\n   *\n   * @param {T} item\n   *   Item.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  unshift(item) {\n    this.setCursor(0);\n    this.right.push(item);\n  }\n\n  /**\n   * Inserts many items to the low-numbered side of the array;\n   * moves the cursor to `0`.\n   *\n   * @param {Array<T>} items\n   *   Items.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  unshiftMany(items) {\n    this.setCursor(0);\n    chunkedPush(this.right, items.reverse());\n  }\n\n  /**\n   * Move the cursor to a specific position in the array. Requires\n   * time proportional to the distance moved.\n   *\n   * If `n < 0`, the cursor will end up at the beginning.\n   * If `n > length`, the cursor will end up at the end.\n   *\n   * @param {number} n\n   *   Position.\n   * @return {undefined}\n   *   Nothing.\n   */\n  setCursor(n) {\n    if (n === this.left.length || n > this.left.length && this.right.length === 0 || n < 0 && this.left.length === 0) return;\n    if (n < this.left.length) {\n      // Move cursor to the this.left\n      const removed = this.left.splice(n, Number.POSITIVE_INFINITY);\n      chunkedPush(this.right, removed.reverse());\n    } else {\n      // Move cursor to the this.right\n      const removed = this.right.splice(this.left.length + this.right.length - n, Number.POSITIVE_INFINITY);\n      chunkedPush(this.left, removed.reverse());\n    }\n  }\n}\n\n/**\n * Avoid stack overflow by pushing items onto the stack in segments\n *\n * @template T\n *   Item type.\n * @param {Array<T>} list\n *   List to inject into.\n * @param {ReadonlyArray<T>} right\n *   Items to inject.\n * @return {undefined}\n *   Nothing.\n */\nfunction chunkedPush(list, right) {\n  /** @type {number} */\n  let chunkStart = 0;\n  if (right.length < 10000) {\n    list.push(...right);\n  } else {\n    while (chunkStart < right.length) {\n      list.push(...right.slice(chunkStart, chunkStart + 10000));\n      chunkStart += 10000;\n    }\n  }\n}"],"names":["SpliceBuffer","initial","index","start","end","stop","deleteCount","items","count","removed","chunkedPush","item","n","list","right","chunkStart"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/constructs.es.js

@@ -0,0 +1,86 @@
+import { resolver as f } from "./initialize/text.es.js";
+import { blockQuote as p } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/block-quote.es.js";
+import { list as o } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/list.es.js";
+import { definition as c } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/definition.es.js";
+import { codeIndented as t } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-indented.es.js";
+import { codeFenced as i } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-fenced.es.js";
+import { thematicBreak as r } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/thematic-break.es.js";
+import { setextUnderline as n } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/setext-underline.es.js";
+import { htmlFlow as s } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/html-flow.es.js";
+import { headingAtx as d } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/heading-atx.es.js";
+import { characterEscape as l } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/character-escape.es.js";
+import { characterReference as a } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/character-reference.es.js";
+import { codeText as h } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/code-text.es.js";
+import { attention as e } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/attention.es.js";
+import { labelEnd as k } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/label-end.es.js";
+import { hardBreakEscape as u } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/hard-break-escape.es.js";
+import { labelStartLink as x } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/label-start-link.es.js";
+import { autolink as b } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/autolink.es.js";
+import { htmlText as g } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/html-text.es.js";
+import { labelStartImage as E } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/label-start-image.es.js";
+import { lineEnding as m } from "../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/line-ending.es.js";
+const J = {
+  42: o,
+  43: o,
+  45: o,
+  48: o,
+  49: o,
+  50: o,
+  51: o,
+  52: o,
+  53: o,
+  54: o,
+  55: o,
+  56: o,
+  57: o,
+  62: p
+}, K = {
+  91: c
+}, N = {
+  [-2]: t,
+  [-1]: t,
+  32: t
+}, O = {
+  35: d,
+  42: r,
+  45: [n, r],
+  60: s,
+  61: n,
+  95: r,
+  96: i,
+  126: i
+}, P = {
+  38: a,
+  92: l
+}, V = {
+  [-5]: m,
+  [-4]: m,
+  [-3]: m,
+  33: E,
+  38: a,
+  42: e,
+  60: [b, g],
+  91: x,
+  92: [u, l],
+  93: k,
+  95: e,
+  96: h
+}, W = {
+  null: [e, f]
+}, X = {
+  null: [42, 95]
+}, Y = {
+  null: []
+};
+export {
+  X as attentionMarkers,
+  K as contentInitial,
+  Y as disable,
+  J as document,
+  O as flow,
+  N as flowInitial,
+  W as insideSpan,
+  P as string,
+  V as text
+};
+//# sourceMappingURL=constructs.es.js.map

package/dist/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/constructs.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constructs.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/constructs.js"],"sourcesContent":["/**\n * @import {Extension} from 'micromark-util-types'\n */\n\nimport { attention, autolink, blockQuote, characterEscape, characterReference, codeFenced, codeIndented, codeText, definition, hardBreakEscape, headingAtx, htmlFlow, htmlText, labelEnd, labelStartImage, labelStartLink, lineEnding, list, setextUnderline, thematicBreak } from 'micromark-core-commonmark';\nimport { resolver as resolveText } from './initialize/text.js';\n\n/** @satisfies {Extension['document']} */\nexport const document = {\n  [42]: list,\n  [43]: list,\n  [45]: list,\n  [48]: list,\n  [49]: list,\n  [50]: list,\n  [51]: list,\n  [52]: list,\n  [53]: list,\n  [54]: list,\n  [55]: list,\n  [56]: list,\n  [57]: list,\n  [62]: blockQuote\n};\n\n/** @satisfies {Extension['contentInitial']} */\nexport const contentInitial = {\n  [91]: definition\n};\n\n/** @satisfies {Extension['flowInitial']} */\nexport const flowInitial = {\n  [-2]: codeIndented,\n  [-1]: codeIndented,\n  [32]: codeIndented\n};\n\n/** @satisfies {Extension['flow']} */\nexport const flow = {\n  [35]: headingAtx,\n  [42]: thematicBreak,\n  [45]: [setextUnderline, thematicBreak],\n  [60]: htmlFlow,\n  [61]: setextUnderline,\n  [95]: thematicBreak,\n  [96]: codeFenced,\n  [126]: codeFenced\n};\n\n/** @satisfies {Extension['string']} */\nexport const string = {\n  [38]: characterReference,\n  [92]: characterEscape\n};\n\n/** @satisfies {Extension['text']} */\nexport const text = {\n  [-5]: lineEnding,\n  [-4]: lineEnding,\n  [-3]: lineEnding,\n  [33]: labelStartImage,\n  [38]: characterReference,\n  [42]: attention,\n  [60]: [autolink, htmlText],\n  [91]: labelStartLink,\n  [92]: [hardBreakEscape, characterEscape],\n  [93]: labelEnd,\n  [95]: attention,\n  [96]: codeText\n};\n\n/** @satisfies {Extension['insideSpan']} */\nexport const insideSpan = {\n  null: [attention, resolveText]\n};\n\n/** @satisfies {Extension['attentionMarkers']} */\nexport const attentionMarkers = {\n  null: [42, 95]\n};\n\n/** @satisfies {Extension['disable']} */\nexport const disable = {\n  null: []\n};"],"names":["document","list","blockQuote","contentInitial","definition","flowInitial","codeIndented","flow","headingAtx","thematicBreak","setextUnderline","htmlFlow","codeFenced","string","characterReference","characterEscape","text","lineEnding","labelStartImage","attention","autolink","htmlText","labelStartLink","hardBreakEscape","labelEnd","codeText","insideSpan","resolveText","attentionMarkers","disable"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAQY,MAACA,IAAW;AAAA,EACrB,IAAKC;AAAA,EACL,IAAKA;AAAA,EACL,IAAKA;AAAA,EACL,IAAKA;AAAA,EACL,IAAKA;AAAA,EACL,IAAKA;AAAA,EACL,IAAKA;AAAA,EACL,IAAKA;AAAA,EACL,IAAKA;AAAA,EACL,IAAKA;AAAA,EACL,IAAKA;AAAA,EACL,IAAKA;AAAA,EACL,IAAKA;AAAA,EACL,IAAKC;AACR,GAGaC,IAAiB;AAAA,EAC3B,IAAKC;AACR,GAGaC,IAAc;AAAA,EACzB,CAAC,EAAE,GAAGC;AAAA,EACN,CAAC,EAAE,GAAGA;AAAA,EACL,IAAKA;AACR,GAGaC,IAAO;AAAA,EACjB,IAAKC;AAAA,EACL,IAAKC;AAAA,EACL,IAAK,CAACC,GAAiBD,CAAa;AAAA,EACpC,IAAKE;AAAA,EACL,IAAKD;AAAA,EACL,IAAKD;AAAA,EACL,IAAKG;AAAA,EACL,KAAMA;AACT,GAGaC,IAAS;AAAA,EACnB,IAAKC;AAAA,EACL,IAAKC;AACR,GAGaC,IAAO;AAAA,EAClB,CAAC,EAAE,GAAGC;AAAA,EACN,CAAC,EAAE,GAAGA;AAAA,EACN,CAAC,EAAE,GAAGA;AAAA,EACL,IAAKC;AAAA,EACL,IAAKJ;AAAA,EACL,IAAKK;AAAA,EACL,IAAK,CAACC,GAAUC,CAAQ;AAAA,EACxB,IAAKC;AAAA,EACL,IAAK,CAACC,GAAiBR,CAAe;AAAA,EACtC,IAAKS;AAAA,EACL,IAAKL;AAAA,EACL,IAAKM;AACR,GAGaC,IAAa;AAAA,EACxB,MAAM,CAACP,GAAWQ,CAAW;AAC/B,GAGaC,IAAmB;AAAA,EAC9B,MAAM,CAAC,IAAI,EAAE;AACf,GAGaC,IAAU;AAAA,EACrB,MAAM,CAAA;AACR;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/create-tokenizer.es.js

@@ -0,0 +1,224 @@
+import { markdownLineEnding as V } from "../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+import { push as W, splice as X } from "../../../../micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.es.js";
+import { resolveAll as Y } from "../../../../micromark-util-resolve-all@2.0.1/node_modules/micromark-util-resolve-all/index.es.js";
+function re(d, l, o) {
+  let n = {
+    _bufferIndex: -1,
+    _index: 0,
+    line: o && o.line || 1,
+    column: o && o.column || 1,
+    offset: o && o.offset || 0
+  };
+  const f = {}, u = [];
+  let s = [], h = [];
+  const S = {
+    attempt: m(J),
+    check: m(P),
+    consume: D,
+    enter: G,
+    exit: H,
+    interrupt: m(P, {
+      interrupt: !0
+    })
+  }, t = {
+    code: null,
+    containerState: {},
+    defineSkip: R,
+    events: [],
+    now: v,
+    parser: d,
+    previous: null,
+    sliceSerialize: M,
+    sliceStream: j,
+    write: L
+  };
+  let O = l.tokenize.call(t, S);
+  return l.resolveAll && u.push(l), t;
+  function L(e) {
+    return s = W(s, e), q(), s[s.length - 1] !== null ? [] : (T(l, 0), t.events = Y(u, t.events, t), t.events);
+  }
+  function M(e, r) {
+    return $(j(e), r);
+  }
+  function j(e) {
+    return Z(s, e);
+  }
+  function v() {
+    const {
+      _bufferIndex: e,
+      _index: r,
+      line: c,
+      column: a,
+      offset: p
+    } = n;
+    return {
+      _bufferIndex: e,
+      _index: r,
+      line: c,
+      column: a,
+      offset: p
+    };
+  }
+  function R(e) {
+    f[e.line] = e.column, g();
+  }
+  function q() {
+    let e;
+    for (; n._index < s.length; ) {
+      const r = s[n._index];
+      if (typeof r == "string")
+        for (e = n._index, n._bufferIndex < 0 && (n._bufferIndex = 0); n._index === e && n._bufferIndex < r.length; )
+          z(r.charCodeAt(n._bufferIndex));
+      else
+        z(r);
+    }
+  }
+  function z(e) {
+    O = O(e);
+  }
+  function D(e) {
+    V(e) ? (n.line++, n.column = 1, n.offset += e === -3 ? 2 : 1, g()) : e !== -1 && (n.column++, n.offset++), n._bufferIndex < 0 ? n._index++ : (n._bufferIndex++, n._bufferIndex === // Points w/ non-negative `_bufferIndex` reference
+    // strings.
+    /** @type {string} */
+    s[n._index].length && (n._bufferIndex = -1, n._index++)), t.previous = e;
+  }
+  function G(e, r) {
+    const c = r || {};
+    return c.type = e, c.start = v(), t.events.push(["enter", c, t]), h.push(c), c;
+  }
+  function H(e) {
+    const r = h.pop();
+    return r.end = v(), t.events.push(["exit", r, t]), r;
+  }
+  function J(e, r) {
+    T(e, r.from);
+  }
+  function P(e, r) {
+    r.restore();
+  }
+  function m(e, r) {
+    return c;
+    function c(a, p, _) {
+      let C, k, B, y;
+      return Array.isArray(a) ? (
+        /* c8 ignore next 1 */
+        A(a)
+      ) : "tokenize" in a ? (
+        // Looks like a construct.
+        A([
+          /** @type {Construct} */
+          a
+        ])
+      ) : N(a);
+      function N(i) {
+        return w;
+        function w(x) {
+          const b = x !== null && i[x], I = x !== null && i.null, U = [
+            // To do: add more extension tests.
+            /* c8 ignore next 2 */
+            ...Array.isArray(b) ? b : b ? [b] : [],
+            ...Array.isArray(I) ? I : I ? [I] : []
+          ];
+          return A(U)(x);
+        }
+      }
+      function A(i) {
+        return C = i, k = 0, i.length === 0 ? _ : E(i[k]);
+      }
+      function E(i) {
+        return w;
+        function w(x) {
+          return y = K(), B = i, i.partial || (t.currentConstruct = i), i.name && t.parser.constructs.disable.null.includes(i.name) ? F() : i.tokenize.call(
+            // If we do have fields, create an object w/ `context` as its
+            // prototype.
+            // This allows a “live binding”, which is needed for `interrupt`.
+            r ? Object.assign(Object.create(t), r) : t,
+            S,
+            Q,
+            F
+          )(x);
+        }
+      }
+      function Q(i) {
+        return e(B, y), p;
+      }
+      function F(i) {
+        return y.restore(), ++k < C.length ? E(C[k]) : _;
+      }
+    }
+  }
+  function T(e, r) {
+    e.resolveAll && !u.includes(e) && u.push(e), e.resolve && X(t.events, r, t.events.length - r, e.resolve(t.events.slice(r), t)), e.resolveTo && (t.events = e.resolveTo(t.events, t));
+  }
+  function K() {
+    const e = v(), r = t.previous, c = t.currentConstruct, a = t.events.length, p = Array.from(h);
+    return {
+      from: a,
+      restore: _
+    };
+    function _() {
+      n = e, t.previous = r, t.currentConstruct = c, t.events.length = a, h = p, g();
+    }
+  }
+  function g() {
+    n.line in f && n.column < 2 && (n.column = f[n.line], n.offset += f[n.line] - 1);
+  }
+}
+function Z(d, l) {
+  const o = l.start._index, n = l.start._bufferIndex, f = l.end._index, u = l.end._bufferIndex;
+  let s;
+  if (o === f)
+    s = [d[o].slice(n, u)];
+  else {
+    if (s = d.slice(o, f), n > -1) {
+      const h = s[0];
+      typeof h == "string" ? s[0] = h.slice(n) : s.shift();
+    }
+    u > 0 && s.push(d[f].slice(0, u));
+  }
+  return s;
+}
+function $(d, l) {
+  let o = -1;
+  const n = [];
+  let f;
+  for (; ++o < d.length; ) {
+    const u = d[o];
+    let s;
+    if (typeof u == "string")
+      s = u;
+    else switch (u) {
+      case -5: {
+        s = "\r";
+        break;
+      }
+      case -4: {
+        s = `
+`;
+        break;
+      }
+      case -3: {
+        s = `\r
+`;
+        break;
+      }
+      case -2: {
+        s = l ? " " : "	";
+        break;
+      }
+      case -1: {
+        if (!l && f) continue;
+        s = " ";
+        break;
+      }
+      default:
+        s = String.fromCharCode(u);
+    }
+    f = u === -2, n.push(s);
+  }
+  return n.join("");
+}
+export {
+  re as createTokenizer
+};
+//# sourceMappingURL=create-tokenizer.es.js.map

package/dist/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/create-tokenizer.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-tokenizer.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/create-tokenizer.js"],"sourcesContent":["/**\n * @import {\n *   Chunk,\n *   Code,\n *   ConstructRecord,\n *   Construct,\n *   Effects,\n *   InitialConstruct,\n *   ParseContext,\n *   Point,\n *   State,\n *   TokenizeContext,\n *   Token\n * } from 'micromark-util-types'\n */\n\n/**\n * @callback Restore\n *   Restore the state.\n * @returns {undefined}\n *   Nothing.\n *\n * @typedef Info\n *   Info.\n * @property {Restore} restore\n *   Restore.\n * @property {number} from\n *   From.\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n *   Construct.\n * @param {Info} info\n *   Info.\n * @returns {undefined}\n *   Nothing.\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { push, splice } from 'micromark-util-chunked';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/**\n * Create a tokenizer.\n * Tokenizers deal with one type of data (e.g., containers, flow, text).\n * The parser is the object dealing with it all.\n * `initialize` works like other constructs, except that only its `tokenize`\n * function is used, in which case it doesn’t receive an `ok` or `nok`.\n * `from` can be given to set the point before the first character, although\n * when further lines are indented, they must be set with `defineSkip`.\n *\n * @param {ParseContext} parser\n *   Parser.\n * @param {InitialConstruct} initialize\n *   Construct.\n * @param {Omit<Point, '_bufferIndex' | '_index'> | undefined} [from]\n *   Point (optional).\n * @returns {TokenizeContext}\n *   Context.\n */\nexport function createTokenizer(parser, initialize, from) {\n  /** @type {Point} */\n  let point = {\n    _bufferIndex: -1,\n    _index: 0,\n    line: from && from.line || 1,\n    column: from && from.column || 1,\n    offset: from && from.offset || 0\n  };\n  /** @type {Record<string, number>} */\n  const columnStart = {};\n  /** @type {Array<Construct>} */\n  const resolveAllConstructs = [];\n  /** @type {Array<Chunk>} */\n  let chunks = [];\n  /** @type {Array<Token>} */\n  let stack = [];\n  /** @type {boolean | undefined} */\n  let consumed = true;\n\n  /**\n   * Tools used for tokenizing.\n   *\n   * @type {Effects}\n   */\n  const effects = {\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    consume,\n    enter,\n    exit,\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    })\n  };\n\n  /**\n   * State and tools for resolving and serializing.\n   *\n   * @type {TokenizeContext}\n   */\n  const context = {\n    code: null,\n    containerState: {},\n    defineSkip,\n    events: [],\n    now,\n    parser,\n    previous: null,\n    sliceSerialize,\n    sliceStream,\n    write\n  };\n\n  /**\n   * The state function.\n   *\n   * @type {State | undefined}\n   */\n  let state = initialize.tokenize.call(context, effects);\n\n  /**\n   * Track which character we expect to be consumed, to catch bugs.\n   *\n   * @type {Code}\n   */\n  let expectedCode;\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize);\n  }\n  return context;\n\n  /** @type {TokenizeContext['write']} */\n  function write(slice) {\n    chunks = push(chunks, slice);\n    main();\n\n    // Exit if we’re not done, resolve might change stuff.\n    if (chunks[chunks.length - 1] !== null) {\n      return [];\n    }\n    addResult(initialize, 0);\n\n    // Otherwise, resolve, and exit.\n    context.events = resolveAll(resolveAllConstructs, context.events, context);\n    return context.events;\n  }\n\n  //\n  // Tools.\n  //\n\n  /** @type {TokenizeContext['sliceSerialize']} */\n  function sliceSerialize(token, expandTabs) {\n    return serializeChunks(sliceStream(token), expandTabs);\n  }\n\n  /** @type {TokenizeContext['sliceStream']} */\n  function sliceStream(token) {\n    return sliceChunks(chunks, token);\n  }\n\n  /** @type {TokenizeContext['now']} */\n  function now() {\n    // This is a hot path, so we clone manually instead of `Object.assign({}, point)`\n    const {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\n    } = point;\n    return {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\n    };\n  }\n\n  /** @type {TokenizeContext['defineSkip']} */\n  function defineSkip(value) {\n    columnStart[value.line] = value.column;\n    accountForPotentialSkip();\n  }\n\n  //\n  // State management.\n  //\n\n  /**\n   * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n   * `consume`).\n   * Here is where we walk through the chunks, which either include strings of\n   * several characters, or numerical character codes.\n   * The reason to do this in a loop instead of a call is so the stack can\n   * drain.\n   *\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function main() {\n    /** @type {number} */\n    let chunkIndex;\n    while (point._index < chunks.length) {\n      const chunk = chunks[point._index];\n\n      // If we’re in a buffer chunk, loop through it.\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index;\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0;\n        }\n        while (point._index === chunkIndex && point._bufferIndex < chunk.length) {\n          go(chunk.charCodeAt(point._bufferIndex));\n        }\n      } else {\n        go(chunk);\n      }\n    }\n  }\n\n  /**\n   * Deal with one code.\n   *\n   * @param {Code} code\n   *   Code.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function go(code) {\n    consumed = undefined;\n    expectedCode = code;\n    state = state(code);\n  }\n\n  /** @type {Effects['consume']} */\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++;\n      point.column = 1;\n      point.offset += code === -3 ? 2 : 1;\n      accountForPotentialSkip();\n    } else if (code !== -1) {\n      point.column++;\n      point.offset++;\n    }\n\n    // Not in a string chunk.\n    if (point._bufferIndex < 0) {\n      point._index++;\n    } else {\n      point._bufferIndex++;\n\n      // At end of string chunk.\n      if (point._bufferIndex ===\n      // Points w/ non-negative `_bufferIndex` reference\n      // strings.\n      /** @type {string} */\n      chunks[point._index].length) {\n        point._bufferIndex = -1;\n        point._index++;\n      }\n    }\n\n    // Expose the previous character.\n    context.previous = code;\n\n    // Mark as consumed.\n    consumed = true;\n  }\n\n  /** @type {Effects['enter']} */\n  function enter(type, fields) {\n    /** @type {Token} */\n    // @ts-expect-error Patch instead of assign required fields to help GC.\n    const token = fields || {};\n    token.type = type;\n    token.start = now();\n    context.events.push(['enter', token, context]);\n    stack.push(token);\n    return token;\n  }\n\n  /** @type {Effects['exit']} */\n  function exit(type) {\n    const token = stack.pop();\n    token.end = now();\n    context.events.push(['exit', token, context]);\n    return token;\n  }\n\n  /**\n   * Use results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from);\n  }\n\n  /**\n   * Discard results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulcheck(_, info) {\n    info.restore();\n  }\n\n  /**\n   * Factory to attempt/check/interrupt.\n   *\n   * @param {ReturnHandle} onreturn\n   *   Callback.\n   * @param {{interrupt?: boolean | undefined} | undefined} [fields]\n   *   Fields.\n   */\n  function constructFactory(onreturn, fields) {\n    return hook;\n\n    /**\n     * Handle either an object mapping codes to constructs, a list of\n     * constructs, or a single construct.\n     *\n     * @param {Array<Construct> | ConstructRecord | Construct} constructs\n     *   Constructs.\n     * @param {State} returnState\n     *   State.\n     * @param {State | undefined} [bogusState]\n     *   State.\n     * @returns {State}\n     *   State.\n     */\n    function hook(constructs, returnState, bogusState) {\n      /** @type {ReadonlyArray<Construct>} */\n      let listOfConstructs;\n      /** @type {number} */\n      let constructIndex;\n      /** @type {Construct} */\n      let currentConstruct;\n      /** @type {Info} */\n      let info;\n      return Array.isArray(constructs) ? /* c8 ignore next 1 */\n      handleListOfConstructs(constructs) : 'tokenize' in constructs ?\n      // Looks like a construct.\n      handleListOfConstructs([(/** @type {Construct} */constructs)]) : handleMapOfConstructs(constructs);\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       *   Constructs.\n       * @returns {State}\n       *   State.\n       */\n      function handleMapOfConstructs(map) {\n        return start;\n\n        /** @type {State} */\n        function start(code) {\n          const left = code !== null && map[code];\n          const all = code !== null && map.null;\n          const list = [\n          // To do: add more extension tests.\n          /* c8 ignore next 2 */\n          ...(Array.isArray(left) ? left : left ? [left] : []), ...(Array.isArray(all) ? all : all ? [all] : [])];\n          return handleListOfConstructs(list)(code);\n        }\n      }\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ReadonlyArray<Construct>} list\n       *   Constructs.\n       * @returns {State}\n       *   State.\n       */\n      function handleListOfConstructs(list) {\n        listOfConstructs = list;\n        constructIndex = 0;\n        if (list.length === 0) {\n          return bogusState;\n        }\n        return handleConstruct(list[constructIndex]);\n      }\n\n      /**\n       * Handle a single construct.\n       *\n       * @param {Construct} construct\n       *   Construct.\n       * @returns {State}\n       *   State.\n       */\n      function handleConstruct(construct) {\n        return start;\n\n        /** @type {State} */\n        function start(code) {\n          // To do: not needed to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store();\n          currentConstruct = construct;\n          if (!construct.partial) {\n            context.currentConstruct = construct;\n          }\n\n          // Always populated by defaults.\n\n          if (construct.name && context.parser.constructs.disable.null.includes(construct.name)) {\n            return nok(code);\n          }\n          return construct.tokenize.call(\n          // If we do have fields, create an object w/ `context` as its\n          // prototype.\n          // This allows a “live binding”, which is needed for `interrupt`.\n          fields ? Object.assign(Object.create(context), fields) : context, effects, ok, nok)(code);\n        }\n      }\n\n      /** @type {State} */\n      function ok(code) {\n        consumed = true;\n        onreturn(currentConstruct, info);\n        return returnState;\n      }\n\n      /** @type {State} */\n      function nok(code) {\n        consumed = true;\n        info.restore();\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex]);\n        }\n        return bogusState;\n      }\n    }\n  }\n\n  /**\n   * @param {Construct} construct\n   *   Construct.\n   * @param {number} from\n   *   From.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct);\n    }\n    if (construct.resolve) {\n      splice(context.events, from, context.events.length - from, construct.resolve(context.events.slice(from), context));\n    }\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context);\n    }\n  }\n\n  /**\n   * Store state.\n   *\n   * @returns {Info}\n   *   Info.\n   */\n  function store() {\n    const startPoint = now();\n    const startPrevious = context.previous;\n    const startCurrentConstruct = context.currentConstruct;\n    const startEventsIndex = context.events.length;\n    const startStack = Array.from(stack);\n    return {\n      from: startEventsIndex,\n      restore\n    };\n\n    /**\n     * Restore state.\n     *\n     * @returns {undefined}\n     *   Nothing.\n     */\n    function restore() {\n      point = startPoint;\n      context.previous = startPrevious;\n      context.currentConstruct = startCurrentConstruct;\n      context.events.length = startEventsIndex;\n      stack = startStack;\n      accountForPotentialSkip();\n    }\n  }\n\n  /**\n   * Move the current point a bit forward in the line when it’s on a column\n   * skip.\n   *\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line];\n      point.offset += columnStart[point.line] - 1;\n    }\n  }\n}\n\n/**\n * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {Pick<Token, 'end' | 'start'>} token\n *   Token.\n * @returns {Array<Chunk>}\n *   Chunks.\n */\nfunction sliceChunks(chunks, token) {\n  const startIndex = token.start._index;\n  const startBufferIndex = token.start._bufferIndex;\n  const endIndex = token.end._index;\n  const endBufferIndex = token.end._bufferIndex;\n  /** @type {Array<Chunk>} */\n  let view;\n  if (startIndex === endIndex) {\n    // @ts-expect-error `_bufferIndex` is used on string chunks.\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];\n  } else {\n    view = chunks.slice(startIndex, endIndex);\n    if (startBufferIndex > -1) {\n      const head = view[0];\n      if (typeof head === 'string') {\n        view[0] = head.slice(startBufferIndex);\n        /* c8 ignore next 4 -- used to be used, no longer */\n      } else {\n        view.shift();\n      }\n    }\n    if (endBufferIndex > 0) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view.push(chunks[endIndex].slice(0, endBufferIndex));\n    }\n  }\n  return view;\n}\n\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {boolean | undefined} [expandTabs=false]\n *   Whether to expand tabs (default: `false`).\n * @returns {string}\n *   Result.\n */\nfunction serializeChunks(chunks, expandTabs) {\n  let index = -1;\n  /** @type {Array<string>} */\n  const result = [];\n  /** @type {boolean | undefined} */\n  let atTab;\n  while (++index < chunks.length) {\n    const chunk = chunks[index];\n    /** @type {string} */\n    let value;\n    if (typeof chunk === 'string') {\n      value = chunk;\n    } else switch (chunk) {\n      case -5:\n        {\n          value = \"\\r\";\n          break;\n        }\n      case -4:\n        {\n          value = \"\\n\";\n          break;\n        }\n      case -3:\n        {\n          value = \"\\r\" + \"\\n\";\n          break;\n        }\n      case -2:\n        {\n          value = expandTabs ? \" \" : \"\\t\";\n          break;\n        }\n      case -1:\n        {\n          if (!expandTabs && atTab) continue;\n          value = \" \";\n          break;\n        }\n      default:\n        {\n          // Currently only replacement character.\n          value = String.fromCharCode(chunk);\n        }\n    }\n    atTab = chunk === -2;\n    result.push(value);\n  }\n  return result.join('');\n}"],"names":["createTokenizer","parser","initialize","from","point","columnStart","resolveAllConstructs","chunks","stack","effects","constructFactory","onsuccessfulconstruct","onsuccessfulcheck","consume","enter","exit","context","defineSkip","now","sliceSerialize","sliceStream","write","state","slice","push","main","addResult","resolveAll","token","expandTabs","serializeChunks","sliceChunks","_bufferIndex","_index","line","column","offset","value","accountForPotentialSkip","chunkIndex","chunk","go","code","markdownLineEnding","type","fields","construct","info","_","onreturn","hook","constructs","returnState","bogusState","listOfConstructs","constructIndex","currentConstruct","handleListOfConstructs","handleMapOfConstructs","map","start","left","all","list","handleConstruct","store","nok","ok","splice","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","restore","startIndex","startBufferIndex","endIndex","endBufferIndex","view","head","index","result","atTab"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/content.es.js

@@ -0,0 +1,38 @@
+import { factorySpace as l } from "../../../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js";
+import { markdownLineEnding as m } from "../../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+const g = {
+  tokenize: x
+};
+function x(n) {
+  const i = n.attempt(this.parser.constructs.contentInitial, e, p);
+  let r;
+  return i;
+  function e(t) {
+    if (t === null) {
+      n.consume(t);
+      return;
+    }
+    return n.enter("lineEnding"), n.consume(t), n.exit("lineEnding"), l(n, i, "linePrefix");
+  }
+  function p(t) {
+    return n.enter("paragraph"), u(t);
+  }
+  function u(t) {
+    const a = n.enter("chunkText", {
+      contentType: "text",
+      previous: r
+    });
+    return r && (r.next = a), r = a, o(t);
+  }
+  function o(t) {
+    if (t === null) {
+      n.exit("chunkText"), n.exit("paragraph"), n.consume(t);
+      return;
+    }
+    return m(t) ? (n.consume(t), n.exit("chunkText"), u) : (n.consume(t), o);
+  }
+}
+export {
+  g as content
+};
+//# sourceMappingURL=content.es.js.map

package/dist/node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/content.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/content.js"],"sourcesContent":["/**\n * @import {\n *   InitialConstruct,\n *   Initializer,\n *   State,\n *   TokenizeContext,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {InitialConstruct} */\nexport const content = {\n  tokenize: initializeContent\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Initializer}\n *   Content.\n */\nfunction initializeContent(effects) {\n  const contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial);\n  /** @type {Token} */\n  let previous;\n  return contentStart;\n\n  /** @type {State} */\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, contentStart, \"linePrefix\");\n  }\n\n  /** @type {State} */\n  function paragraphInitial(code) {\n    effects.enter(\"paragraph\");\n    return lineStart(code);\n  }\n\n  /** @type {State} */\n  function lineStart(code) {\n    const token = effects.enter(\"chunkText\", {\n      contentType: \"text\",\n      previous\n    });\n    if (previous) {\n      previous.next = token;\n    }\n    previous = token;\n    return data(code);\n  }\n\n  /** @type {State} */\n  function data(code) {\n    if (code === null) {\n      effects.exit(\"chunkText\");\n      effects.exit(\"paragraph\");\n      effects.consume(code);\n      return;\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      effects.exit(\"chunkText\");\n      return lineStart;\n    }\n\n    // Data.\n    effects.consume(code);\n    return data;\n  }\n}"],"names":["content","initializeContent","effects","contentStart","afterContentStartConstruct","paragraphInitial","previous","code","factorySpace","lineStart","token","data","markdownLineEnding"],"mappings":";;AAaY,MAACA,IAAU;AAAA,EACrB,UAAUC;AACZ;AAQA,SAASA,EAAkBC,GAAS;AAClC,QAAMC,IAAeD,EAAQ,QAAQ,KAAK,OAAO,WAAW,gBAAgBE,GAA4BC,CAAgB;AAExH,MAAIC;AACJ,SAAOH;AAGP,WAASC,EAA2BG,GAAM;AACxC,QAAIA,MAAS,MAAM;AACjB,MAAAL,EAAQ,QAAQK,CAAI;AACpB;AAAA,IACN;AACI,WAAAL,EAAQ,MAAM,YAAY,GAC1BA,EAAQ,QAAQK,CAAI,GACpBL,EAAQ,KAAK,YAAY,GAClBM,EAAaN,GAASC,GAAc,YAAY;AAAA,EAC3D;AAGE,WAASE,EAAiBE,GAAM;AAC9B,WAAAL,EAAQ,MAAM,WAAW,GAClBO,EAAUF,CAAI;AAAA,EACzB;AAGE,WAASE,EAAUF,GAAM;AACvB,UAAMG,IAAQR,EAAQ,MAAM,aAAa;AAAA,MACvC,aAAa;AAAA,MACb,UAAAI;AAAA,IACN,CAAK;AACD,WAAIA,MACFA,EAAS,OAAOI,IAElBJ,IAAWI,GACJC,EAAKJ,CAAI;AAAA,EACpB;AAGE,WAASI,EAAKJ,GAAM;AAClB,QAAIA,MAAS,MAAM;AACjB,MAAAL,EAAQ,KAAK,WAAW,GACxBA,EAAQ,KAAK,WAAW,GACxBA,EAAQ,QAAQK,CAAI;AACpB;AAAA,IACN;AACI,WAAIK,EAAmBL,CAAI,KACzBL,EAAQ,QAAQK,CAAI,GACpBL,EAAQ,KAAK,WAAW,GACjBO,MAITP,EAAQ,QAAQK,CAAI,GACbI;AAAA,EACX;AACA;","x_google_ignoreList":[0]}