markdown-flow-ui 0.1.70-beta.0 → 0.1.70

package/dist/node_modules/micromark-util-character/index.js

@@ -0,0 +1,35 @@
+const u = t(/[A-Za-z]/), a = t(/[\dA-Za-z]/);
+function c(n) {
+  return (
+    // Special whitespace codes (which have negative values), C0 and Control
+    // character DEL
+    n !== null && (n < 32 || n === 127)
+  );
+}
+function e(n) {
+  return n !== null && n < -2;
+}
+function o(n) {
+  return n !== null && (n < 0 || n === 32);
+}
+function l(n) {
+  return n === -2 || n === -1 || n === 32;
+}
+const s = t(new RegExp("\\p{P}|\\p{S}", "u")), p = t(/\s/);
+function t(n) {
+  return i;
+  function i(r) {
+    return r !== null && r > -1 && n.test(String.fromCharCode(r));
+  }
+}
+export {
+  u as asciiAlpha,
+  a as asciiAlphanumeric,
+  c as asciiControl,
+  e as markdownLineEnding,
+  o as markdownLineEndingOrSpace,
+  l as markdownSpace,
+  s as unicodePunctuation,
+  p as unicodeWhitespace
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/micromark-util-character/index.js.map

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

package/dist/node_modules/micromark-util-chunked/index.js

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

package/dist/node_modules/micromark-util-chunked/index.js.map

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

package/dist/node_modules/micromark-util-classify-character/index.js

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

package/dist/node_modules/micromark-util-classify-character/index.js.map

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

package/dist/node_modules/micromark-util-combine-extensions/index.js

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

package/dist/node_modules/micromark-util-combine-extensions/index.js.map

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

package/dist/node_modules/micromark-util-normalize-identifier/index.js

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

package/dist/node_modules/micromark-util-normalize-identifier/index.js.map

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

package/dist/node_modules/micromark-util-resolve-all/index.js

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

package/dist/node_modules/micromark-util-resolve-all/index.js.map

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

package/dist/{Documents/ai-shifu/markdown-flow-ui/node_modules/.pnpm/rehype-highlight@7.0.2/node_modules → node_modules}/rehype-highlight/lib/index.js

@@ -1,7 +1,7 @@
-import { grammars as d } from "../../../../lowlight@3.3.0/node_modules/lowlight/lib/common.js";
-import { createLowlight as w } from "../../../../lowlight@3.3.0/node_modules/lowlight/lib/index.js";
-import { visit as A } from "../../../../unist-util-visit@5.0.0/node_modules/unist-util-visit/lib/index.js";
-import { toText as T } from "../../../../hast-util-to-text@4.0.2/node_modules/hast-util-to-text/lib/index.js";
+import { grammars as d } from "../../lowlight/lib/common.js";
+import { createLowlight as w } from "../../lowlight/lib/index.js";
+import { visit as A } from "../../unist-util-visit/lib/index.js";
+import { toText as T } from "../../hast-util-to-text/lib/index.js";
 const b = {};
 function I(o) {
   const t = o || b, n = t.aliases, a = t.detect || !1, i = t.languages || d, f = t.plainText, r = t.prefix, x = t.subset;

package/dist/node_modules/rehype-highlight/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/rehype-highlight/lib/index.js"],"sourcesContent":["/**\n * @import {ElementContent, Element, Root} from 'hast'\n * @import {LanguageFn} from 'lowlight'\n * @import {VFile} from 'vfile'\n */\n\n/**\n * @typedef Options\n *   Configuration (optional).\n * @property {Readonly<Record<string, ReadonlyArray<string> | string>> | null | undefined} [aliases={}]\n *   Register more aliases (optional);\n *   passed to `lowlight.registerAlias`.\n * @property {boolean | null | undefined} [detect=false]\n *   Highlight code without language classes by guessing its programming\n *   language (default: `false`).\n * @property {Readonly<Record<string, LanguageFn>> | null | undefined} [languages]\n *   Register languages (default: `common`);\n *   passed to `lowlight.register`.\n * @property {ReadonlyArray<string> | null | undefined} [plainText=[]]\n *   List of language names to not highlight (optional);\n *   note you can also add `no-highlight` classes.\n * @property {string | null | undefined} [prefix='hljs-']\n *   Class prefix (default: `'hljs-'`).\n * @property {ReadonlyArray<string> | null | undefined} [subset]\n *   Names of languages to check when detecting (default: all registered\n *   languages).\n */\n\nimport {toText} from 'hast-util-to-text'\nimport {common, createLowlight} from 'lowlight'\nimport {visit} from 'unist-util-visit'\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Apply syntax highlighting.\n *\n * @param {Readonly<Options> | null | undefined} [options]\n *   Configuration (optional).\n * @returns\n *   Transform.\n */\nexport default function rehypeHighlight(options) {\n  const settings = options || emptyOptions\n  const aliases = settings.aliases\n  const detect = settings.detect || false\n  const languages = settings.languages || common\n  const plainText = settings.plainText\n  const prefix = settings.prefix\n  const subset = settings.subset\n  let name = 'hljs'\n\n  const lowlight = createLowlight(languages)\n\n  if (aliases) {\n    lowlight.registerAlias(aliases)\n  }\n\n  if (prefix) {\n    const pos = prefix.indexOf('-')\n    name = pos === -1 ? prefix : prefix.slice(0, pos)\n  }\n\n  /**\n   * Transform.\n   *\n   * @param {Root} tree\n   *   Tree.\n   * @param {VFile} file\n   *   File.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  return function (tree, file) {\n    visit(tree, 'element', function (node, _, parent) {\n      if (\n        node.tagName !== 'code' ||\n        !parent ||\n        parent.type !== 'element' ||\n        parent.tagName !== 'pre'\n      ) {\n        return\n      }\n\n      const lang = language(node)\n\n      if (\n        lang === false ||\n        (!lang && !detect) ||\n        (lang && plainText && plainText.includes(lang))\n      ) {\n        return\n      }\n\n      if (!Array.isArray(node.properties.className)) {\n        node.properties.className = []\n      }\n\n      if (!node.properties.className.includes(name)) {\n        node.properties.className.unshift(name)\n      }\n\n      const text = toText(node, {whitespace: 'pre'})\n      /** @type {Root} */\n      let result\n\n      try {\n        result = lang\n          ? lowlight.highlight(lang, text, {prefix})\n          : lowlight.highlightAuto(text, {prefix, subset})\n      } catch (error) {\n        const cause = /** @type {Error} */ (error)\n\n        if (lang && /Unknown language/.test(cause.message)) {\n          file.message(\n            'Cannot highlight as `' + lang + '`, it’s not registered',\n            {\n              ancestors: [parent, node],\n              cause,\n              place: node.position,\n              ruleId: 'missing-language',\n              source: 'rehype-highlight'\n            }\n          )\n\n          /* c8 ignore next 5 -- throw arbitrary hljs errors */\n          return\n        }\n\n        throw cause\n      }\n\n      if (!lang && result.data && result.data.language) {\n        node.properties.className.push('language-' + result.data.language)\n      }\n\n      if (result.children.length > 0) {\n        node.children = /** @type {Array<ElementContent>} */ (result.children)\n      }\n    })\n  }\n}\n\n/**\n * Get the programming language of `node`.\n *\n * @param {Element} node\n *   Node.\n * @returns {false | string | undefined}\n *   Language or `undefined`, or `false` when an explikcit `no-highlight` class\n *   is used.\n */\nfunction language(node) {\n  const list = node.properties.className\n  let index = -1\n\n  if (!Array.isArray(list)) {\n    return\n  }\n\n  /** @type {string | undefined} */\n  let name\n\n  while (++index < list.length) {\n    const value = String(list[index])\n\n    if (value === 'no-highlight' || value === 'nohighlight') {\n      return false\n    }\n\n    if (!name && value.slice(0, 5) === 'lang-') {\n      name = value.slice(5)\n    }\n\n    if (!name && value.slice(0, 9) === 'language-') {\n      name = value.slice(9)\n    }\n  }\n\n  return name\n}\n"],"names":["emptyOptions","rehypeHighlight","options","settings","aliases","detect","languages","common","plainText","prefix","subset","name","lowlight","createLowlight","pos","tree","file","visit","node","_","parent","lang","language","text","toText","result","error","cause","list","index","value"],"mappings":";;;;AAiCA,MAAMA,IAAe,CAAA;AAUN,SAASC,EAAgBC,GAAS;AAC/C,QAAMC,IAAWD,KAAWF,GACtBI,IAAUD,EAAS,SACnBE,IAASF,EAAS,UAAU,IAC5BG,IAAYH,EAAS,aAAaI,GAClCC,IAAYL,EAAS,WACrBM,IAASN,EAAS,QAClBO,IAASP,EAAS;AACxB,MAAIQ,IAAO;AAEX,QAAMC,IAAWC,EAAeP,CAAS;AAMzC,MAJIF,KACFQ,EAAS,cAAcR,CAAO,GAG5BK,GAAQ;AACV,UAAMK,IAAML,EAAO,QAAQ,GAAG;AAC9B,IAAAE,IAAOG,MAAQ,KAAKL,IAASA,EAAO,MAAM,GAAGK,CAAG;AAAA,EAClD;AAYA,SAAO,SAAUC,GAAMC,GAAM;AAC3B,IAAAC,EAAMF,GAAM,WAAW,SAAUG,GAAMC,GAAGC,GAAQ;AAChD,UACEF,EAAK,YAAY,UACjB,CAACE,KACDA,EAAO,SAAS,aAChBA,EAAO,YAAY;AAEnB;AAGF,YAAMC,IAAOC,EAASJ,CAAI;AAE1B,UACEG,MAAS,MACR,CAACA,KAAQ,CAAChB,KACVgB,KAAQb,KAAaA,EAAU,SAASa,CAAI;AAE7C;AAGF,MAAK,MAAM,QAAQH,EAAK,WAAW,SAAS,MAC1CA,EAAK,WAAW,YAAY,CAAA,IAGzBA,EAAK,WAAW,UAAU,SAASP,CAAI,KAC1CO,EAAK,WAAW,UAAU,QAAQP,CAAI;AAGxC,YAAMY,IAAOC,EAAON,GAAM,EAAC,YAAY,MAAK,CAAC;AAE7C,UAAIO;AAEJ,UAAI;AACF,QAAAA,IAASJ,IACLT,EAAS,UAAUS,GAAME,GAAM,EAAC,QAAAd,EAAM,CAAC,IACvCG,EAAS,cAAcW,GAAM,EAAC,QAAAd,GAAQ,QAAAC,EAAM,CAAC;AAAA,MACnD,SAASgB,GAAO;AACd,cAAMC;AAAA;AAAA,UAA8BD;AAAA;AAEpC,YAAIL,KAAQ,mBAAmB,KAAKM,EAAM,OAAO,GAAG;AAClD,UAAAX,EAAK;AAAA,YACH,0BAA0BK,IAAO;AAAA,YACjC;AAAA,cACE,WAAW,CAACD,GAAQF,CAAI;AAAA,cACxB,OAAAS;AAAA,cACA,OAAOT,EAAK;AAAA,cACZ,QAAQ;AAAA,cACR,QAAQ;AAAA,YACtB;AAAA,UACA;AAGU;AAAA,QACF;AAEA,cAAMS;AAAA,MACR;AAEA,MAAI,CAACN,KAAQI,EAAO,QAAQA,EAAO,KAAK,YACtCP,EAAK,WAAW,UAAU,KAAK,cAAcO,EAAO,KAAK,QAAQ,GAG/DA,EAAO,SAAS,SAAS,MAC3BP,EAAK;AAAA,MAAiDO,EAAO;AAAA,IAEjE,CAAC;AAAA,EACH;AACF;AAWA,SAASH,EAASJ,GAAM;AACtB,QAAMU,IAAOV,EAAK,WAAW;AAC7B,MAAIW,IAAQ;AAEZ,MAAI,CAAC,MAAM,QAAQD,CAAI;AACrB;AAIF,MAAIjB;AAEJ,SAAO,EAAEkB,IAAQD,EAAK,UAAQ;AAC5B,UAAME,IAAQ,OAAOF,EAAKC,CAAK,CAAC;AAEhC,QAAIC,MAAU,kBAAkBA,MAAU;AACxC,aAAO;AAGT,IAAI,CAACnB,KAAQmB,EAAM,MAAM,GAAG,CAAC,MAAM,YACjCnB,IAAOmB,EAAM,MAAM,CAAC,IAGlB,CAACnB,KAAQmB,EAAM,MAAM,GAAG,CAAC,MAAM,gBACjCnB,IAAOmB,EAAM,MAAM,CAAC;AAAA,EAExB;AAEA,SAAOnB;AACT;","x_google_ignoreList":[0]}

