@easyv/biz-components 0.0.1

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

@@ -0,0 +1,127 @@
+import { factorySpace as I } from "../../../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js";
+import { markdownLineEnding as N } from "../../../../../micromark-util-character@2.1.1/node_modules/micromark-util-character/index.es.js";
+import { splice as F } from "../../../../../micromark-util-chunked@2.0.1/node_modules/micromark-util-chunked/index.es.js";
+const L = {
+  tokenize: T
+}, y = {
+  tokenize: E
+};
+function T(i) {
+  const e = this, l = [];
+  let s = 0, t, a, d;
+  return w;
+  function w(n) {
+    if (s < l.length) {
+      const o = l[s];
+      return e.containerState = o[1], i.attempt(o[0].continuation, z, p)(n);
+    }
+    return p(n);
+  }
+  function z(n) {
+    if (s++, e.containerState._closeFlow) {
+      e.containerState._closeFlow = void 0, t && x();
+      const o = e.events.length;
+      let u = o, r;
+      for (; u--; )
+        if (e.events[u][0] === "exit" && e.events[u][1].type === "chunkFlow") {
+          r = e.events[u][1].end;
+          break;
+        }
+      f(s);
+      let c = o;
+      for (; c < e.events.length; )
+        e.events[c][1].end = {
+          ...r
+        }, c++;
+      return F(e.events, u + 1, 0, e.events.slice(o)), e.events.length = c, p(n);
+    }
+    return w(n);
+  }
+  function p(n) {
+    if (s === l.length) {
+      if (!t)
+        return m(n);
+      if (t.currentConstruct && t.currentConstruct.concrete)
+        return v(n);
+      e.interrupt = !!(t.currentConstruct && !t._gfmTableDynamicInterruptHack);
+    }
+    return e.containerState = {}, i.check(y, B, _)(n);
+  }
+  function B(n) {
+    return t && x(), f(s), m(n);
+  }
+  function _(n) {
+    return e.parser.lazy[e.now().line] = s !== l.length, d = e.now().offset, v(n);
+  }
+  function m(n) {
+    return e.containerState = {}, i.attempt(y, b, v)(n);
+  }
+  function b(n) {
+    return s++, l.push([e.currentConstruct, e.containerState]), m(n);
+  }
+  function v(n) {
+    if (n === null) {
+      t && x(), f(0), i.consume(n);
+      return;
+    }
+    return t = t || e.parser.flow(e.now()), i.enter("chunkFlow", {
+      _tokenizer: t,
+      contentType: "flow",
+      previous: a
+    }), C(n);
+  }
+  function C(n) {
+    if (n === null) {
+      g(i.exit("chunkFlow"), !0), f(0), i.consume(n);
+      return;
+    }
+    return N(n) ? (i.consume(n), g(i.exit("chunkFlow")), s = 0, e.interrupt = void 0, w) : (i.consume(n), C);
+  }
+  function g(n, o) {
+    const u = e.sliceStream(n);
+    if (o && u.push(null), n.previous = a, a && (a.next = n), a = n, t.defineSkip(n.start), t.write(u), e.parser.lazy[n.start.line]) {
+      let r = t.events.length;
+      for (; r--; )
+        if (
+          // The token starts before the line ending…
+          t.events[r][1].start.offset < d && // …and either is not ended yet…
+          (!t.events[r][1].end || // …or ends after it.
+          t.events[r][1].end.offset > d)
+        )
+          return;
+      const c = e.events.length;
+      let h = c, k, S;
+      for (; h--; )
+        if (e.events[h][0] === "exit" && e.events[h][1].type === "chunkFlow") {
+          if (k) {
+            S = e.events[h][1].end;
+            break;
+          }
+          k = !0;
+        }
+      for (f(s), r = c; r < e.events.length; )
+        e.events[r][1].end = {
+          ...S
+        }, r++;
+      F(e.events, h + 1, 0, e.events.slice(c)), e.events.length = r;
+    }
+  }
+  function f(n) {
+    let o = l.length;
+    for (; o-- > n; ) {
+      const u = l[o];
+      e.containerState = u[1], u[0].exit.call(e, i);
+    }
+    l.length = n;
+  }
+  function x() {
+    t.write([null]), a = void 0, t = void 0, e.containerState._closeFlow = void 0;
+  }
+}
+function E(i, e, l) {
+  return I(i, i.attempt(this.parser.constructs.document, e, l), "linePrefix", this.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4);
+}
+export {
+  L as document
+};
+//# sourceMappingURL=document.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"document.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/document.js"],"sourcesContent":["/**\n * @import {\n *   Construct,\n *   ContainerState,\n *   InitialConstruct,\n *   Initializer,\n *   Point,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\n/**\n * @typedef {[Construct, ContainerState]} StackItem\n *   Construct and its state.\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { splice } from 'micromark-util-chunked';\n/** @type {InitialConstruct} */\nexport const document = {\n  tokenize: initializeDocument\n};\n\n/** @type {Construct} */\nconst containerConstruct = {\n  tokenize: tokenizeContainer\n};\n\n/**\n * @this {TokenizeContext}\n *   Self.\n * @type {Initializer}\n *   Initializer.\n */\nfunction initializeDocument(effects) {\n  const self = this;\n  /** @type {Array<StackItem>} */\n  const stack = [];\n  let continued = 0;\n  /** @type {TokenizeContext | undefined} */\n  let childFlow;\n  /** @type {Token | undefined} */\n  let childToken;\n  /** @type {number} */\n  let lineStartOffset;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    // First we iterate through the open blocks, starting with the root\n    // document, and descending through last children down to the last open\n    // block.\n    // Each block imposes a condition that the line must satisfy if the block is\n    // to remain open.\n    // For example, a block quote requires a `>` character.\n    // A paragraph requires a non-blank line.\n    // In this phase we may match all or just some of the open blocks.\n    // But we cannot close unmatched blocks yet, because we may have a lazy\n    // continuation line.\n    if (continued < stack.length) {\n      const item = stack[continued];\n      self.containerState = item[1];\n      return effects.attempt(item[0].continuation, documentContinue, checkNewContainers)(code);\n    }\n\n    // Done.\n    return checkNewContainers(code);\n  }\n\n  /** @type {State} */\n  function documentContinue(code) {\n    continued++;\n\n    // Note: this field is called `_closeFlow` but it also closes containers.\n    // Perhaps a good idea to rename it but it’s already used in the wild by\n    // extensions.\n    if (self.containerState._closeFlow) {\n      self.containerState._closeFlow = undefined;\n      if (childFlow) {\n        closeFlow();\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when dealing with lazy lines in `writeToChild`.\n      const indexBeforeExits = self.events.length;\n      let indexBeforeFlow = indexBeforeExits;\n      /** @type {Point | undefined} */\n      let point;\n\n      // Find the flow chunk.\n      while (indexBeforeFlow--) {\n        if (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === \"chunkFlow\") {\n          point = self.events[indexBeforeFlow][1].end;\n          break;\n        }\n      }\n      exitContainers(continued);\n\n      // Fix positions.\n      let index = indexBeforeExits;\n      while (index < self.events.length) {\n        self.events[index][1].end = {\n          ...point\n        };\n        index++;\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));\n\n      // Discard the duplicate exits.\n      self.events.length = index;\n      return checkNewContainers(code);\n    }\n    return start(code);\n  }\n\n  /** @type {State} */\n  function checkNewContainers(code) {\n    // Next, after consuming the continuation markers for existing blocks, we\n    // look for new block starts (e.g. `>` for a block quote).\n    // If we encounter a new block start, we close any blocks unmatched in\n    // step 1 before creating the new block as a child of the last matched\n    // block.\n    if (continued === stack.length) {\n      // No need to `check` whether there’s a container, of `exitContainers`\n      // would be moot.\n      // We can instead immediately `attempt` to parse one.\n      if (!childFlow) {\n        return documentContinued(code);\n      }\n\n      // If we have concrete content, such as block HTML or fenced code,\n      // we can’t have containers “pierce” into them, so we can immediately\n      // start.\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        return flowStart(code);\n      }\n\n      // If we do have flow, it could still be a blank line,\n      // but we’d be interrupting it w/ a new container if there’s a current\n      // construct.\n      // To do: next major: remove `_gfmTableDynamicInterruptHack` (no longer\n      // needed in micromark-extension-gfm-table@1.0.6).\n      self.interrupt = Boolean(childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack);\n    }\n\n    // Check if there is a new container.\n    self.containerState = {};\n    return effects.check(containerConstruct, thereIsANewContainer, thereIsNoNewContainer)(code);\n  }\n\n  /** @type {State} */\n  function thereIsANewContainer(code) {\n    if (childFlow) closeFlow();\n    exitContainers(continued);\n    return documentContinued(code);\n  }\n\n  /** @type {State} */\n  function thereIsNoNewContainer(code) {\n    self.parser.lazy[self.now().line] = continued !== stack.length;\n    lineStartOffset = self.now().offset;\n    return flowStart(code);\n  }\n\n  /** @type {State} */\n  function documentContinued(code) {\n    // Try new containers.\n    self.containerState = {};\n    return effects.attempt(containerConstruct, containerContinue, flowStart)(code);\n  }\n\n  /** @type {State} */\n  function containerContinue(code) {\n    continued++;\n    stack.push([self.currentConstruct, self.containerState]);\n    // Try another.\n    return documentContinued(code);\n  }\n\n  /** @type {State} */\n  function flowStart(code) {\n    if (code === null) {\n      if (childFlow) closeFlow();\n      exitContainers(0);\n      effects.consume(code);\n      return;\n    }\n    childFlow = childFlow || self.parser.flow(self.now());\n    effects.enter(\"chunkFlow\", {\n      _tokenizer: childFlow,\n      contentType: \"flow\",\n      previous: childToken\n    });\n    return flowContinue(code);\n  }\n\n  /** @type {State} */\n  function flowContinue(code) {\n    if (code === null) {\n      writeToChild(effects.exit(\"chunkFlow\"), true);\n      exitContainers(0);\n      effects.consume(code);\n      return;\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      writeToChild(effects.exit(\"chunkFlow\"));\n      // Get ready for the next line.\n      continued = 0;\n      self.interrupt = undefined;\n      return start;\n    }\n    effects.consume(code);\n    return flowContinue;\n  }\n\n  /**\n   * @param {Token} token\n   *   Token.\n   * @param {boolean | undefined} [endOfFile]\n   *   Whether the token is at the end of the file (default: `false`).\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function writeToChild(token, endOfFile) {\n    const stream = self.sliceStream(token);\n    if (endOfFile) stream.push(null);\n    token.previous = childToken;\n    if (childToken) childToken.next = token;\n    childToken = token;\n    childFlow.defineSkip(token.start);\n    childFlow.write(stream);\n\n    // Alright, so we just added a lazy line:\n    //\n    // ```markdown\n    // > a\n    // b.\n    //\n    // Or:\n    //\n    // > ~~~c\n    // d\n    //\n    // Or:\n    //\n    // > | e |\n    // f\n    // ```\n    //\n    // The construct in the second example (fenced code) does not accept lazy\n    // lines, so it marked itself as done at the end of its first line, and\n    // then the content construct parses `d`.\n    // Most constructs in markdown match on the first line: if the first line\n    // forms a construct, a non-lazy line can’t “unmake” it.\n    //\n    // The construct in the third example is potentially a GFM table, and\n    // those are *weird*.\n    // It *could* be a table, from the first line, if the following line\n    // matches a condition.\n    // In this case, that second line is lazy, which “unmakes” the first line\n    // and turns the whole into one content block.\n    //\n    // We’ve now parsed the non-lazy and the lazy line, and can figure out\n    // whether the lazy line started a new flow block.\n    // If it did, we exit the current containers between the two flow blocks.\n    if (self.parser.lazy[token.start.line]) {\n      let index = childFlow.events.length;\n      while (index--) {\n        if (\n        // The token starts before the line ending…\n        childFlow.events[index][1].start.offset < lineStartOffset && (\n        // …and either is not ended yet…\n        !childFlow.events[index][1].end ||\n        // …or ends after it.\n        childFlow.events[index][1].end.offset > lineStartOffset)) {\n          // Exit: there’s still something open, which means it’s a lazy line\n          // part of something.\n          return;\n        }\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when closing flow in `documentContinue`.\n      const indexBeforeExits = self.events.length;\n      let indexBeforeFlow = indexBeforeExits;\n      /** @type {boolean | undefined} */\n      let seen;\n      /** @type {Point | undefined} */\n      let point;\n\n      // Find the previous chunk (the one before the lazy line).\n      while (indexBeforeFlow--) {\n        if (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === \"chunkFlow\") {\n          if (seen) {\n            point = self.events[indexBeforeFlow][1].end;\n            break;\n          }\n          seen = true;\n        }\n      }\n      exitContainers(continued);\n\n      // Fix positions.\n      index = indexBeforeExits;\n      while (index < self.events.length) {\n        self.events[index][1].end = {\n          ...point\n        };\n        index++;\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));\n\n      // Discard the duplicate exits.\n      self.events.length = index;\n    }\n  }\n\n  /**\n   * @param {number} size\n   *   Size.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function exitContainers(size) {\n    let index = stack.length;\n\n    // Exit open containers.\n    while (index-- > size) {\n      const entry = stack[index];\n      self.containerState = entry[1];\n      entry[0].exit.call(self, effects);\n    }\n    stack.length = size;\n  }\n  function closeFlow() {\n    childFlow.write([null]);\n    childToken = undefined;\n    childFlow = undefined;\n    self.containerState._closeFlow = undefined;\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n *   Tokenizer.\n */\nfunction tokenizeContainer(effects, ok, nok) {\n  // Always populated by defaults.\n\n  return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok, nok), \"linePrefix\", this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4);\n}"],"names":["document","initializeDocument","containerConstruct","tokenizeContainer","effects","self","stack","continued","childFlow","childToken","lineStartOffset","start","code","item","documentContinue","checkNewContainers","closeFlow","indexBeforeExits","indexBeforeFlow","point","exitContainers","index","splice","documentContinued","flowStart","thereIsANewContainer","thereIsNoNewContainer","containerContinue","flowContinue","writeToChild","markdownLineEnding","token","endOfFile","stream","seen","size","entry","ok","nok","factorySpace"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -0,0 +1,34 @@
+import { factorySpace as l } from "../../../../../micromark-factory-space@2.0.1/node_modules/micromark-factory-space/index.es.js";
+import { blankLine as a } from "../../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/blank-line.es.js";
+import { content as e } from "../../../../../micromark-core-commonmark@2.0.3/node_modules/micromark-core-commonmark/lib/content.es.js";
+const d = {
+  tokenize: m
+};
+function m(n) {
+  const o = this, i = n.attempt(
+    // Try to parse a blank line.
+    a,
+    u,
+    // Try to parse initial flow (essentially, only code).
+    n.attempt(this.parser.constructs.flowInitial, r, l(n, n.attempt(this.parser.constructs.flow, r, n.attempt(e, r)), "linePrefix"))
+  );
+  return i;
+  function u(t) {
+    if (t === null) {
+      n.consume(t);
+      return;
+    }
+    return n.enter("lineEndingBlank"), n.consume(t), n.exit("lineEndingBlank"), o.currentConstruct = void 0, i;
+  }
+  function r(t) {
+    if (t === null) {
+      n.consume(t);
+      return;
+    }
+    return n.enter("lineEnding"), n.consume(t), n.exit("lineEnding"), o.currentConstruct = void 0, i;
+  }
+}
+export {
+  d as flow
+};
+//# sourceMappingURL=flow.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flow.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/flow.js"],"sourcesContent":["/**\n * @import {\n *   InitialConstruct,\n *   Initializer,\n *   State,\n *   TokenizeContext\n * } from 'micromark-util-types'\n */\n\nimport { blankLine, content } from 'micromark-core-commonmark';\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {InitialConstruct} */\nexport const flow = {\n  tokenize: initializeFlow\n};\n\n/**\n * @this {TokenizeContext}\n *   Self.\n * @type {Initializer}\n *   Initializer.\n */\nfunction initializeFlow(effects) {\n  const self = this;\n  const initial = effects.attempt(\n  // Try to parse a blank line.\n  blankLine, atBlankEnding,\n  // Try to parse initial flow (essentially, only code).\n  effects.attempt(this.parser.constructs.flowInitial, afterConstruct, factorySpace(effects, effects.attempt(this.parser.constructs.flow, afterConstruct, effects.attempt(content, afterConstruct)), \"linePrefix\")));\n  return initial;\n\n  /** @type {State} */\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEndingBlank\");\n    effects.consume(code);\n    effects.exit(\"lineEndingBlank\");\n    self.currentConstruct = undefined;\n    return initial;\n  }\n\n  /** @type {State} */\n  function afterConstruct(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    self.currentConstruct = undefined;\n    return initial;\n  }\n}"],"names":["flow","initializeFlow","effects","self","initial","blankLine","atBlankEnding","afterConstruct","factorySpace","content","code"],"mappings":";;;AAaY,MAACA,IAAO;AAAA,EAClB,UAAUC;AACZ;AAQA,SAASA,EAAeC,GAAS;AAC/B,QAAMC,IAAO,MACPC,IAAUF,EAAQ;AAAA;AAAA,IAExBG;AAAA,IAAWC;AAAA;AAAA,IAEXJ,EAAQ,QAAQ,KAAK,OAAO,WAAW,aAAaK,GAAgBC,EAAaN,GAASA,EAAQ,QAAQ,KAAK,OAAO,WAAW,MAAMK,GAAgBL,EAAQ,QAAQO,GAASF,CAAc,CAAC,GAAG,YAAY,CAAC;AAAA,EAAC;AAChN,SAAOH;AAGP,WAASE,EAAcI,GAAM;AAC3B,QAAIA,MAAS,MAAM;AACjB,MAAAR,EAAQ,QAAQQ,CAAI;AACpB;AAAA,IACN;AACI,WAAAR,EAAQ,MAAM,iBAAiB,GAC/BA,EAAQ,QAAQQ,CAAI,GACpBR,EAAQ,KAAK,iBAAiB,GAC9BC,EAAK,mBAAmB,QACjBC;AAAA,EACX;AAGE,WAASG,EAAeG,GAAM;AAC5B,QAAIA,MAAS,MAAM;AACjB,MAAAR,EAAQ,QAAQQ,CAAI;AACpB;AAAA,IACN;AACI,WAAAR,EAAQ,MAAM,YAAY,GAC1BA,EAAQ,QAAQQ,CAAI,GACpBR,EAAQ,KAAK,YAAY,GACzBC,EAAK,mBAAmB,QACjBC;AAAA,EACX;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,96 @@
+const k = {
+  resolveAll: g()
+}, m = x("string"), y = x("text");
+function x(r) {
+  return {
+    resolveAll: g(r === "text" ? p : void 0),
+    tokenize: o
+  };
+  function o(t) {
+    const i = this, e = this.parser.constructs[r], n = t.attempt(e, a, f);
+    return a;
+    function a(l) {
+      return u(l) ? n(l) : f(l);
+    }
+    function f(l) {
+      if (l === null) {
+        t.consume(l);
+        return;
+      }
+      return t.enter("data"), t.consume(l), s;
+    }
+    function s(l) {
+      return u(l) ? (t.exit("data"), n(l)) : (t.consume(l), s);
+    }
+    function u(l) {
+      if (l === null)
+        return !0;
+      const c = e[l];
+      let d = -1;
+      if (c)
+        for (; ++d < c.length; ) {
+          const h = c[d];
+          if (!h.previous || h.previous.call(i, i.previous))
+            return !0;
+        }
+      return !1;
+    }
+  }
+}
+function g(r) {
+  return o;
+  function o(t, i) {
+    let e = -1, n;
+    for (; ++e <= t.length; )
+      n === void 0 ? t[e] && t[e][1].type === "data" && (n = e, e++) : (!t[e] || t[e][1].type !== "data") && (e !== n + 2 && (t[n][1].end = t[e - 1][1].end, t.splice(n + 2, e - n - 2), e = n + 2), n = void 0);
+    return r ? r(t, i) : t;
+  }
+}
+function p(r, o) {
+  let t = 0;
+  for (; ++t <= r.length; )
+    if ((t === r.length || r[t][1].type === "lineEnding") && r[t - 1][1].type === "data") {
+      const i = r[t - 1][1], e = o.sliceStream(i);
+      let n = e.length, a = -1, f = 0, s;
+      for (; n--; ) {
+        const u = e[n];
+        if (typeof u == "string") {
+          for (a = u.length; u.charCodeAt(a - 1) === 32; )
+            f++, a--;
+          if (a) break;
+          a = -1;
+        } else if (u === -2)
+          s = !0, f++;
+        else if (u !== -1) {
+          n++;
+          break;
+        }
+      }
+      if (o._contentTypeTextTrailing && t === r.length && (f = 0), f) {
+        const u = {
+          type: t === r.length || s || f < 2 ? "lineSuffix" : "hardBreakTrailing",
+          start: {
+            _bufferIndex: n ? a : i.start._bufferIndex + a,
+            _index: i.start._index + n,
+            line: i.end.line,
+            column: i.end.column - f,
+            offset: i.end.offset - f
+          },
+          end: {
+            ...i.end
+          }
+        };
+        i.end = {
+          ...u.start
+        }, i.start.offset === i.end.offset ? Object.assign(i, u) : (r.splice(t, 0, ["enter", u, o], ["exit", u, o]), t += 2);
+      }
+      t++;
+    }
+  return r;
+}
+export {
+  k as resolver,
+  m as string,
+  y as text
+};
+//# sourceMappingURL=text.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text.es.js","sources":["../../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/initialize/text.js"],"sourcesContent":["/**\n * @import {\n *   Code,\n *   InitialConstruct,\n *   Initializer,\n *   Resolver,\n *   State,\n *   TokenizeContext\n * } from 'micromark-util-types'\n */\n\nexport const resolver = {\n  resolveAll: createResolver()\n};\nexport const string = initializeFactory('string');\nexport const text = initializeFactory('text');\n\n/**\n * @param {'string' | 'text'} field\n *   Field.\n * @returns {InitialConstruct}\n *   Construct.\n */\nfunction initializeFactory(field) {\n  return {\n    resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined),\n    tokenize: initializeText\n  };\n\n  /**\n   * @this {TokenizeContext}\n   *   Context.\n   * @type {Initializer}\n   */\n  function initializeText(effects) {\n    const self = this;\n    const constructs = this.parser.constructs[field];\n    const text = effects.attempt(constructs, start, notText);\n    return start;\n\n    /** @type {State} */\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code);\n    }\n\n    /** @type {State} */\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code);\n        return;\n      }\n      effects.enter(\"data\");\n      effects.consume(code);\n      return data;\n    }\n\n    /** @type {State} */\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit(\"data\");\n        return text(code);\n      }\n\n      // Data.\n      effects.consume(code);\n      return data;\n    }\n\n    /**\n     * @param {Code} code\n     *   Code.\n     * @returns {boolean}\n     *   Whether the code is a break.\n     */\n    function atBreak(code) {\n      if (code === null) {\n        return true;\n      }\n      const list = constructs[code];\n      let index = -1;\n      if (list) {\n        // Always populated by defaults.\n\n        while (++index < list.length) {\n          const item = list[index];\n          if (!item.previous || item.previous.call(self, self.previous)) {\n            return true;\n          }\n        }\n      }\n      return false;\n    }\n  }\n}\n\n/**\n * @param {Resolver | undefined} [extraResolver]\n *   Resolver.\n * @returns {Resolver}\n *   Resolver.\n */\nfunction createResolver(extraResolver) {\n  return resolveAllText;\n\n  /** @type {Resolver} */\n  function resolveAllText(events, context) {\n    let index = -1;\n    /** @type {number | undefined} */\n    let enter;\n\n    // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === \"data\") {\n          enter = index;\n          index++;\n        }\n      } else if (!events[index] || events[index][1].type !== \"data\") {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end;\n          events.splice(enter + 2, index - enter - 2);\n          index = enter + 2;\n        }\n        enter = undefined;\n      }\n    }\n    return extraResolver ? extraResolver(events, context) : events;\n  }\n}\n\n/**\n * A rather ugly set of instructions which again looks at chunks in the input\n * stream.\n * The reason to do this here is that it is *much* faster to parse in reverse.\n * And that we can’t hook into `null` to split the line suffix before an EOF.\n * To do: figure out if we can make this into a clean utility, or even in core.\n * As it will be useful for GFMs literal autolink extension (and maybe even\n * tables?)\n *\n * @type {Resolver}\n */\nfunction resolveAllLineSuffixes(events, context) {\n  let eventIndex = 0; // Skip first.\n\n  while (++eventIndex <= events.length) {\n    if ((eventIndex === events.length || events[eventIndex][1].type === \"lineEnding\") && events[eventIndex - 1][1].type === \"data\") {\n      const data = events[eventIndex - 1][1];\n      const chunks = context.sliceStream(data);\n      let index = chunks.length;\n      let bufferIndex = -1;\n      let size = 0;\n      /** @type {boolean | undefined} */\n      let tabs;\n      while (index--) {\n        const chunk = chunks[index];\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length;\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++;\n            bufferIndex--;\n          }\n          if (bufferIndex) break;\n          bufferIndex = -1;\n        }\n        // Number\n        else if (chunk === -2) {\n          tabs = true;\n          size++;\n        } else if (chunk === -1) {\n          // Empty\n        } else {\n          // Replacement character, exit.\n          index++;\n          break;\n        }\n      }\n\n      // Allow final trailing whitespace.\n      if (context._contentTypeTextTrailing && eventIndex === events.length) {\n        size = 0;\n      }\n      if (size) {\n        const token = {\n          type: eventIndex === events.length || tabs || size < 2 ? \"lineSuffix\" : \"hardBreakTrailing\",\n          start: {\n            _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex,\n            _index: data.start._index + index,\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size\n          },\n          end: {\n            ...data.end\n          }\n        };\n        data.end = {\n          ...token.start\n        };\n        if (data.start.offset === data.end.offset) {\n          Object.assign(data, token);\n        } else {\n          events.splice(eventIndex, 0, ['enter', token, context], ['exit', token, context]);\n          eventIndex += 2;\n        }\n      }\n      eventIndex++;\n    }\n  }\n  return events;\n}"],"names":["resolver","createResolver","string","initializeFactory","text","field","resolveAllLineSuffixes","initializeText","effects","self","constructs","start","notText","code","atBreak","data","list","index","item","extraResolver","resolveAllText","events","context","enter","eventIndex","chunks","bufferIndex","size","tabs","chunk","token"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -0,0 +1,33 @@
+import { combineExtensions as c } from "../../../../micromark-util-combine-extensions@2.0.1/node_modules/micromark-util-combine-extensions/index.es.js";
+import { content as i } from "./initialize/content.es.js";
+import { document as m } from "./initialize/document.es.js";
+import { flow as f } from "./initialize/flow.es.js";
+import { text as u, string as p } from "./initialize/text.es.js";
+import * as a from "./constructs.es.js";
+import { createTokenizer as x } from "./create-tokenizer.es.js";
+function y(r) {
+  const o = {
+    constructs: (
+      /** @type {FullNormalizedExtension} */
+      c([a, ...(r || {}).extensions || []])
+    ),
+    content: t(i),
+    defined: [],
+    document: t(m),
+    flow: t(f),
+    lazy: {},
+    string: t(p),
+    text: t(u)
+  };
+  return o;
+  function t(n) {
+    return e;
+    function e(s) {
+      return x(o, n, s);
+    }
+  }
+}
+export {
+  y as parse
+};
+//# sourceMappingURL=parse.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/parse.js"],"sourcesContent":["/**\n * @import {\n *   Create,\n *   FullNormalizedExtension,\n *   InitialConstruct,\n *   ParseContext,\n *   ParseOptions\n * } from 'micromark-util-types'\n */\n\nimport { combineExtensions } from 'micromark-util-combine-extensions';\nimport { content } from './initialize/content.js';\nimport { document } from './initialize/document.js';\nimport { flow } from './initialize/flow.js';\nimport { string, text } from './initialize/text.js';\nimport * as defaultConstructs from './constructs.js';\nimport { createTokenizer } from './create-tokenizer.js';\n\n/**\n * @param {ParseOptions | null | undefined} [options]\n *   Configuration (optional).\n * @returns {ParseContext}\n *   Parser.\n */\nexport function parse(options) {\n  const settings = options || {};\n  const constructs = /** @type {FullNormalizedExtension} */\n  combineExtensions([defaultConstructs, ...(settings.extensions || [])]);\n\n  /** @type {ParseContext} */\n  const parser = {\n    constructs,\n    content: create(content),\n    defined: [],\n    document: create(document),\n    flow: create(flow),\n    lazy: {},\n    string: create(string),\n    text: create(text)\n  };\n  return parser;\n\n  /**\n   * @param {InitialConstruct} initial\n   *   Construct to start with.\n   * @returns {Create}\n   *   Create a tokenizer.\n   */\n  function create(initial) {\n    return creator;\n    /** @type {Create} */\n    function creator(from) {\n      return createTokenizer(parser, initial, from);\n    }\n  }\n}"],"names":["parse","options","parser","combineExtensions","defaultConstructs","create","content","document","flow","string","text","initial","creator","from","createTokenizer"],"mappings":";;;;;;;AAwBO,SAASA,EAAMC,GAAS;AAM7B,QAAMC,IAAS;AAAA,IACjB;AAAA;AAAA,MAJEC,EAAkB,CAACC,GAAmB,IAFrBH,KAAW,CAAE,GAEqB,cAAc,CAAE,CAAC,CAAC;AAAA;AAAA,IAKnE,SAASI,EAAOC,CAAO;AAAA,IACvB,SAAS,CAAE;AAAA,IACX,UAAUD,EAAOE,CAAQ;AAAA,IACzB,MAAMF,EAAOG,CAAI;AAAA,IACjB,MAAM,CAAE;AAAA,IACR,QAAQH,EAAOI,CAAM;AAAA,IACrB,MAAMJ,EAAOK,CAAI;AAAA,EAClB;AACD,SAAOR;AAQP,WAASG,EAAOM,GAAS;AACvB,WAAOC;AAEP,aAASA,EAAQC,GAAM;AACrB,aAAOC,EAAgBZ,GAAQS,GAASE,CAAI;AAAA,IAClD;AAAA,EACA;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,10 @@
+import { subtokenize as r } from "../../../../micromark-util-subtokenize@2.1.0/node_modules/micromark-util-subtokenize/index.es.js";
+function e(o) {
+  for (; !r(o); )
+    ;
+  return o;
+}
+export {
+  e as postprocess
+};
+//# sourceMappingURL=postprocess.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"postprocess.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/postprocess.js"],"sourcesContent":["/**\n * @import {Event} from 'micromark-util-types'\n */\n\nimport { subtokenize } from 'micromark-util-subtokenize';\n\n/**\n * @param {Array<Event>} events\n *   Events.\n * @returns {Array<Event>}\n *   Events.\n */\nexport function postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n  return events;\n}"],"names":["postprocess","events","subtokenize"],"mappings":";AAYO,SAASA,EAAYC,GAAQ;AAClC,SAAO,CAACC,EAAYD,CAAM;AAAG;AAG7B,SAAOA;AACT;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,40 @@
+const u = /[\0\t\n\r]/g;
+function x() {
+  let s = 1, c = "", f = !0, r;
+  return p;
+  function p(e, l, a) {
+    const t = [];
+    let d, o, n, i, h;
+    for (e = c + (typeof e == "string" ? e.toString() : new TextDecoder(l || void 0).decode(e)), n = 0, c = "", f && (e.charCodeAt(0) === 65279 && n++, f = void 0); n < e.length; ) {
+      if (u.lastIndex = n, d = u.exec(e), i = d && d.index !== void 0 ? d.index : e.length, h = e.charCodeAt(i), !d) {
+        c = e.slice(n);
+        break;
+      }
+      if (h === 10 && n === i && r)
+        t.push(-3), r = void 0;
+      else
+        switch (r && (t.push(-5), r = void 0), n < i && (t.push(e.slice(n, i)), s += i - n), h) {
+          case 0: {
+            t.push(65533), s++;
+            break;
+          }
+          case 9: {
+            for (o = Math.ceil(s / 4) * 4, t.push(-2); s++ < o; ) t.push(-1);
+            break;
+          }
+          case 10: {
+            t.push(-4), s = 1;
+            break;
+          }
+          default:
+            r = !0, s = 1;
+        }
+      n = i + 1;
+    }
+    return a && (r && t.push(-5), c && t.push(c), t.push(null)), t;
+  }
+}
+export {
+  x as preprocess
+};
+//# sourceMappingURL=preprocess.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"preprocess.es.js","sources":["../../../../../../../../../node_modules/.pnpm/micromark@4.0.2/node_modules/micromark/lib/preprocess.js"],"sourcesContent":["/**\n * @import {Chunk, Code, Encoding, Value} from 'micromark-util-types'\n */\n\n/**\n * @callback Preprocessor\n *   Preprocess a value.\n * @param {Value} value\n *   Value.\n * @param {Encoding | null | undefined} [encoding]\n *   Encoding when `value` is a typed array (optional).\n * @param {boolean | null | undefined} [end=false]\n *   Whether this is the last chunk (default: `false`).\n * @returns {Array<Chunk>}\n *   Chunks.\n */\n\nconst search = /[\\0\\t\\n\\r]/g;\n\n/**\n * @returns {Preprocessor}\n *   Preprocess a value.\n */\nexport function preprocess() {\n  let column = 1;\n  let buffer = '';\n  /** @type {boolean | undefined} */\n  let start = true;\n  /** @type {boolean | undefined} */\n  let atCarriageReturn;\n  return preprocessor;\n\n  /** @type {Preprocessor} */\n  // eslint-disable-next-line complexity\n  function preprocessor(value, encoding, end) {\n    /** @type {Array<Chunk>} */\n    const chunks = [];\n    /** @type {RegExpMatchArray | null} */\n    let match;\n    /** @type {number} */\n    let next;\n    /** @type {number} */\n    let startPosition;\n    /** @type {number} */\n    let endPosition;\n    /** @type {Code} */\n    let code;\n    value = buffer + (typeof value === 'string' ? value.toString() : new TextDecoder(encoding || undefined).decode(value));\n    startPosition = 0;\n    buffer = '';\n    if (start) {\n      // To do: `markdown-rs` actually parses BOMs (byte order mark).\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++;\n      }\n      start = undefined;\n    }\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition;\n      match = search.exec(value);\n      endPosition = match && match.index !== undefined ? match.index : value.length;\n      code = value.charCodeAt(endPosition);\n      if (!match) {\n        buffer = value.slice(startPosition);\n        break;\n      }\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3);\n        atCarriageReturn = undefined;\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5);\n          atCarriageReturn = undefined;\n        }\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition));\n          column += endPosition - startPosition;\n        }\n        switch (code) {\n          case 0:\n            {\n              chunks.push(65533);\n              column++;\n              break;\n            }\n          case 9:\n            {\n              next = Math.ceil(column / 4) * 4;\n              chunks.push(-2);\n              while (column++ < next) chunks.push(-1);\n              break;\n            }\n          case 10:\n            {\n              chunks.push(-4);\n              column = 1;\n              break;\n            }\n          default:\n            {\n              atCarriageReturn = true;\n              column = 1;\n            }\n        }\n      }\n      startPosition = endPosition + 1;\n    }\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5);\n      if (buffer) chunks.push(buffer);\n      chunks.push(null);\n    }\n    return chunks;\n  }\n}"],"names":["search","preprocess","column","buffer","start","atCarriageReturn","preprocessor","value","encoding","end","chunks","match","next","startPosition","endPosition","code"],"mappings":"AAiBA,MAAMA,IAAS;AAMR,SAASC,IAAa;AAC3B,MAAIC,IAAS,GACTC,IAAS,IAETC,IAAQ,IAERC;AACJ,SAAOC;AAIP,WAASA,EAAaC,GAAOC,GAAUC,GAAK;AAE1C,UAAMC,IAAS,CAAE;AAEjB,QAAIC,GAEAC,GAEAC,GAEAC,GAEAC;AAWJ,SAVAR,IAAQJ,KAAU,OAAOI,KAAU,WAAWA,EAAM,SAAQ,IAAK,IAAI,YAAYC,KAAY,MAAS,EAAE,OAAOD,CAAK,IACpHM,IAAgB,GAChBV,IAAS,IACLC,MAEEG,EAAM,WAAW,CAAC,MAAM,SAC1BM,KAEFT,IAAQ,SAEHS,IAAgBN,EAAM,UAAQ;AAKnC,UAJAP,EAAO,YAAYa,GACnBF,IAAQX,EAAO,KAAKO,CAAK,GACzBO,IAAcH,KAASA,EAAM,UAAU,SAAYA,EAAM,QAAQJ,EAAM,QACvEQ,IAAOR,EAAM,WAAWO,CAAW,GAC/B,CAACH,GAAO;AACV,QAAAR,IAASI,EAAM,MAAMM,CAAa;AAClC;AAAA,MACR;AACM,UAAIE,MAAS,MAAMF,MAAkBC,KAAeT;AAClD,QAAAK,EAAO,KAAK,EAAE,GACdL,IAAmB;AAAA;AAUnB,gBARIA,MACFK,EAAO,KAAK,EAAE,GACdL,IAAmB,SAEjBQ,IAAgBC,MAClBJ,EAAO,KAAKH,EAAM,MAAMM,GAAeC,CAAW,CAAC,GACnDZ,KAAUY,IAAcD,IAElBE,GAAI;AAAA,UACV,KAAK,GACH;AACE,YAAAL,EAAO,KAAK,KAAK,GACjBR;AACA;AAAA,UACd;AAAA,UACU,KAAK,GACH;AAGE,iBAFAU,IAAO,KAAK,KAAKV,IAAS,CAAC,IAAI,GAC/BQ,EAAO,KAAK,EAAE,GACPR,MAAWU,IAAM,CAAAF,EAAO,KAAK,EAAE;AACtC;AAAA,UACd;AAAA,UACU,KAAK,IACH;AACE,YAAAA,EAAO,KAAK,EAAE,GACdR,IAAS;AACT;AAAA,UACd;AAAA,UACU;AAEI,YAAAG,IAAmB,IACnBH,IAAS;AAAA,QAEvB;AAEM,MAAAW,IAAgBC,IAAc;AAAA,IACpC;AACI,WAAIL,MACEJ,KAAkBK,EAAO,KAAK,EAAE,GAChCP,KAAQO,EAAO,KAAKP,CAAM,GAC9BO,EAAO,KAAK,IAAI,IAEXA;AAAA,EACX;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/object-assign@4.1.1/node_modules/object-assign/index.es.js

