@sheetxl/studio-vanilla 0.4.11 → 0.4.12

package/cdn/assets/DBL4jY0AVc53RGNm.js

@@ -0,0 +1,637 @@
+/**
+ * @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.4.12
+ *
+ * (C) 2025-present SheetXL Inc. & Michael T. Ford
+ * License: The license can be found at https://www.sheetxl.com/license.
+ */
+function S(t) {
+  return Array.isArray ? Array.isArray(t) : ne(t) === "[object Array]";
+}
+function v(t) {
+  return typeof t == "string";
+}
+function te(t) {
+  return typeof t == "number";
+}
+function ae(t) {
+  return t === !0 || t === !1 || function(e) {
+    return ie(e) && e !== null;
+  }(t) && ne(t) == "[object Boolean]";
+}
+function ie(t) {
+  return typeof t == "object";
+}
+function E(t) {
+  return t != null;
+}
+function K(t) {
+  return !t.trim().length;
+}
+function ne(t) {
+  return t == null ? t === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(t);
+}
+const H = Object.prototype.hasOwnProperty;
+class le {
+  constructor(e) {
+    this._keys = [], this._keyMap = {};
+    let i = 0;
+    e.forEach((s) => {
+      let n = se(s);
+      this._keys.push(n), this._keyMap[n.id] = n, i += n.weight;
+    }), this._keys.forEach((s) => {
+      s.weight /= i;
+    });
+  }
+  get(e) {
+    return this._keyMap[e];
+  }
+  keys() {
+    return this._keys;
+  }
+  toJSON() {
+    return JSON.stringify(this._keys);
+  }
+}
+function se(t) {
+  let e = null, i = null, s = null, n = 1, u = null;
+  if (v(t) || S(t)) s = t, e = T(t), i = q(t);
+  else {
+    if (!H.call(t, "name")) throw new Error("Missing name property in key");
+    const c = t.name;
+    if (s = c, H.call(t, "weight") && (n = t.weight, n <= 0)) throw new Error(((o) => `Property 'weight' in key '${o}' must be a positive integer`)(c));
+    e = T(c), i = q(c), u = t.getFn;
+  }
+  return { path: e, id: i, weight: n, src: s, getFn: u };
+}
+function T(t) {
+  return S(t) ? t : t.split(".");
+}
+function q(t) {
+  return S(t) ? t.join(".") : t;
+}
+var l = { isCaseSensitive: !1, ignoreDiacritics: !1, includeScore: !1, keys: [], shouldSort: !0, sortFn: (t, e) => t.score === e.score ? t.idx < e.idx ? -1 : 1 : t.score < e.score ? -1 : 1, includeMatches: !1, findAllMatches: !1, minMatchCharLength: 1, location: 0, threshold: 0.6, distance: 100, useExtendedSearch: !1, getFn: function(t, e) {
+  let i = [], s = !1;
+  const n = (u, c, o) => {
+    if (E(u)) if (c[o]) {
+      const r = u[c[o]];
+      if (!E(r)) return;
+      if (o === c.length - 1 && (v(r) || te(r) || ae(r))) i.push(function(a) {
+        return a == null ? "" : function(h) {
+          if (typeof h == "string") return h;
+          let d = h + "";
+          return d == "0" && 1 / h == -1 / 0 ? "-0" : d;
+        }(a);
+      }(r));
+      else if (S(r)) {
+        s = !0;
+        for (let a = 0, h = r.length; a < h; a += 1) n(r[a], c, o + 1);
+      } else c.length && n(r, c, o + 1);
+    } else i.push(u);
+  };
+  return n(t, v(e) ? e.split(".") : e, 0), s ? i : i[0];
+}, ignoreLocation: !1, ignoreFieldNorm: !1, fieldNormWeight: 1 };
+const de = /[^ ]+/g;
+class U {
+  constructor({ getFn: e = l.getFn, fieldNormWeight: i = l.fieldNormWeight } = {}) {
+    this.norm = function(s = 1, n = 3) {
+      const u = /* @__PURE__ */ new Map(), c = Math.pow(10, n);
+      return { get(o) {
+        const r = o.match(de).length;
+        if (u.has(r)) return u.get(r);
+        const a = 1 / Math.pow(r, 0.5 * s), h = parseFloat(Math.round(a * c) / c);
+        return u.set(r, h), h;
+      }, clear() {
+        u.clear();
+      } };
+    }(i, 3), this.getFn = e, this.isCreated = !1, this.setIndexRecords();
+  }
+  setSources(e = []) {
+    this.docs = e;
+  }
+  setIndexRecords(e = []) {
+    this.records = e;
+  }
+  setKeys(e = []) {
+    this.keys = e, this._keysMap = {}, e.forEach((i, s) => {
+      this._keysMap[i.id] = s;
+    });
+  }
+  create() {
+    !this.isCreated && this.docs.length && (this.isCreated = !0, v(this.docs[0]) ? this.docs.forEach((e, i) => {
+      this._addString(e, i);
+    }) : this.docs.forEach((e, i) => {
+      this._addObject(e, i);
+    }), this.norm.clear());
+  }
+  add(e) {
+    const i = this.size();
+    v(e) ? this._addString(e, i) : this._addObject(e, i);
+  }
+  removeAt(e) {
+    this.records.splice(e, 1);
+    for (let i = e, s = this.size(); i < s; i += 1) this.records[i].i -= 1;
+  }
+  getValueForItemAtKeyId(e, i) {
+    return e[this._keysMap[i]];
+  }
+  size() {
+    return this.records.length;
+  }
+  _addString(e, i) {
+    if (!E(e) || K(e)) return;
+    let s = { v: e, i, n: this.norm.get(e) };
+    this.records.push(s);
+  }
+  _addObject(e, i) {
+    let s = { i, $: {} };
+    this.keys.forEach((n, u) => {
+      let c = n.getFn ? n.getFn(e) : this.getFn(e, n.path);
+      if (E(c)) {
+        if (S(c)) {
+          let o = [];
+          const r = [{ nestedArrIndex: -1, value: c }];
+          for (; r.length; ) {
+            const { nestedArrIndex: a, value: h } = r.pop();
+            if (E(h)) if (v(h) && !K(h)) {
+              let d = { v: h, i: a, n: this.norm.get(h) };
+              o.push(d);
+            } else S(h) && h.forEach((d, f) => {
+              r.push({ nestedArrIndex: f, value: d });
+            });
+          }
+          s.$[u] = o;
+        } else if (v(c) && !K(c)) {
+          let o = { v: c, n: this.norm.get(c) };
+          s.$[u] = o;
+        }
+      }
+    }), this.records.push(s);
+  }
+  toJSON() {
+    return { keys: this.keys, records: this.records };
+  }
+}
+function re(t, e, { getFn: i = l.getFn, fieldNormWeight: s = l.fieldNormWeight } = {}) {
+  const n = new U({ getFn: i, fieldNormWeight: s });
+  return n.setKeys(t.map(se)), n.setSources(e), n.create(), n;
+}
+function j(t, { errors: e = 0, currentLocation: i = 0, expectedLocation: s = 0, distance: n = l.distance, ignoreLocation: u = l.ignoreLocation } = {}) {
+  const c = e / t.length;
+  if (u) return c;
+  const o = Math.abs(s - i);
+  return n ? c + o / n : o ? 1 : c;
+}
+const N = 32;
+function ge(t, e, i, { location: s = l.location, distance: n = l.distance, threshold: u = l.threshold, findAllMatches: c = l.findAllMatches, minMatchCharLength: o = l.minMatchCharLength, includeMatches: r = l.includeMatches, ignoreLocation: a = l.ignoreLocation } = {}) {
+  if (e.length > N) throw new Error("Pattern length exceeds max of 32.");
+  const h = e.length, d = t.length, f = Math.max(0, Math.min(s, d));
+  let g = u, A = f;
+  const p = o > 1 || r, m = p ? Array(d) : [];
+  let F;
+  for (; (F = t.indexOf(e, A)) > -1; ) {
+    let y = j(e, { currentLocation: F, expectedLocation: f, distance: n, ignoreLocation: a });
+    if (g = Math.min(y, g), A = F + h, p) {
+      let B = 0;
+      for (; B < h; ) m[F + B] = 1, B += 1;
+    }
+  }
+  A = -1;
+  let L = [], D = 1, M = h + d;
+  const w = 1 << h - 1;
+  for (let y = 0; y < h; y += 1) {
+    let B = 0, k = M;
+    for (; B < k; ) j(e, { errors: y, currentLocation: f + k, expectedLocation: f, distance: n, ignoreLocation: a }) <= g ? B = k : M = k, k = Math.floor((M - B) / 2 + B);
+    M = k;
+    let $ = Math.max(1, f - k + 1), x = c ? d : Math.min(f + k, d) + h, _ = Array(x + 2);
+    _[x + 1] = (1 << y) - 1;
+    for (let C = x; C >= $; C -= 1) {
+      let b = C - 1, R = i[t.charAt(b)];
+      if (p && (m[b] = +!!R), _[C] = (_[C + 1] << 1 | 1) & R, y && (_[C] |= (L[C + 1] | L[C]) << 1 | 1 | L[C + 1]), _[C] & w && (D = j(e, { errors: y, currentLocation: b, expectedLocation: f, distance: n, ignoreLocation: a }), D <= g)) {
+        if (g = D, A = b, A <= f) break;
+        $ = Math.max(1, 2 * f - A);
+      }
+    }
+    if (j(e, { errors: y + 1, currentLocation: f, expectedLocation: f, distance: n, ignoreLocation: a }) > g) break;
+    L = _;
+  }
+  const z = { isMatch: A >= 0, score: Math.max(1e-3, D) };
+  if (p) {
+    const y = function(B = [], k = l.minMatchCharLength) {
+      let $ = [], x = -1, _ = -1, C = 0;
+      for (let b = B.length; C < b; C += 1) {
+        let R = B[C];
+        R && x === -1 ? x = C : R || x === -1 || (_ = C - 1, _ - x + 1 >= k && $.push([x, _]), x = -1);
+      }
+      return B[C - 1] && C - x >= k && $.push([x, C - 1]), $;
+    }(m, o);
+    y.length ? r && (z.indices = y) : z.isMatch = !1;
+  }
+  return z;
+}
+function fe(t) {
+  let e = {};
+  for (let i = 0, s = t.length; i < s; i += 1) {
+    const n = t.charAt(i);
+    e[n] = (e[n] || 0) | 1 << s - i - 1;
+  }
+  return e;
+}
+const W = String.prototype.normalize ? (t) => t.normalize("NFD").replace(/[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08D3-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C04\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u1885\u1886\u18A9\u1920-\u192B\u1930-\u193B\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ABE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DF9\u1DFB-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F]/g, "") : (t) => t;
+class ue {
+  constructor(e, { location: i = l.location, threshold: s = l.threshold, distance: n = l.distance, includeMatches: u = l.includeMatches, findAllMatches: c = l.findAllMatches, minMatchCharLength: o = l.minMatchCharLength, isCaseSensitive: r = l.isCaseSensitive, ignoreDiacritics: a = l.ignoreDiacritics, ignoreLocation: h = l.ignoreLocation } = {}) {
+    if (this.options = { location: i, threshold: s, distance: n, includeMatches: u, findAllMatches: c, minMatchCharLength: o, isCaseSensitive: r, ignoreDiacritics: a, ignoreLocation: h }, e = r ? e : e.toLowerCase(), e = a ? W(e) : e, this.pattern = e, this.chunks = [], !this.pattern.length) return;
+    const d = (g, A) => {
+      this.chunks.push({ pattern: g, alphabet: fe(g), startIndex: A });
+    }, f = this.pattern.length;
+    if (f > N) {
+      let g = 0;
+      const A = f % N, p = f - A;
+      for (; g < p; ) d(this.pattern.substr(g, N), g), g += N;
+      if (A) {
+        const m = f - N;
+        d(this.pattern.substr(m), m);
+      }
+    } else d(this.pattern, 0);
+  }
+  searchIn(e) {
+    const { isCaseSensitive: i, ignoreDiacritics: s, includeMatches: n } = this.options;
+    if (e = i ? e : e.toLowerCase(), e = s ? W(e) : e, this.pattern === e) {
+      let p = { isMatch: !0, score: 0 };
+      return n && (p.indices = [[0, e.length - 1]]), p;
+    }
+    const { location: u, distance: c, threshold: o, findAllMatches: r, minMatchCharLength: a, ignoreLocation: h } = this.options;
+    let d = [], f = 0, g = !1;
+    this.chunks.forEach(({ pattern: p, alphabet: m, startIndex: F }) => {
+      const { isMatch: L, score: D, indices: M } = ge(e, p, m, { location: u + F, distance: c, threshold: o, findAllMatches: r, minMatchCharLength: a, includeMatches: n, ignoreLocation: h });
+      L && (g = !0), f += D, L && M && (d = [...d, ...M]);
+    });
+    let A = { isMatch: g, score: g ? f / this.chunks.length : 1 };
+    return g && n && (A.indices = d), A;
+  }
+}
+class I {
+  constructor(e) {
+    this.pattern = e;
+  }
+  static isMultiMatch(e) {
+    return X(e, this.multiRegex);
+  }
+  static isSingleMatch(e) {
+    return X(e, this.singleRegex);
+  }
+  search() {
+  }
+}
+function X(t, e) {
+  const i = t.match(e);
+  return i ? i[1] : null;
+}
+class ce extends I {
+  constructor(e, { location: i = l.location, threshold: s = l.threshold, distance: n = l.distance, includeMatches: u = l.includeMatches, findAllMatches: c = l.findAllMatches, minMatchCharLength: o = l.minMatchCharLength, isCaseSensitive: r = l.isCaseSensitive, ignoreDiacritics: a = l.ignoreDiacritics, ignoreLocation: h = l.ignoreLocation } = {}) {
+    super(e), this._bitapSearch = new ue(e, { location: i, threshold: s, distance: n, includeMatches: u, findAllMatches: c, minMatchCharLength: o, isCaseSensitive: r, ignoreDiacritics: a, ignoreLocation: h });
+  }
+  static get type() {
+    return "fuzzy";
+  }
+  static get multiRegex() {
+    return /^"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^(.*)$/;
+  }
+  search(e) {
+    return this._bitapSearch.searchIn(e);
+  }
+}
+class oe extends I {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "include";
+  }
+  static get multiRegex() {
+    return /^'"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^'(.*)$/;
+  }
+  search(e) {
+    let i, s = 0;
+    const n = [], u = this.pattern.length;
+    for (; (i = e.indexOf(this.pattern, s)) > -1; ) s = i + u, n.push([i, s - 1]);
+    const c = !!n.length;
+    return { isMatch: c, score: c ? 0 : 1, indices: n };
+  }
+}
+const J = [class extends I {
+  constructor(t) {
+    super(t);
+  }
+  static get type() {
+    return "exact";
+  }
+  static get multiRegex() {
+    return /^="(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^=(.*)$/;
+  }
+  search(t) {
+    const e = t === this.pattern;
+    return { isMatch: e, score: e ? 0 : 1, indices: [0, this.pattern.length - 1] };
+  }
+}, oe, class extends I {
+  constructor(t) {
+    super(t);
+  }
+  static get type() {
+    return "prefix-exact";
+  }
+  static get multiRegex() {
+    return /^\^"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^\^(.*)$/;
+  }
+  search(t) {
+    const e = t.startsWith(this.pattern);
+    return { isMatch: e, score: e ? 0 : 1, indices: [0, this.pattern.length - 1] };
+  }
+}, class extends I {
+  constructor(t) {
+    super(t);
+  }
+  static get type() {
+    return "inverse-prefix-exact";
+  }
+  static get multiRegex() {
+    return /^!\^"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^!\^(.*)$/;
+  }
+  search(t) {
+    const e = !t.startsWith(this.pattern);
+    return { isMatch: e, score: e ? 0 : 1, indices: [0, t.length - 1] };
+  }
+}, class extends I {
+  constructor(t) {
+    super(t);
+  }
+  static get type() {
+    return "inverse-suffix-exact";
+  }
+  static get multiRegex() {
+    return /^!"(.*)"\$$/;
+  }
+  static get singleRegex() {
+    return /^!(.*)\$$/;
+  }
+  search(t) {
+    const e = !t.endsWith(this.pattern);
+    return { isMatch: e, score: e ? 0 : 1, indices: [0, t.length - 1] };
+  }
+}, class extends I {
+  constructor(t) {
+    super(t);
+  }
+  static get type() {
+    return "suffix-exact";
+  }
+  static get multiRegex() {
+    return /^"(.*)"\$$/;
+  }
+  static get singleRegex() {
+    return /^(.*)\$$/;
+  }
+  search(t) {
+    const e = t.endsWith(this.pattern);
+    return { isMatch: e, score: e ? 0 : 1, indices: [t.length - this.pattern.length, t.length - 1] };
+  }
+}, class extends I {
+  constructor(t) {
+    super(t);
+  }
+  static get type() {
+    return "inverse-exact";
+  }
+  static get multiRegex() {
+    return /^!"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^!(.*)$/;
+  }
+  search(t) {
+    const e = t.indexOf(this.pattern) === -1;
+    return { isMatch: e, score: e ? 0 : 1, indices: [0, t.length - 1] };
+  }
+}, ce], Y = J.length, Ae = / +(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/, pe = /* @__PURE__ */ new Set([ce.type, oe.type]), V = [];
+function Q(t, e) {
+  for (let i = 0, s = V.length; i < s; i += 1) {
+    let n = V[i];
+    if (n.condition(t, e)) return new n(t, e);
+  }
+  return new ue(t, e);
+}
+const G = "$and", Z = "$path", P = (t) => !(!t[G] && !t.$or), ee = (t) => ({ [G]: Object.keys(t).map((e) => ({ [e]: t[e] })) });
+function he(t, e, { auto: i = !0 } = {}) {
+  const s = (n) => {
+    let u = Object.keys(n);
+    const c = ((r) => !!r[Z])(n);
+    if (!c && u.length > 1 && !P(n)) return s(ee(n));
+    if (((r) => !S(r) && ie(r) && !P(r))(n)) {
+      const r = c ? n[Z] : u[0], a = c ? n.$val : n[r];
+      if (!v(a)) throw new Error(((d) => `Invalid value for key ${d}`)(r));
+      const h = { keyId: q(r), pattern: a };
+      return i && (h.searcher = Q(a, e)), h;
+    }
+    let o = { children: [], operator: u[0] };
+    return u.forEach((r) => {
+      const a = n[r];
+      S(a) && a.forEach((h) => {
+        o.children.push(s(h));
+      });
+    }), o;
+  };
+  return P(t) || (t = ee(t)), s(t);
+}
+function Ce(t, e) {
+  const i = t.matches;
+  e.matches = [], E(i) && i.forEach((s) => {
+    if (!E(s.indices) || !s.indices.length) return;
+    const { indices: n, value: u } = s;
+    let c = { indices: n, value: u };
+    s.key && (c.key = s.key.src), s.idx > -1 && (c.refIndex = s.idx), e.matches.push(c);
+  });
+}
+function me(t, e) {
+  e.score = t.score;
+}
+class O {
+  constructor(e, i = {}, s) {
+    this.options = { ...l, ...i }, this.options.useExtendedSearch, this._keyStore = new le(this.options.keys), this.setCollection(e, s);
+  }
+  setCollection(e, i) {
+    if (this._docs = e, i && !(i instanceof U)) throw new Error("Incorrect 'index' type");
+    this._myIndex = i || re(this.options.keys, this._docs, { getFn: this.options.getFn, fieldNormWeight: this.options.fieldNormWeight });
+  }
+  add(e) {
+    E(e) && (this._docs.push(e), this._myIndex.add(e));
+  }
+  remove(e = () => !1) {
+    const i = [];
+    for (let s = 0, n = this._docs.length; s < n; s += 1) {
+      const u = this._docs[s];
+      e(u, s) && (this.removeAt(s), s -= 1, n -= 1, i.push(u));
+    }
+    return i;
+  }
+  removeAt(e) {
+    this._docs.splice(e, 1), this._myIndex.removeAt(e);
+  }
+  getIndex() {
+    return this._myIndex;
+  }
+  search(e, { limit: i = -1 } = {}) {
+    const { includeMatches: s, includeScore: n, shouldSort: u, sortFn: c, ignoreFieldNorm: o } = this.options;
+    let r = v(e) ? v(this._docs[0]) ? this._searchStringList(e) : this._searchObjectList(e) : this._searchLogical(e);
+    return function(a, { ignoreFieldNorm: h = l.ignoreFieldNorm }) {
+      a.forEach((d) => {
+        let f = 1;
+        d.matches.forEach(({ key: g, norm: A, score: p }) => {
+          const m = g ? g.weight : null;
+          f *= Math.pow(p === 0 && m ? Number.EPSILON : p, (m || 1) * (h ? 1 : A));
+        }), d.score = f;
+      });
+    }(r, { ignoreFieldNorm: o }), u && r.sort(c), te(i) && i > -1 && (r = r.slice(0, i)), function(a, h, { includeMatches: d = l.includeMatches, includeScore: f = l.includeScore } = {}) {
+      const g = [];
+      return d && g.push(Ce), f && g.push(me), a.map((A) => {
+        const { idx: p } = A, m = { item: h[p], refIndex: p };
+        return g.length && g.forEach((F) => {
+          F(A, m);
+        }), m;
+      });
+    }(r, this._docs, { includeMatches: s, includeScore: n });
+  }
+  _searchStringList(e) {
+    const i = Q(e, this.options), { records: s } = this._myIndex, n = [];
+    return s.forEach(({ v: u, i: c, n: o }) => {
+      if (!E(u)) return;
+      const { isMatch: r, score: a, indices: h } = i.searchIn(u);
+      r && n.push({ item: u, idx: c, matches: [{ score: a, value: u, norm: o, indices: h }] });
+    }), n;
+  }
+  _searchLogical(e) {
+    const i = he(e, this.options), s = (o, r, a) => {
+      if (!o.children) {
+        const { keyId: d, searcher: f } = o, g = this._findMatches({ key: this._keyStore.get(d), value: this._myIndex.getValueForItemAtKeyId(r, d), searcher: f });
+        return g && g.length ? [{ idx: a, item: r, matches: g }] : [];
+      }
+      const h = [];
+      for (let d = 0, f = o.children.length; d < f; d += 1) {
+        const g = o.children[d], A = s(g, r, a);
+        if (A.length) h.push(...A);
+        else if (o.operator === G) return [];
+      }
+      return h;
+    }, n = this._myIndex.records, u = {}, c = [];
+    return n.forEach(({ $: o, i: r }) => {
+      if (E(o)) {
+        let a = s(i, o, r);
+        a.length && (u[r] || (u[r] = { idx: r, item: o, matches: [] }, c.push(u[r])), a.forEach(({ matches: h }) => {
+          u[r].matches.push(...h);
+        }));
+      }
+    }), c;
+  }
+  _searchObjectList(e) {
+    const i = Q(e, this.options), { keys: s, records: n } = this._myIndex, u = [];
+    return n.forEach(({ $: c, i: o }) => {
+      if (!E(c)) return;
+      let r = [];
+      s.forEach((a, h) => {
+        r.push(...this._findMatches({ key: a, value: c[h], searcher: i }));
+      }), r.length && u.push({ idx: o, item: c, matches: r });
+    }), u;
+  }
+  _findMatches({ key: e, value: i, searcher: s }) {
+    if (!E(i)) return [];
+    let n = [];
+    if (S(i)) i.forEach(({ v: u, i: c, n: o }) => {
+      if (!E(u)) return;
+      const { isMatch: r, score: a, indices: h } = s.searchIn(u);
+      r && n.push({ score: a, key: e, value: u, idx: c, norm: o, indices: h });
+    });
+    else {
+      const { v: u, n: c } = i, { isMatch: o, score: r, indices: a } = s.searchIn(u);
+      o && n.push({ score: r, key: e, value: u, norm: c, indices: a });
+    }
+    return n;
+  }
+}
+O.version = "7.1.0", O.createIndex = re, O.parseIndex = function(t, { getFn: e = l.getFn, fieldNormWeight: i = l.fieldNormWeight } = {}) {
+  const { keys: s, records: n } = t, u = new U({ getFn: e, fieldNormWeight: i });
+  return u.setKeys(s), u.setIndexRecords(n), u;
+}, O.config = l, O.parseQuery = he, function(...t) {
+  V.push(...t);
+}(class {
+  constructor(t, { isCaseSensitive: e = l.isCaseSensitive, ignoreDiacritics: i = l.ignoreDiacritics, includeMatches: s = l.includeMatches, minMatchCharLength: n = l.minMatchCharLength, ignoreLocation: u = l.ignoreLocation, findAllMatches: c = l.findAllMatches, location: o = l.location, threshold: r = l.threshold, distance: a = l.distance } = {}) {
+    this.query = null, this.options = { isCaseSensitive: e, ignoreDiacritics: i, includeMatches: s, minMatchCharLength: n, findAllMatches: c, ignoreLocation: u, location: o, threshold: r, distance: a }, t = e ? t : t.toLowerCase(), t = i ? W(t) : t, this.pattern = t, this.query = function(h, d = {}) {
+      return h.split("|").map((f) => {
+        let g = f.trim().split(Ae).filter((p) => p && !!p.trim()), A = [];
+        for (let p = 0, m = g.length; p < m; p += 1) {
+          const F = g[p];
+          let L = !1, D = -1;
+          for (; !L && ++D < Y; ) {
+            const M = J[D];
+            let w = M.isMultiMatch(F);
+            w && (A.push(new M(w, d)), L = !0);
+          }
+          if (!L) for (D = -1; ++D < Y; ) {
+            const M = J[D];
+            let w = M.isSingleMatch(F);
+            if (w) {
+              A.push(new M(w, d));
+              break;
+            }
+          }
+        }
+        return A;
+      });
+    }(this.pattern, this.options);
+  }
+  static condition(t, e) {
+    return e.useExtendedSearch;
+  }
+  searchIn(t) {
+    const e = this.query;
+    if (!e) return { isMatch: !1, score: 1 };
+    const { includeMatches: i, isCaseSensitive: s, ignoreDiacritics: n } = this.options;
+    t = s ? t : t.toLowerCase(), t = n ? W(t) : t;
+    let u = 0, c = [], o = 0;
+    for (let r = 0, a = e.length; r < a; r += 1) {
+      const h = e[r];
+      c.length = 0, u = 0;
+      for (let d = 0, f = h.length; d < f; d += 1) {
+        const g = h[d], { isMatch: A, indices: p, score: m } = g.search(t);
+        if (!A) {
+          o = 0, u = 0, c.length = 0;
+          break;
+        }
+        if (u += 1, o += m, i) {
+          const F = g.constructor.type;
+          pe.has(F) ? c = [...c, ...p] : c.push(p);
+        }
+      }
+      if (u) {
+        let d = { isMatch: !0, score: o / u };
+        return i && (d.indices = c), d;
+      }
+    }
+    return { isMatch: !1, score: 1 };
+  }
+});
+export {
+  O as default
+};

package/cdn/assets/DDW1WJ2IM_9ZUfKm.js

@@ -0,0 +1,36 @@
+import { g as c } from "./phYz0vGgqIEQ2hco.js";
+/**
+ * @license @sheetxl/studio-vanilla - SheetXL Studio - Vanilla entry point for integrating SheetXL UI. - v0.4.12
+ *
+ * (C) 2025-present SheetXL Inc. & Michael T. Ford
+ * License: The license can be found at https://www.sheetxl.com/license.
+ */
+function g(o, i) {
+  for (var n = 0; n < i.length; n++) {
+    const t = i[n];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const e in t) if (e !== "default" && !(e in o)) {
+        const r = Object.getOwnPropertyDescriptor(t, e);
+        r && Object.defineProperty(o, e, r.get ? r : { enumerable: !0, get: () => t[e] });
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(o, Symbol.toStringTag, { value: "Module" }));
+}
+var l, y, p = { exports: {} }, f = {}, u = (y || (y = 1, p.exports = function() {
+  if (l) return f;
+  l = 1;
+  var o = Symbol.for("react.transitional.element"), i = Symbol.for("react.fragment");
+  function n(t, e, r) {
+    var a = null;
+    if (r !== void 0 && (a = "" + r), e.key !== void 0 && (a = "" + e.key), "key" in e) for (var s in r = {}, e) s !== "key" && (r[s] = e[s]);
+    else r = e;
+    return e = r.ref, { $$typeof: o, type: t, key: a, ref: e !== void 0 ? e : null, props: r };
+  }
+  return f.Fragment = i, f.jsx = n, f.jsxs = n, f;
+}()), p.exports);
+const m = g({ __proto__: null, default: c(u) }, [u]);
+export {
+  u as a,
+  m as j
+};