package/dist/{Documents/ai-shifu/markdown-flow-ui/node_modules/.pnpm/remark-gfm@4.0.1/node_modules → node_modules}/remark-gfm/lib/index.js

@@ -1,5 +1,5 @@
-import { gfm as i } from "../../../../micromark-extension-gfm@3.0.0/node_modules/micromark-extension-gfm/index.js";
-import { gfmFromMarkdown as e, gfmToMarkdown as f } from "../../../../mdast-util-gfm@3.1.0/node_modules/mdast-util-gfm/lib/index.js";
+import { gfm as i } from "../../micromark-extension-gfm/index.js";
+import { gfmFromMarkdown as e, gfmToMarkdown as f } from "../../mdast-util-gfm/lib/index.js";
 const k = {};
 function x(s) {
   const t = (

package/dist/node_modules/remark-gfm/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/remark-gfm/lib/index.js"],"sourcesContent":["/**\n * @import {Root} from 'mdast'\n * @import {Options} from 'remark-gfm'\n * @import {} from 'remark-parse'\n * @import {} from 'remark-stringify'\n * @import {Processor} from 'unified'\n */\n\nimport {gfmFromMarkdown, gfmToMarkdown} from 'mdast-util-gfm'\nimport {gfm} from 'micromark-extension-gfm'\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Add support GFM (autolink literals, footnotes, strikethrough, tables,\n * tasklists).\n *\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {undefined}\n *   Nothing.\n */\nexport default function remarkGfm(options) {\n  // @ts-expect-error: TS is wrong about `this`.\n  // eslint-disable-next-line unicorn/no-this-assignment\n  const self = /** @type {Processor<Root>} */ (this)\n  const settings = options || emptyOptions\n  const data = self.data()\n\n  const micromarkExtensions =\n    data.micromarkExtensions || (data.micromarkExtensions = [])\n  const fromMarkdownExtensions =\n    data.fromMarkdownExtensions || (data.fromMarkdownExtensions = [])\n  const toMarkdownExtensions =\n    data.toMarkdownExtensions || (data.toMarkdownExtensions = [])\n\n  micromarkExtensions.push(gfm(settings))\n  fromMarkdownExtensions.push(gfmFromMarkdown())\n  toMarkdownExtensions.push(gfmToMarkdown(settings))\n}\n"],"names":["emptyOptions","remarkGfm","options","self","settings","data","micromarkExtensions","fromMarkdownExtensions","toMarkdownExtensions","gfm","gfmFromMarkdown","gfmToMarkdown"],"mappings":";;AAYA,MAAMA,IAAe,CAAA;AAWN,SAASC,EAAUC,GAAS;AAGzC,QAAMC;AAAA;AAAA,IAAuC;AAAA,KACvCC,IAAWF,KAAWF,GACtBK,IAAOF,EAAK,KAAI,GAEhBG,IACJD,EAAK,wBAAwBA,EAAK,sBAAsB,CAAA,IACpDE,IACJF,EAAK,2BAA2BA,EAAK,yBAAyB,CAAA,IAC1DG,IACJH,EAAK,yBAAyBA,EAAK,uBAAuB,CAAA;AAE5D,EAAAC,EAAoB,KAAKG,EAAIL,CAAQ,CAAC,GACtCG,EAAuB,KAAKG,EAAe,CAAE,GAC7CF,EAAqB,KAAKG,EAAcP,CAAQ,CAAC;AACnD;","x_google_ignoreList":[0]}

package/dist/node_modules/unist-util-find-after/lib/index.js

@@ -0,0 +1,33 @@
+import { convert as t } from "../../unist-util-is/lib/index.js";
+const f = (
+  // Note: overloads like this are needed to support optional generics.
+  /**
+   * @type {(
+   *   (<Kind extends UnistParent, Check extends Test>(parent: Kind, index: Child<Kind> | number, test: Check) => Matches<Child<Kind>, Check> | undefined) &
+   *   (<Kind extends UnistParent>(parent: Kind, index: Child<Kind> | number, test?: null | undefined) => Child<Kind> | undefined)
+   * )}
+   */
+  /**
+   * @param {UnistParent} parent
+   * @param {UnistNode | number} index
+   * @param {Test} [test]
+   * @returns {UnistNode | undefined}
+   */
+  (function(e, r, o) {
+    const i = t(o);
+    if (!e || !e.type || !e.children)
+      throw new Error("Expected parent node");
+    if (typeof r == "number") {
+      if (r < 0 || r === Number.POSITIVE_INFINITY)
+        throw new Error("Expected positive finite number as index");
+    } else if (r = e.children.indexOf(r), r < 0)
+      throw new Error("Expected child node or index");
+    for (; ++r < e.children.length; )
+      if (i(e.children[r], r, e))
+        return e.children[r];
+  })
+);
+export {
+  f as findAfter
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/unist-util-find-after/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/unist-util-find-after/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('unist').Node} UnistNode\n * @typedef {import('unist').Parent} UnistParent\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends Array<any>\n *   ? MatchesOne<Value, Check[keyof Check]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {(\n *   Kind extends {children: Array<infer Child>}\n *   ? Child\n *   : never\n * )} Child\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Kind\n *   All node types.\n */\n\nimport {convert} from 'unist-util-is'\n\n/**\n * Find the first node in `parent` after another `node` or after an index,\n * that passes `test`.\n *\n * @param parent\n *   Parent node.\n * @param index\n *   Child node or index.\n * @param [test=undefined]\n *   Test for child to look for (optional).\n * @returns\n *   A child (matching `test`, if given) or `undefined`.\n */\nexport const findAfter =\n  // Note: overloads like this are needed to support optional generics.\n  /**\n   * @type {(\n   *   (<Kind extends UnistParent, Check extends Test>(parent: Kind, index: Child<Kind> | number, test: Check) => Matches<Child<Kind>, Check> | undefined) &\n   *   (<Kind extends UnistParent>(parent: Kind, index: Child<Kind> | number, test?: null | undefined) => Child<Kind> | undefined)\n   * )}\n   */\n  (\n    /**\n     * @param {UnistParent} parent\n     * @param {UnistNode | number} index\n     * @param {Test} [test]\n     * @returns {UnistNode | undefined}\n     */\n    function (parent, index, test) {\n      const is = convert(test)\n\n      if (!parent || !parent.type || !parent.children) {\n        throw new Error('Expected parent node')\n      }\n\n      if (typeof index === 'number') {\n        if (index < 0 || index === Number.POSITIVE_INFINITY) {\n          throw new Error('Expected positive finite number as index')\n        }\n      } else {\n        index = parent.children.indexOf(index)\n\n        if (index < 0) {\n          throw new Error('Expected child node or index')\n        }\n      }\n\n      while (++index < parent.children.length) {\n        if (is(parent.children[index], index, parent)) {\n          return parent.children[index]\n        }\n      }\n\n      return undefined\n    }\n  )\n"],"names":["findAfter","parent","index","test","is","convert"],"mappings":";AAuFY,MAACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GAeT,SAAUC,GAAQC,GAAOC,GAAM;AAC7B,UAAMC,IAAKC,EAAQF,CAAI;AAEvB,QAAI,CAACF,KAAU,CAACA,EAAO,QAAQ,CAACA,EAAO;AACrC,YAAM,IAAI,MAAM,sBAAsB;AAGxC,QAAI,OAAOC,KAAU;AACnB,UAAIA,IAAQ,KAAKA,MAAU,OAAO;AAChC,cAAM,IAAI,MAAM,0CAA0C;AAAA,eAG5DA,IAAQD,EAAO,SAAS,QAAQC,CAAK,GAEjCA,IAAQ;AACV,YAAM,IAAI,MAAM,8BAA8B;AAIlD,WAAO,EAAEA,IAAQD,EAAO,SAAS;AAC/B,UAAIG,EAAGH,EAAO,SAASC,CAAK,GAAGA,GAAOD,CAAM;AAC1C,eAAOA,EAAO,SAASC,CAAK;AAAA,EAKlC;AAAA;","x_google_ignoreList":[0]}

package/dist/node_modules/unist-util-is/lib/index.js

@@ -0,0 +1,85 @@
+const i = (
+  // Note: overloads in JSDoc can’t yet use different `@template`s.
+  /**
+   * @type {(
+   *   (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &
+   *   (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &
+   *   (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &
+   *   ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &
+   *   ((test?: Test) => Check)
+   * )}
+   */
+  /**
+   * @param {Test} [test]
+   * @returns {Check}
+   */
+  (function(n) {
+    if (n == null)
+      return p;
+    if (typeof n == "function")
+      return c(n);
+    if (typeof n == "object")
+      return Array.isArray(n) ? f(n) : y(n);
+    if (typeof n == "string")
+      return l(n);
+    throw new Error("Expected function, string, or object as test");
+  })
+);
+function f(n) {
+  const e = [];
+  let r = -1;
+  for (; ++r < n.length; )
+    e[r] = i(n[r]);
+  return c(t);
+  function t(...u) {
+    let o = -1;
+    for (; ++o < e.length; )
+      if (e[o].apply(this, u)) return !0;
+    return !1;
+  }
+}
+function y(n) {
+  const e = (
+    /** @type {Record<string, unknown>} */
+    n
+  );
+  return c(r);
+  function r(t) {
+    const u = (
+      /** @type {Record<string, unknown>} */
+      /** @type {unknown} */
+      t
+    );
+    let o;
+    for (o in n)
+      if (u[o] !== e[o]) return !1;
+    return !0;
+  }
+}
+function l(n) {
+  return c(e);
+  function e(r) {
+    return r && r.type === n;
+  }
+}
+function c(n) {
+  return e;
+  function e(r, t, u) {
+    return !!(a(r) && n.call(
+      this,
+      r,
+      typeof t == "number" ? t : void 0,
+      u || void 0
+    ));
+  }
+}
+function p() {
+  return !0;
+}
+function a(n) {
+  return n !== null && typeof n == "object" && "type" in n;
+}
+export {
+  i as convert
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/unist-util-is/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/unist-util-is/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n */\n\n/**\n * @template Fn\n * @template Fallback\n * @typedef {Fn extends (value: any) => value is infer Thing ? Thing : Fallback} Predicate\n */\n\n/**\n * @callback Check\n *   Check that an arbitrary value is a node.\n * @param {unknown} this\n *   The given context.\n * @param {unknown} [node]\n *   Anything (typically a node).\n * @param {number | null | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean}\n *   Whether this is a node and passes a test.\n *\n * @typedef {Record<string, unknown> | Node} Props\n *   Object to check for equivalence.\n *\n *   Note: `Node` is included as it is common but is not indexable.\n *\n * @typedef {Array<Props | TestFunction | string> | Props | TestFunction | string | null | undefined} Test\n *   Check for an arbitrary node.\n *\n * @callback TestFunction\n *   Check if a node passes a test.\n * @param {unknown} this\n *   The given context.\n * @param {Node} node\n *   A node.\n * @param {number | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean | undefined | void}\n *   Whether this node passes the test.\n *\n *   Note: `void` is included until TS sees no return as `undefined`.\n */\n\n/**\n * Check if `node` is a `Node` and whether it passes the given test.\n *\n * @param {unknown} node\n *   Thing to check, typically `Node`.\n * @param {Test} test\n *   A check for a specific node.\n * @param {number | null | undefined} index\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} parent\n *   The node’s parent.\n * @param {unknown} context\n *   Context object (`this`) to pass to `test` functions.\n * @returns {boolean}\n *   Whether `node` is a node and passes a test.\n */\nexport const is =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends string>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n   *   (<Condition extends Props>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n   *   (<Condition extends TestFunction>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n   *   ((node?: null | undefined) => false) &\n   *   ((node: unknown, test?: null | undefined, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n   *   ((node: unknown, test?: Test, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => boolean)\n   * )}\n   */\n  (\n    /**\n     * @param {unknown} [node]\n     * @param {Test} [test]\n     * @param {number | null | undefined} [index]\n     * @param {Parent | null | undefined} [parent]\n     * @param {unknown} [context]\n     * @returns {boolean}\n     */\n    // eslint-disable-next-line max-params\n    function (node, test, index, parent, context) {\n      const check = convert(test)\n\n      if (\n        index !== undefined &&\n        index !== null &&\n        (typeof index !== 'number' ||\n          index < 0 ||\n          index === Number.POSITIVE_INFINITY)\n      ) {\n        throw new Error('Expected positive finite index')\n      }\n\n      if (\n        parent !== undefined &&\n        parent !== null &&\n        (!is(parent) || !parent.children)\n      ) {\n        throw new Error('Expected parent node')\n      }\n\n      if (\n        (parent === undefined || parent === null) !==\n        (index === undefined || index === null)\n      ) {\n        throw new Error('Expected both parent and index')\n      }\n\n      return looksLikeANode(node)\n        ? check.call(context, node, index, parent)\n        : false\n    }\n  )\n\n/**\n * Generate an assertion from a test.\n *\n * Useful if you’re going to test many nodes, for example when creating a\n * utility where something else passes a compatible test.\n *\n * The created function is a bit faster because it expects valid input only:\n * a `node`, `index`, and `parent`.\n *\n * @param {Test} test\n *   *   when nullish, checks if `node` is a `Node`.\n *   *   when `string`, works like passing `(node) => node.type === test`.\n *   *   when `function` checks if function passed the node is true.\n *   *   when `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n *   *   when `array`, checks if any one of the subtests pass.\n * @returns {Check}\n *   An assertion.\n */\nexport const convert =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n   *   (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n   *   (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n   *   ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n   *   ((test?: Test) => Check)\n   * )}\n   */\n  (\n    /**\n     * @param {Test} [test]\n     * @returns {Check}\n     */\n    function (test) {\n      if (test === null || test === undefined) {\n        return ok\n      }\n\n      if (typeof test === 'function') {\n        return castFactory(test)\n      }\n\n      if (typeof test === 'object') {\n        return Array.isArray(test) ? anyFactory(test) : propsFactory(test)\n      }\n\n      if (typeof test === 'string') {\n        return typeFactory(test)\n      }\n\n      throw new Error('Expected function, string, or object as test')\n    }\n  )\n\n/**\n * @param {Array<Props | TestFunction | string>} tests\n * @returns {Check}\n */\nfunction anyFactory(tests) {\n  /** @type {Array<Check>} */\n  const checks = []\n  let index = -1\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index])\n  }\n\n  return castFactory(any)\n\n  /**\n   * @this {unknown}\n   * @type {TestFunction}\n   */\n  function any(...parameters) {\n    let index = -1\n\n    while (++index < checks.length) {\n      if (checks[index].apply(this, parameters)) return true\n    }\n\n    return false\n  }\n}\n\n/**\n * Turn an object into a test for a node with a certain fields.\n *\n * @param {Props} check\n * @returns {Check}\n */\nfunction propsFactory(check) {\n  const checkAsRecord = /** @type {Record<string, unknown>} */ (check)\n\n  return castFactory(all)\n\n  /**\n   * @param {Node} node\n   * @returns {boolean}\n   */\n  function all(node) {\n    const nodeAsRecord = /** @type {Record<string, unknown>} */ (\n      /** @type {unknown} */ (node)\n    )\n\n    /** @type {string} */\n    let key\n\n    for (key in check) {\n      if (nodeAsRecord[key] !== checkAsRecord[key]) return false\n    }\n\n    return true\n  }\n}\n\n/**\n * Turn a string into a test for a node with a certain type.\n *\n * @param {string} check\n * @returns {Check}\n */\nfunction typeFactory(check) {\n  return castFactory(type)\n\n  /**\n   * @param {Node} node\n   */\n  function type(node) {\n    return node && node.type === check\n  }\n}\n\n/**\n * Turn a custom test into a test for a node that passes that test.\n *\n * @param {TestFunction} testFunction\n * @returns {Check}\n */\nfunction castFactory(testFunction) {\n  return check\n\n  /**\n   * @this {unknown}\n   * @type {Check}\n   */\n  function check(value, index, parent) {\n    return Boolean(\n      looksLikeANode(value) &&\n        testFunction.call(\n          this,\n          value,\n          typeof index === 'number' ? index : undefined,\n          parent || undefined\n        )\n    )\n  }\n}\n\nfunction ok() {\n  return true\n}\n\n/**\n * @param {unknown} value\n * @returns {value is Node}\n */\nfunction looksLikeANode(value) {\n  return value !== null && typeof value === 'object' && 'type' in value\n}\n"],"names":["convert","test","ok","castFactory","anyFactory","propsFactory","typeFactory","tests","checks","index","any","parameters","check","checkAsRecord","all","node","nodeAsRecord","key","type","testFunction","value","parent","looksLikeANode"],"mappings":"AA2IY,MAACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,GAgBT,SAAUC,GAAM;AACd,QAAIA,KAAS;AACX,aAAOC;AAGT,QAAI,OAAOD,KAAS;AAClB,aAAOE,EAAYF,CAAI;AAGzB,QAAI,OAAOA,KAAS;AAClB,aAAO,MAAM,QAAQA,CAAI,IAAIG,EAAWH,CAAI,IAAII,EAAaJ,CAAI;AAGnE,QAAI,OAAOA,KAAS;AAClB,aAAOK,EAAYL,CAAI;AAGzB,UAAM,IAAI,MAAM,8CAA8C;AAAA,EAChE;AAAA;AAOJ,SAASG,EAAWG,GAAO;AAEzB,QAAMC,IAAS,CAAA;AACf,MAAIC,IAAQ;AAEZ,SAAO,EAAEA,IAAQF,EAAM;AACrB,IAAAC,EAAOC,CAAK,IAAIT,EAAQO,EAAME,CAAK,CAAC;AAGtC,SAAON,EAAYO,CAAG;AAMtB,WAASA,KAAOC,GAAY;AAC1B,QAAIF,IAAQ;AAEZ,WAAO,EAAEA,IAAQD,EAAO;AACtB,UAAIA,EAAOC,CAAK,EAAE,MAAM,MAAME,CAAU,EAAG,QAAO;AAGpD,WAAO;AAAA,EACT;AACF;AAQA,SAASN,EAAaO,GAAO;AAC3B,QAAMC;AAAA;AAAA,IAAwDD;AAAA;AAE9D,SAAOT,EAAYW,CAAG;AAMtB,WAASA,EAAIC,GAAM;AACjB,UAAMC;AAAA;AAAA;AAAA,MACoBD;AAAA;AAI1B,QAAIE;AAEJ,SAAKA,KAAOL;AACV,UAAII,EAAaC,CAAG,MAAMJ,EAAcI,CAAG,EAAG,QAAO;AAGvD,WAAO;AAAA,EACT;AACF;AAQA,SAASX,EAAYM,GAAO;AAC1B,SAAOT,EAAYe,CAAI;AAKvB,WAASA,EAAKH,GAAM;AAClB,WAAOA,KAAQA,EAAK,SAASH;AAAA,EAC/B;AACF;AAQA,SAAST,EAAYgB,GAAc;AACjC,SAAOP;AAMP,WAASA,EAAMQ,GAAOX,GAAOY,GAAQ;AACnC,WAAO,GACLC,EAAeF,CAAK,KAClBD,EAAa;AAAA,MACX;AAAA,MACAC;AAAA,MACA,OAAOX,KAAU,WAAWA,IAAQ;AAAA,MACpCY,KAAU;AAAA,IACpB;AAAA,EAEE;AACF;AAEA,SAASnB,IAAK;AACZ,SAAO;AACT;AAMA,SAASoB,EAAeF,GAAO;AAC7B,SAAOA,MAAU,QAAQ,OAAOA,KAAU,YAAY,UAAUA;AAClE;","x_google_ignoreList":[0]}

package/dist/node_modules/unist-util-visit/lib/index.js

@@ -0,0 +1,17 @@
+import { visitParents as m } from "../../unist-util-visit-parents/lib/index.js";
+import { CONTINUE as y, EXIT as E, SKIP as N } from "../../unist-util-visit-parents/lib/index.js";
+function I(l, n, e, u) {
+  let t, f, o;
+  typeof n == "function" && typeof e != "function" ? (f = void 0, o = n, t = e) : (f = n, o = e, t = u), m(l, f, p, t);
+  function p(c, d) {
+    const i = d[d.length - 1], x = i ? i.children.indexOf(c) : void 0;
+    return o(c, x, i);
+  }
+}
+export {
+  y as CONTINUE,
+  E as EXIT,
+  N as SKIP,
+  I as visit
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/unist-util-visit/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/unist-util-visit/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('unist').Node} UnistNode\n * @typedef {import('unist').Parent} UnistParent\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n// To do: use types from `unist-util-visit-parents` when it’s released.\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends Array<any>\n *   ? MatchesOne<Value, Check[keyof Check]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform `parent`.\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of `parent` still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Visited extends UnistNode ? number | undefined : never} index\n *   Index of `node` in `parent`.\n * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent\n *   Parent of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [Ancestor=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch\n *   Build a typed `Visitor` function from a node and all possible parents.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Visited\n *   Node type.\n * @template {UnistParent} Ancestor\n *   Parent type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromMatch<\n *     Matches<Descendant, Check>,\n *     Extract<Descendant, UnistParent>\n *   >\n * )} BuildVisitorFromDescendants\n *   Build a typed `Visitor` function from a list of descendants and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Descendant\n *   Node type.\n * @template {Test} Check\n *   Test type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromDescendants<\n *     InclusiveDescendant<Tree>,\n *     Check\n *   >\n * )} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Node type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport {visitParents} from 'unist-util-visit-parents'\n\nexport {CONTINUE, EXIT, SKIP} from 'unist-util-visit-parents'\n\n/**\n * Visit nodes.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} testOrVisitor\n *   `unist-util-is`-compatible test (optional, omit to pass a visitor).\n * @param {Visitor | boolean | null | undefined} [visitorOrReverse]\n *   Handle each node (when test is omitted, pass `reverse`).\n * @param {boolean | null | undefined} [maybeReverse=false]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {\n  /** @type {boolean | null | undefined} */\n  let reverse\n  /** @type {Test} */\n  let test\n  /** @type {Visitor} */\n  let visitor\n\n  if (\n    typeof testOrVisitor === 'function' &&\n    typeof visitorOrReverse !== 'function'\n  ) {\n    test = undefined\n    visitor = testOrVisitor\n    reverse = visitorOrReverse\n  } else {\n    // @ts-expect-error: assume the overload with test was given.\n    test = testOrVisitor\n    // @ts-expect-error: assume the overload with test was given.\n    visitor = visitorOrReverse\n    reverse = maybeReverse\n  }\n\n  visitParents(tree, test, overload, reverse)\n\n  /**\n   * @param {UnistNode} node\n   * @param {Array<UnistParent>} parents\n   */\n  function overload(node, parents) {\n    const parent = parents[parents.length - 1]\n    const index = parent ? parent.children.indexOf(node) : undefined\n    return visitor(node, index, parent)\n  }\n}\n"],"names":["visit","tree","testOrVisitor","visitorOrReverse","maybeReverse","reverse","test","visitor","visitParents","overload","node","parents","parent","index"],"mappings":";;AAsRO,SAASA,EAAMC,GAAMC,GAAeC,GAAkBC,GAAc;AAEzE,MAAIC,GAEAC,GAEAC;AAEJ,EACE,OAAOL,KAAkB,cACzB,OAAOC,KAAqB,cAE5BG,IAAO,QACPC,IAAUL,GACVG,IAAUF,MAGVG,IAAOJ,GAEPK,IAAUJ,GACVE,IAAUD,IAGZI,EAAaP,GAAMK,GAAMG,GAAUJ,CAAO;AAM1C,WAASI,EAASC,GAAMC,GAAS;AAC/B,UAAMC,IAASD,EAAQA,EAAQ,SAAS,CAAC,GACnCE,IAAQD,IAASA,EAAO,SAAS,QAAQF,CAAI,IAAI;AACvD,WAAOH,EAAQG,GAAMG,GAAOD,CAAM;AAAA,EACpC;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/unist-util-visit-parents/lib/color.js

@@ -0,0 +1,7 @@
+function r(o) {
+  return o;
+}
+export {
+  r as color
+};
+//# sourceMappingURL=color.js.map

package/dist/node_modules/unist-util-visit-parents/lib/color.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.js","sources":["../../../../../../../node_modules/unist-util-visit-parents/lib/color.js"],"sourcesContent":["/**\n * @param {string} d\n * @returns {string}\n */\nexport function color(d) {\n  return d\n}\n"],"names":["color","d"],"mappings":"AAIO,SAASA,EAAMC,GAAG;AACvB,SAAOA;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/unist-util-visit-parents/lib/index.js

@@ -0,0 +1,57 @@
+import { color as A } from "./color.js";
+import { convert as I } from "../../unist-util-is/lib/index.js";
+const g = [], j = !0, a = !1, k = "skip";
+function w(t, o, u, s) {
+  let p;
+  typeof o == "function" && typeof u != "function" ? (s = u, u = o) : p = o;
+  const b = I(p), y = s ? -1 : 1;
+  m(t, void 0, [])();
+  function m(n, N, l) {
+    const i = (
+      /** @type {Record<string, unknown>} */
+      n && typeof n == "object" ? n : {}
+    );
+    if (typeof i.type == "string") {
+      const e = (
+        // `hast`
+        typeof i.tagName == "string" ? i.tagName : (
+          // `xast`
+          typeof i.name == "string" ? i.name : void 0
+        )
+      );
+      Object.defineProperty(h, "name", {
+        value: "node (" + A(n.type + (e ? "<" + e + ">" : "")) + ")"
+      });
+    }
+    return h;
+    function h() {
+      let e = g, f, r, d;
+      if ((!o || b(n, N, l[l.length - 1] || void 0)) && (e = E(u(n, l)), e[0] === a))
+        return e;
+      if ("children" in n && n.children) {
+        const c = (
+          /** @type {UnistParent} */
+          n
+        );
+        if (c.children && e[0] !== k)
+          for (r = (s ? c.children.length : -1) + y, d = l.concat(c); r > -1 && r < c.children.length; ) {
+            const P = c.children[r];
+            if (f = m(P, r, d)(), f[0] === a)
+              return f;
+            r = typeof f[1] == "number" ? f[1] : r + y;
+          }
+      }
+      return e;
+    }
+  }
+}
+function E(t) {
+  return Array.isArray(t) ? t : typeof t == "number" ? [j, t] : t == null ? g : [t];
+}
+export {
+  j as CONTINUE,
+  a as EXIT,
+  k as SKIP,
+  w as visitParents
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/unist-util-visit-parents/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../node_modules/unist-util-visit-parents/lib/index.js"],"sourcesContent":["/**\n * @typedef {import('unist').Node} UnistNode\n * @typedef {import('unist').Parent} UnistParent\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends Array<any>\n *   ? MatchesOne<Value, Check[keyof Check]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {InternalAncestor<InclusiveDescendant<Tree>, Child>} Ancestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {'skip' | boolean} Action\n *   Union of the action types.\n *\n * @typedef {number} Index\n *   Move to the sibling at `index` next (after node itself is completely\n *   traversed).\n *\n *   Useful if mutating the tree, such as removing the node the visitor is\n *   currently on, or any of its previous siblings.\n *   Results less than 0 or greater than or equal to `children.length` stop\n *   traversing the parent.\n *\n * @typedef {[(Action | null | undefined | void)?, (Index | null | undefined)?]} ActionTuple\n *   List with one or two values, the first an action, the second an index.\n *\n * @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult\n *   Any value that can be returned from a visitor.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform the parent of node (the last of `ancestors`).\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of an ancestor still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Array<VisitedParents>} ancestors\n *   Ancestors of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [VisitedParents=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Matches<InclusiveDescendant<Tree>, Check>, Ancestor<Tree, Matches<InclusiveDescendant<Tree>, Check>>>} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parents`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Tree type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport {convert} from 'unist-util-is'\nimport {color} from 'unist-util-visit-parents/do-not-use-color'\n\n/** @type {Readonly<ActionTuple>} */\nconst empty = []\n\n/**\n * Continue traversing as normal.\n */\nexport const CONTINUE = true\n\n/**\n * Stop traversing immediately.\n */\nexport const EXIT = false\n\n/**\n * Do not traverse this node’s children.\n */\nexport const SKIP = 'skip'\n\n/**\n * Visit nodes, with ancestral information.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} test\n *   `unist-util-is`-compatible test\n * @param {Visitor | boolean | null | undefined} [visitor]\n *   Handle each node.\n * @param {boolean | null | undefined} [reverse]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visitParents(tree, test, visitor, reverse) {\n  /** @type {Test} */\n  let check\n\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor\n    // @ts-expect-error no visitor given, so `visitor` is test.\n    visitor = test\n  } else {\n    // @ts-expect-error visitor given, so `test` isn’t a visitor.\n    check = test\n  }\n\n  const is = convert(check)\n  const step = reverse ? -1 : 1\n\n  factory(tree, undefined, [])()\n\n  /**\n   * @param {UnistNode} node\n   * @param {number | undefined} index\n   * @param {Array<UnistParent>} parents\n   */\n  function factory(node, index, parents) {\n    const value = /** @type {Record<string, unknown>} */ (\n      node && typeof node === 'object' ? node : {}\n    )\n\n    if (typeof value.type === 'string') {\n      const name =\n        // `hast`\n        typeof value.tagName === 'string'\n          ? value.tagName\n          : // `xast`\n          typeof value.name === 'string'\n          ? value.name\n          : undefined\n\n      Object.defineProperty(visit, 'name', {\n        value:\n          'node (' + color(node.type + (name ? '<' + name + '>' : '')) + ')'\n      })\n    }\n\n    return visit\n\n    function visit() {\n      /** @type {Readonly<ActionTuple>} */\n      let result = empty\n      /** @type {Readonly<ActionTuple>} */\n      let subresult\n      /** @type {number} */\n      let offset\n      /** @type {Array<UnistParent>} */\n      let grandparents\n\n      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {\n        // @ts-expect-error: `visitor` is now a visitor.\n        result = toResult(visitor(node, parents))\n\n        if (result[0] === EXIT) {\n          return result\n        }\n      }\n\n      if ('children' in node && node.children) {\n        const nodeAsParent = /** @type {UnistParent} */ (node)\n\n        if (nodeAsParent.children && result[0] !== SKIP) {\n          offset = (reverse ? nodeAsParent.children.length : -1) + step\n          grandparents = parents.concat(nodeAsParent)\n\n          while (offset > -1 && offset < nodeAsParent.children.length) {\n            const child = nodeAsParent.children[offset]\n\n            subresult = factory(child, offset, grandparents)()\n\n            if (subresult[0] === EXIT) {\n              return subresult\n            }\n\n            offset =\n              typeof subresult[1] === 'number' ? subresult[1] : offset + step\n          }\n        }\n      }\n\n      return result\n    }\n  }\n}\n\n/**\n * Turn a return value into a clean result.\n *\n * @param {VisitorResult} value\n *   Valid return values from visitors.\n * @returns {Readonly<ActionTuple>}\n *   Clean result.\n */\nfunction toResult(value) {\n  if (Array.isArray(value)) {\n    return value\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value]\n  }\n\n  return value === null || value === undefined ? empty : [value]\n}\n"],"names":["empty","CONTINUE","EXIT","SKIP","visitParents","tree","test","visitor","reverse","check","is","convert","step","factory","node","index","parents","value","name","visit","color","result","subresult","offset","grandparents","toResult","nodeAsParent","child"],"mappings":";;AA+NA,MAAMA,IAAQ,CAAA,GAKDC,IAAW,IAKXC,IAAO,IAKPC,IAAO;AAiDb,SAASC,EAAaC,GAAMC,GAAMC,GAASC,GAAS;AAEzD,MAAIC;AAEJ,EAAI,OAAOH,KAAS,cAAc,OAAOC,KAAY,cACnDC,IAAUD,GAEVA,IAAUD,KAGVG,IAAQH;AAGV,QAAMI,IAAKC,EAAQF,CAAK,GAClBG,IAAOJ,IAAU,KAAK;AAE5B,EAAAK,EAAQR,GAAM,QAAW,EAAE,EAAC;AAO5B,WAASQ,EAAQC,GAAMC,GAAOC,GAAS;AACrC,UAAMC;AAAA;AAAA,MACJH,KAAQ,OAAOA,KAAS,WAAWA,IAAO,CAAA;AAAA;AAG5C,QAAI,OAAOG,EAAM,QAAS,UAAU;AAClC,YAAMC;AAAA;AAAA,QAEJ,OAAOD,EAAM,WAAY,WACrBA,EAAM;AAAA;AAAA,UAER,OAAOA,EAAM,QAAS,WACpBA,EAAM,OACN;AAAA;AAAA;AAEN,aAAO,eAAeE,GAAO,QAAQ;AAAA,QACnC,OACE,WAAWC,EAAMN,EAAK,QAAQI,IAAO,MAAMA,IAAO,MAAM,GAAG,IAAI;AAAA,MACzE,CAAO;AAAA,IACH;AAEA,WAAOC;AAEP,aAASA,IAAQ;AAEf,UAAIE,IAASrB,GAETsB,GAEAC,GAEAC;AAEJ,WAAI,CAAClB,KAAQI,EAAGI,GAAMC,GAAOC,EAAQA,EAAQ,SAAS,CAAC,KAAK,MAAS,OAEnEK,IAASI,EAASlB,EAAQO,GAAME,CAAO,CAAC,GAEpCK,EAAO,CAAC,MAAMnB;AAChB,eAAOmB;AAIX,UAAI,cAAcP,KAAQA,EAAK,UAAU;AACvC,cAAMY;AAAA;AAAA,UAA2CZ;AAAA;AAEjD,YAAIY,EAAa,YAAYL,EAAO,CAAC,MAAMlB;AAIzC,eAHAoB,KAAUf,IAAUkB,EAAa,SAAS,SAAS,MAAMd,GACzDY,IAAeR,EAAQ,OAAOU,CAAY,GAEnCH,IAAS,MAAMA,IAASG,EAAa,SAAS,UAAQ;AAC3D,kBAAMC,IAAQD,EAAa,SAASH,CAAM;AAI1C,gBAFAD,IAAYT,EAAQc,GAAOJ,GAAQC,CAAY,EAAC,GAE5CF,EAAU,CAAC,MAAMpB;AACnB,qBAAOoB;AAGT,YAAAC,IACE,OAAOD,EAAU,CAAC,KAAM,WAAWA,EAAU,CAAC,IAAIC,IAASX;AAAA,UAC/D;AAAA,MAEJ;AAEA,aAAOS;AAAA,IACT;AAAA,EACF;AACF;AAUA,SAASI,EAASR,GAAO;AACvB,SAAI,MAAM,QAAQA,CAAK,IACdA,IAGL,OAAOA,KAAU,WACZ,CAAChB,GAAUgB,CAAK,IAGlBA,KAAU,OAA8BjB,IAAQ,CAACiB,CAAK;AAC/D;","x_google_ignoreList":[0]}

package/package.json

@@ -149,7 +149,7 @@
     "storybook": "storybook dev -p 6006",
     "test": "echo \"No tests specified\" && exit 0"
   },
-  "version": "0.1.70-beta.0",
+  "version": "0.1.70",
   "type": "module",
   "exports": {
     ".": {

package/dist/Documents/ai-shifu/markdown-flow-ui/node_modules/.pnpm/ccount@2.0.1/node_modules/ccount/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../../../../../../node_modules/.pnpm/ccount@2.0.1/node_modules/ccount/index.js"],"sourcesContent":["/**\n * Count how often a character (or substring) is used in a string.\n *\n * @param {string} value\n *   Value to search in.\n * @param {string} character\n *   Character (or substring) to look for.\n * @return {number}\n *   Number of times `character` occurred in `value`.\n */\nexport function ccount(value, character) {\n  const source = String(value)\n\n  if (typeof character !== 'string') {\n    throw new TypeError('Expected character')\n  }\n\n  let count = 0\n  let index = source.indexOf(character)\n\n  while (index !== -1) {\n    count++\n    index = source.indexOf(character, index + character.length)\n  }\n\n  return count\n}\n"],"names":["ccount","value","character","source","count","index"],"mappings":"AAUO,SAASA,EAAOC,GAAOC,GAAW;AACvC,QAAMC,IAAS,OAAOF,CAAK;AAE3B,MAAI,OAAOC,KAAc;AACvB,UAAM,IAAI,UAAU,oBAAoB;AAG1C,MAAIE,IAAQ,GACRC,IAAQF,EAAO,QAAQD,CAAS;AAEpC,SAAOG,MAAU;AACf,IAAAD,KACAC,IAAQF,EAAO,QAAQD,GAAWG,IAAQH,EAAU,MAAM;AAG5D,SAAOE;AACT;","x_google_ignoreList":[0]}