@@ -0,0 +1,55 @@
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var f, i;
+function p() {
+  if (i) return f;
+  i = 1;
+  var u = Object.getOwnPropertySymbols, b = Object.prototype.hasOwnProperty, l = Object.prototype.propertyIsEnumerable;
+  function O(n) {
+    if (n == null)
+      throw new TypeError("Object.assign cannot be called with null or undefined");
+    return Object(n);
+  }
+  function j() {
+    try {
+      if (!Object.assign)
+        return !1;
+      var n = new String("abc");
+      if (n[5] = "de", Object.getOwnPropertyNames(n)[0] === "5")
+        return !1;
+      for (var s = {}, r = 0; r < 10; r++)
+        s["_" + String.fromCharCode(r)] = r;
+      var a = Object.getOwnPropertyNames(s).map(function(e) {
+        return s[e];
+      });
+      if (a.join("") !== "0123456789")
+        return !1;
+      var t = {};
+      return "abcdefghijklmnopqrst".split("").forEach(function(e) {
+        t[e] = e;
+      }), Object.keys(Object.assign({}, t)).join("") === "abcdefghijklmnopqrst";
+    } catch {
+      return !1;
+    }
+  }
+  return f = j() ? Object.assign : function(n, s) {
+    for (var r, a = O(n), t, e = 1; e < arguments.length; e++) {
+      r = Object(arguments[e]);
+      for (var c in r)
+        b.call(r, c) && (a[c] = r[c]);
+      if (u) {
+        t = u(r);
+        for (var o = 0; o < t.length; o++)
+          l.call(r, t[o]) && (a[t[o]] = r[t[o]]);
+      }
+    }
+    return a;
+  }, f;
+}
+export {
+  p as __require
+};
+//# sourceMappingURL=index.es.js.map

package/dist/node_modules/.pnpm/object-assign@4.1.1/node_modules/object-assign/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../../../node_modules/.pnpm/object-assign@4.1.1/node_modules/object-assign/index.js"],"sourcesContent":["/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n"],"names":["getOwnPropertySymbols","hasOwnProperty","propIsEnumerable","toObject","val","shouldUseNative","test1","test2","i","order2","n","test3","letter","objectAssign","target","source","from","to","symbols","s","key"],"mappings":";;;;;;;;;AAQA,MAAIA,IAAwB,OAAO,uBAC/BC,IAAiB,OAAO,UAAU,gBAClCC,IAAmB,OAAO,UAAU;AAExC,WAASC,EAASC,GAAK;AACtB,QAAIA,KAAQ;AACX,YAAM,IAAI,UAAU,uDAAuD;AAG5E,WAAO,OAAOA,CAAG;AAAA;AAGlB,WAASC,IAAkB;AAC1B,QAAI;AACH,UAAI,CAAC,OAAO;AACX,eAAO;AAMR,UAAIC,IAAQ,IAAI,OAAO,KAAK;AAE5B,UADAA,EAAM,CAAC,IAAI,MACP,OAAO,oBAAoBA,CAAK,EAAE,CAAC,MAAM;AAC5C,eAAO;AAKR,eADIC,IAAQ,CAAE,GACLC,IAAI,GAAGA,IAAI,IAAIA;AACvB,QAAAD,EAAM,MAAM,OAAO,aAAaC,CAAC,CAAC,IAAIA;AAEvC,UAAIC,IAAS,OAAO,oBAAoBF,CAAK,EAAE,IAAI,SAAUG,GAAG;AAC/D,eAAOH,EAAMG,CAAC;AAAA,MACjB,CAAG;AACD,UAAID,EAAO,KAAK,EAAE,MAAM;AACvB,eAAO;AAIR,UAAIE,IAAQ,CAAE;AAId,aAHA,uBAAuB,MAAM,EAAE,EAAE,QAAQ,SAAUC,GAAQ;AAC1D,QAAAD,EAAMC,CAAM,IAAIA;AAAA,MACnB,CAAG,GACG,OAAO,KAAK,OAAO,OAAO,CAAE,GAAED,CAAK,CAAC,EAAE,KAAK,EAAE,MAC/C;AAAA,IAKF,QAAa;AAEb,aAAO;AAAA;;AAIT,SAAAE,IAAiBR,EAAe,IAAK,OAAO,SAAS,SAAUS,GAAQC,GAAQ;AAK9E,aAJIC,GACAC,IAAKd,EAASW,CAAM,GACpBI,GAEKC,IAAI,GAAGA,IAAI,UAAU,QAAQA,KAAK;AAC1C,MAAAH,IAAO,OAAO,UAAUG,CAAC,CAAC;AAE1B,eAASC,KAAOJ;AACf,QAAIf,EAAe,KAAKe,GAAMI,CAAG,MAChCH,EAAGG,CAAG,IAAIJ,EAAKI,CAAG;AAIpB,UAAIpB,GAAuB;AAC1B,QAAAkB,IAAUlB,EAAsBgB,CAAI;AACpC,iBAASR,IAAI,GAAGA,IAAIU,EAAQ,QAAQV;AACnC,UAAIN,EAAiB,KAAKc,GAAME,EAAQV,CAAC,CAAC,MACzCS,EAAGC,EAAQV,CAAC,CAAC,IAAIQ,EAAKE,EAAQV,CAAC,CAAC;AAAA;;AAMpC,WAAOS;AAAA,EACP;;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/checkPropTypes.es.js

@@ -0,0 +1,55 @@
+import { __require as E } from "./lib/ReactPropTypesSecret.es.js";
+import { __require as _ } from "./lib/has.es.js";
+var f, v;
+function P() {
+  if (v) return f;
+  v = 1;
+  var o = function() {
+  };
+  if (process.env.NODE_ENV !== "production") {
+    var y = E(), t = {}, d = _();
+    o = function(n) {
+      var a = "Warning: " + n;
+      typeof console < "u" && console.error(a);
+      try {
+        throw new Error(a);
+      } catch {
+      }
+    };
+  }
+  function u(n, a, i, s, c) {
+    if (process.env.NODE_ENV !== "production") {
+      for (var e in n)
+        if (d(n, e)) {
+          var r;
+          try {
+            if (typeof n[e] != "function") {
+              var h = Error(
+                (s || "React class") + ": " + i + " type `" + e + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof n[e] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+              );
+              throw h.name = "Invariant Violation", h;
+            }
+            r = n[e](a, e, s, i, null, y);
+          } catch (l) {
+            r = l;
+          }
+          if (r && !(r instanceof Error) && o(
+            (s || "React class") + ": type specification of " + i + " `" + e + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof r + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+          ), r instanceof Error && !(r.message in t)) {
+            t[r.message] = !0;
+            var p = c ? c() : "";
+            o(
+              "Failed " + i + " type: " + r.message + (p ?? "")
+            );
+          }
+        }
+    }
+  }
+  return u.resetWarningCache = function() {
+    process.env.NODE_ENV !== "production" && (t = {});
+  }, f = u, f;
+}
+export {
+  P as __require
+};
+//# sourceMappingURL=checkPropTypes.es.js.map

package/dist/node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/checkPropTypes.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkPropTypes.es.js","sources":["../../../../../../../../node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/checkPropTypes.js"],"sourcesContent":["/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar printWarning = function() {};\n\nif (process.env.NODE_ENV !== 'production') {\n  var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n  var loggedTypeFailures = {};\n  var has = require('./lib/has');\n\n  printWarning = function(text) {\n    var message = 'Warning: ' + text;\n    if (typeof console !== 'undefined') {\n      console.error(message);\n    }\n    try {\n      // --- Welcome to debugging React ---\n      // This error was thrown as a convenience so that you can use this stack\n      // to find the callsite that caused this warning to fire.\n      throw new Error(message);\n    } catch (x) { /**/ }\n  };\n}\n\n/**\n * Assert that the values match with the type specs.\n * Error messages are memorized and will only be shown once.\n *\n * @param {object} typeSpecs Map of name to a ReactPropType\n * @param {object} values Runtime values that need to be type-checked\n * @param {string} location e.g. \"prop\", \"context\", \"child context\"\n * @param {string} componentName Name of the component for error messages.\n * @param {?Function} getStack Returns the component stack.\n * @private\n */\nfunction checkPropTypes(typeSpecs, values, location, componentName, getStack) {\n  if (process.env.NODE_ENV !== 'production') {\n    for (var typeSpecName in typeSpecs) {\n      if (has(typeSpecs, typeSpecName)) {\n        var error;\n        // Prop type validation may throw. In case they do, we don't want to\n        // fail the render phase where it didn't fail before. So we log it.\n        // After these have been cleaned up, we'll let them throw.\n        try {\n          // This is intentionally an invariant that gets caught. It's the same\n          // behavior as without this statement except with a better message.\n          if (typeof typeSpecs[typeSpecName] !== 'function') {\n            var err = Error(\n              (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +\n              'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' +\n              'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'\n            );\n            err.name = 'Invariant Violation';\n            throw err;\n          }\n          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);\n        } catch (ex) {\n          error = ex;\n        }\n        if (error && !(error instanceof Error)) {\n          printWarning(\n            (componentName || 'React class') + ': type specification of ' +\n            location + ' `' + typeSpecName + '` is invalid; the type checker ' +\n            'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +\n            'You may have forgotten to pass an argument to the type checker ' +\n            'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +\n            'shape all require an argument).'\n          );\n        }\n        if (error instanceof Error && !(error.message in loggedTypeFailures)) {\n          // Only monitor this failure once because there tends to be a lot of the\n          // same error.\n          loggedTypeFailures[error.message] = true;\n\n          var stack = getStack ? getStack() : '';\n\n          printWarning(\n            'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')\n          );\n        }\n      }\n    }\n  }\n}\n\n/**\n * Resets warning cache when testing.\n *\n * @private\n */\ncheckPropTypes.resetWarningCache = function() {\n  if (process.env.NODE_ENV !== 'production') {\n    loggedTypeFailures = {};\n  }\n}\n\nmodule.exports = checkPropTypes;\n"],"names":["printWarning","ReactPropTypesSecret","require$$0","loggedTypeFailures","has","require$$1","text","message","checkPropTypes","typeSpecs","values","location","componentName","getStack","typeSpecName","error","err","ex","stack","checkPropTypes_1"],"mappings":";;;;;;AASA,MAAIA,IAAe,WAAW;AAAA,EAAE;AAEhC,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,QAAIC,IAAuBC,EAAqC,GAC5DC,IAAqB,CAAE,GACvBC,IAAMC,EAAoB;AAE9B,IAAAL,IAAe,SAASM,GAAM;AAC5B,UAAIC,IAAU,cAAcD;AAC5B,MAAI,OAAO,UAAY,OACrB,QAAQ,MAAMC,CAAO;AAEvB,UAAI;AAIF,cAAM,IAAI,MAAMA,CAAO;AAAA,MACxB,QAAW;AAAA,MAAA;AAAA,IACb;AAAA;AAcH,WAASC,EAAeC,GAAWC,GAAQC,GAAUC,GAAeC,GAAU;AAC5E,QAAI,QAAQ,IAAI,aAAa;AAC3B,eAASC,KAAgBL;AACvB,YAAIL,EAAIK,GAAWK,CAAY,GAAG;AAChC,cAAIC;AAIJ,cAAI;AAGF,gBAAI,OAAON,EAAUK,CAAY,KAAM,YAAY;AACjD,kBAAIE,IAAM;AAAA,iBACPJ,KAAiB,iBAAiB,OAAOD,IAAW,YAAYG,IAAe,+FACC,OAAOL,EAAUK,CAAY,IAAI;AAAA,cAEnH;AACD,oBAAAE,EAAI,OAAO,uBACLA;AAAA;AAER,YAAAD,IAAQN,EAAUK,CAAY,EAAEJ,GAAQI,GAAcF,GAAeD,GAAU,MAAMV,CAAoB;AAAA,UAC1G,SAAQgB,GAAI;AACX,YAAAF,IAAQE;AAAA;AAYV,cAVIF,KAAS,EAAEA,aAAiB,UAC9Bf;AAAA,aACGY,KAAiB,iBAAiB,6BACnCD,IAAW,OAAOG,IAAe,6FAC6B,OAAOC,IAAQ;AAAA,UAI9E,GAECA,aAAiB,SAAS,EAAEA,EAAM,WAAWZ,IAAqB;AAGpE,YAAAA,EAAmBY,EAAM,OAAO,IAAI;AAEpC,gBAAIG,IAAQL,IAAWA,EAAQ,IAAK;AAEpC,YAAAb;AAAA,cACE,YAAYW,IAAW,YAAYI,EAAM,WAAWG,KAAwB;AAAA,YAC7E;AAAA;;;;AAYX,SAAAV,EAAe,oBAAoB,WAAW;AAC5C,IAAI,QAAQ,IAAI,aAAa,iBAC3BL,IAAqB,CAAE;AAAA,KAI3BgB,IAAiBX;;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/factoryWithThrowingShims.es.js

@@ -0,0 +1,53 @@
+import { __require as u } from "./lib/ReactPropTypesSecret.es.js";
+var o, p;
+function g() {
+  if (p) return o;
+  p = 1;
+  var c = u();
+  function n() {
+  }
+  function i() {
+  }
+  return i.resetWarningCache = n, o = function() {
+    function e(h, y, m, f, l, s) {
+      if (s !== c) {
+        var a = new Error(
+          "Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types"
+        );
+        throw a.name = "Invariant Violation", a;
+      }
+    }
+    e.isRequired = e;
+    function r() {
+      return e;
+    }
+    var t = {
+      array: e,
+      bigint: e,
+      bool: e,
+      func: e,
+      number: e,
+      object: e,
+      string: e,
+      symbol: e,
+      any: e,
+      arrayOf: r,
+      element: e,
+      elementType: e,
+      instanceOf: r,
+      node: e,
+      objectOf: r,
+      oneOf: r,
+      oneOfType: r,
+      shape: r,
+      exact: r,
+      checkPropTypes: i,
+      resetWarningCache: n
+    };
+    return t.PropTypes = t, t;
+  }, o;
+}
+export {
+  g as __require
+};
+//# sourceMappingURL=factoryWithThrowingShims.es.js.map

package/dist/node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/factoryWithThrowingShims.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factoryWithThrowingShims.es.js","sources":["../../../../../../../../node_modules/.pnpm/prop-types@15.8.1/node_modules/prop-types/factoryWithThrowingShims.js"],"sourcesContent":["/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nfunction emptyFunction() {}\nfunction emptyFunctionWithReset() {}\nemptyFunctionWithReset.resetWarningCache = emptyFunction;\n\nmodule.exports = function() {\n  function shim(props, propName, componentName, location, propFullName, secret) {\n    if (secret === ReactPropTypesSecret) {\n      // It is still safe when called from React.\n      return;\n    }\n    var err = new Error(\n      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n      'Use PropTypes.checkPropTypes() to call them. ' +\n      'Read more at http://fb.me/use-check-prop-types'\n    );\n    err.name = 'Invariant Violation';\n    throw err;\n  };\n  shim.isRequired = shim;\n  function getShim() {\n    return shim;\n  };\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n  var ReactPropTypes = {\n    array: shim,\n    bigint: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    elementType: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim,\n    exact: getShim,\n\n    checkPropTypes: emptyFunctionWithReset,\n    resetWarningCache: emptyFunction\n  };\n\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n"],"names":["ReactPropTypesSecret","require$$0","emptyFunction","emptyFunctionWithReset","factoryWithThrowingShims","shim","props","propName","componentName","location","propFullName","secret","err","getShim","ReactPropTypes"],"mappings":";;;;;AASA,MAAIA,IAAuBC,EAAqC;AAEhE,WAASC,IAAgB;AAAA,EAAA;AACzB,WAASC,IAAyB;AAAA,EAAA;AAClC,SAAAA,EAAuB,oBAAoBD,GAE3CE,IAAiB,WAAW;AAC1B,aAASC,EAAKC,GAAOC,GAAUC,GAAeC,GAAUC,GAAcC,GAAQ;AAC5E,UAAIA,MAAWX,GAIf;AAAA,YAAIY,IAAM,IAAI;AAAA,UACZ;AAAA,QAGD;AACD,cAAAA,EAAI,OAAO,uBACLA;AAAA;AAAA,IACV;AACE,IAAAP,EAAK,aAAaA;AAClB,aAASQ,IAAU;AACjB,aAAOR;AAAA,IAEX;AAEE,QAAIS,IAAiB;AAAA,MACnB,OAAOT;AAAA,MACP,QAAQA;AAAA,MACR,MAAMA;AAAA,MACN,MAAMA;AAAA,MACN,QAAQA;AAAA,MACR,QAAQA;AAAA,MACR,QAAQA;AAAA,MACR,QAAQA;AAAA,MAER,KAAKA;AAAA,MACL,SAASQ;AAAA,MACT,SAASR;AAAA,MACT,aAAaA;AAAA,MACb,YAAYQ;AAAA,MACZ,MAAMR;AAAA,MACN,UAAUQ;AAAA,MACV,OAAOA;AAAA,MACP,WAAWA;AAAA,MACX,OAAOA;AAAA,MACP,OAAOA;AAAA,MAEP,gBAAgBV;AAAA,MAChB,mBAAmBD;AAAA,IACpB;AAED,WAAAY,EAAe,YAAYA,GAEpBA;AAAA,EACR;;","x_google_ignoreList":[0]}