@synnaxlabs/pluto 0.32.0 → 0.33.0

package/dist/external-CxatFj2t.js

@@ -0,0 +1,1191 @@
+import { a1 as fe, au as Pe, ak as ke, ab as ve, av as Te, a5 as Ce, l as Fe, aa as Ne, aw as $e, ax as je, a6 as De, ay as Ke, az as Ye, aA as We, aB as ze, aC as He, ac as Be, aD as Ve, aE as Ue, a0 as Ge, aF as Je, aG as Qe, aH as Xe } from "./Toggle-B96EPQ2x.js";
+import { j as Ze } from "./jsx-runtime-B6kdoens.js";
+import { useCallback as qe } from "react";
+import { w as et, k as tt } from "./aggregator-B36SA-20.js";
+import "./css-C8qHWSpT.js";
+import "./Pack-CxtceW7N.js";
+import { L as st } from "./List-KmtaD0qw.js";
+const de = Symbol(), q = Symbol(), v = "a", N = "w";
+let rt = (t, e) => new Proxy(t, e);
+const H = Object.getPrototypeOf, ne = /* @__PURE__ */ new WeakMap(), ee = (t) => t && (ne.has(t) ? ne.get(t) : H(t) === Object.prototype || H(t) === Array.prototype), ie = (t) => typeof t == "object" && t !== null, ce = /* @__PURE__ */ new WeakMap(), ge = (t) => t[q] || t, pe = (t, e, s) => {
+  if (!ee(t)) return t;
+  const r = ge(t), i = ((c) => Object.isFrozen(c) || Object.values(Object.getOwnPropertyDescriptors(c)).some((o) => !o.writable))(r);
+  let n = s && s.get(r);
+  return n && n[1].f === i || (n = ((c, o) => {
+    const a = { f: o };
+    let h = !1;
+    const l = (f, g) => {
+      if (!h) {
+        let p = a[v].get(c);
+        if (p || (p = {}, a[v].set(c, p)), f === N) p[N] = !0;
+        else {
+          let m = p[f];
+          m || (m = /* @__PURE__ */ new Set(), p[f] = m), m.add(g);
+        }
+      }
+    }, u = { get: (f, g) => g === q ? c : (l("k", g), pe(Reflect.get(f, g), a[v], a.c)), has: (f, g) => g === de ? (h = !0, a[v].delete(c), !0) : (l("h", g), Reflect.has(f, g)), getOwnPropertyDescriptor: (f, g) => (l("o", g), Reflect.getOwnPropertyDescriptor(f, g)), ownKeys: (f) => (l(N), Reflect.ownKeys(f)) };
+    return o && (u.set = u.deleteProperty = () => !1), [u, a];
+  })(r, i), n[1].p = rt(i ? ((c) => {
+    let o = ce.get(c);
+    if (!o) {
+      if (Array.isArray(c)) o = Array.from(c);
+      else {
+        const a = Object.getOwnPropertyDescriptors(c);
+        Object.values(a).forEach((h) => {
+          h.configurable = !0;
+        }), o = Object.create(H(c), a);
+      }
+      ce.set(c, o);
+    }
+    return o;
+  })(r) : r, n[0]), s && s.set(r, n)), n[1][v] = e, n[1].c = s, n[1].p;
+}, me = (t, e, s, r) => {
+  if (Object.is(t, e)) return !1;
+  if (!ie(t) || !ie(e)) return !0;
+  const i = s.get(ge(t));
+  if (!i) return !0;
+  if (r) {
+    const c = r.get(t);
+    if (c && c.n === e) return c.g;
+    r.set(t, { n: e, g: !1 });
+  }
+  let n = null;
+  try {
+    for (const c of i.h || []) if (n = Reflect.has(t, c) !== Reflect.has(e, c), n) return n;
+    if (i[N] === !0) {
+      if (n = ((c, o) => {
+        const a = Reflect.ownKeys(c), h = Reflect.ownKeys(o);
+        return a.length !== h.length || a.some((l, u) => l !== h[u]);
+      })(t, e), n) return n;
+    } else for (const c of i.o || []) if (n = !!Reflect.getOwnPropertyDescriptor(t, c) != !!Reflect.getOwnPropertyDescriptor(e, c), n) return n;
+    for (const c of i.k || []) if (n = me(t[c], e[c], s, r), n) return n;
+    return n === null && (n = !0), n;
+  } finally {
+    r && r.set(t, { n: e, g: n });
+  }
+}, nt = (t) => !!ee(t) && de in t, ye = (t) => ee(t) && t[q] || null, it = "h", ct = "w", ot = "o", at = "k", B = (t) => typeof t == "object" && t !== null, Me = (t, e) => {
+  if (!B(t)) return t;
+  const s = ye(t);
+  return s !== null ? (nt(t), s) : (e.has(t) || (e.add(t), Object.entries(t).forEach(([r, i]) => {
+    const n = Me(i, e);
+    Object.is(n, i) || (t[r] = n);
+  })), t);
+}, V = (t, e, s) => {
+  var r, i, n;
+  if (!B(t) || !B(e)) return;
+  const c = s.get(ye(e) || e);
+  c && ((r = c[it]) == null || r.forEach((o) => {
+    Reflect.has(t, o);
+  }), c[ct] === !0 && Reflect.ownKeys(t), (i = c[ot]) == null || i.forEach((o) => {
+    Reflect.getOwnPropertyDescriptor(t, o);
+  }), (n = c[at]) == null || n.forEach((o) => {
+    V(t[o], e[o], s);
+  }));
+}, K = "o", Y = "r", W = "a";
+function lt(t, e) {
+  var s;
+  let r = 0;
+  const i = (s = e == null ? void 0 : e.size) != null ? s : 1, n = [], c = e != null && e.noWeakMap ? null : /* @__PURE__ */ new WeakMap();
+  return (a) => {
+    const h = c == null ? void 0 : c.get(a);
+    if (h)
+      return h[Y];
+    for (let p = 0; p < i; p += 1) {
+      const m = n[(r + p) % i];
+      if (!m) break;
+      if (!me(m[K], a, m[W], /* @__PURE__ */ new WeakMap()))
+        return V(a, m[K], m[W]), c == null || c.set(a, m), m[Y];
+    }
+    const l = /* @__PURE__ */ new WeakMap(), u = pe(a, l), f = Me(t(u), /* @__PURE__ */ new Set());
+    V(a, a, l);
+    const g = {
+      [K]: a,
+      [Y]: f,
+      [W]: l
+    };
+    return r = (r - 1 + i) % i, n[r] = g, c == null || c.set(a, g), f;
+  };
+}
+const ht = (t, e) => et.RUNTIME === "browser" ? lt(t, e) : t;
+function x(t) {
+  return Array.isArray ? Array.isArray(t) : Se(t) === "[object Array]";
+}
+const ut = 1 / 0;
+function ft(t) {
+  if (typeof t == "string")
+    return t;
+  let e = t + "";
+  return e == "0" && 1 / t == -ut ? "-0" : e;
+}
+function dt(t) {
+  return t == null ? "" : ft(t);
+}
+function _(t) {
+  return typeof t == "string";
+}
+function Ee(t) {
+  return typeof t == "number";
+}
+function gt(t) {
+  return t === !0 || t === !1 || pt(t) && Se(t) == "[object Boolean]";
+}
+function _e(t) {
+  return typeof t == "object";
+}
+function pt(t) {
+  return _e(t) && t !== null;
+}
+function y(t) {
+  return t != null;
+}
+function z(t) {
+  return !t.trim().length;
+}
+function Se(t) {
+  return t == null ? t === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(t);
+}
+const mt = "Incorrect 'index' type", yt = (t) => `Invalid value for key ${t}`, Mt = (t) => `Pattern length exceeds max of ${t}.`, Et = (t) => `Missing ${t} property in key`, _t = (t) => `Property 'weight' in key '${t}' must be a positive integer`, oe = Object.prototype.hasOwnProperty;
+class St {
+  constructor(e) {
+    this._keys = [], this._keyMap = {};
+    let s = 0;
+    e.forEach((r) => {
+      let i = xe(r);
+      this._keys.push(i), this._keyMap[i.id] = i, s += i.weight;
+    }), this._keys.forEach((r) => {
+      r.weight /= s;
+    });
+  }
+  get(e) {
+    return this._keyMap[e];
+  }
+  keys() {
+    return this._keys;
+  }
+  toJSON() {
+    return JSON.stringify(this._keys);
+  }
+}
+function xe(t) {
+  let e = null, s = null, r = null, i = 1, n = null;
+  if (_(t) || x(t))
+    r = t, e = ae(t), s = U(t);
+  else {
+    if (!oe.call(t, "name"))
+      throw new Error(Et("name"));
+    const c = t.name;
+    if (r = c, oe.call(t, "weight") && (i = t.weight, i <= 0))
+      throw new Error(_t(c));
+    e = ae(c), s = U(c), n = t.getFn;
+  }
+  return { path: e, id: s, weight: i, src: r, getFn: n };
+}
+function ae(t) {
+  return x(t) ? t : t.split(".");
+}
+function U(t) {
+  return x(t) ? t.join(".") : t;
+}
+function xt(t, e) {
+  let s = [], r = !1;
+  const i = (n, c, o) => {
+    if (y(n))
+      if (!c[o])
+        s.push(n);
+      else {
+        let a = c[o];
+        const h = n[a];
+        if (!y(h))
+          return;
+        if (o === c.length - 1 && (_(h) || Ee(h) || gt(h)))
+          s.push(dt(h));
+        else if (x(h)) {
+          r = !0;
+          for (let l = 0, u = h.length; l < u; l += 1)
+            i(h[l], c, o + 1);
+        } else c.length && i(h, c, o + 1);
+      }
+  };
+  return i(t, _(e) ? e.split(".") : e, 0), r ? s : s[0];
+}
+const Rt = {
+  // Whether the matches should be included in the result set. When `true`, each record in the result
+  // set will include the indices of the matched characters.
+  // These can consequently be used for highlighting purposes.
+  includeMatches: !1,
+  // When `true`, the matching function will continue to the end of a search pattern even if
+  // a perfect match has already been located in the string.
+  findAllMatches: !1,
+  // Minimum number of characters that must be matched before a result is considered a match
+  minMatchCharLength: 1
+}, wt = {
+  // When `true`, the algorithm continues searching to the end of the input even if a perfect
+  // match is found before the end of the same input.
+  isCaseSensitive: !1,
+  // When true, the matching function will continue to the end of a search pattern even if
+  includeScore: !1,
+  // List of properties that will be searched. This also supports nested properties.
+  keys: [],
+  // Whether to sort the result list, by score
+  shouldSort: !0,
+  // Default sort function: sort by ascending score, ascending index
+  sortFn: (t, e) => t.score === e.score ? t.idx < e.idx ? -1 : 1 : t.score < e.score ? -1 : 1
+}, Ot = {
+  // Approximately where in the text is the pattern expected to be found?
+  location: 0,
+  // At what point does the match algorithm give up. A threshold of '0.0' requires a perfect match
+  // (of both letters and location), a threshold of '1.0' would match anything.
+  threshold: 0.6,
+  // Determines how close the match must be to the fuzzy location (specified above).
+  // An exact letter match which is 'distance' characters away from the fuzzy location
+  // would score as a complete mismatch. A distance of '0' requires the match be at
+  // the exact location specified, a threshold of '1000' would require a perfect match
+  // to be within 800 characters of the fuzzy location to be found using a 0.8 threshold.
+  distance: 100
+}, At = {
+  // When `true`, it enables the use of unix-like search commands
+  useExtendedSearch: !1,
+  // The get function to use when fetching an object's properties.
+  // The default will search nested paths *ie foo.bar.baz*
+  getFn: xt,
+  // When `true`, search will ignore `location` and `distance`, so it won't matter
+  // where in the string the pattern appears.
+  // More info: https://fusejs.io/concepts/scoring-theory.html#fuzziness-score
+  ignoreLocation: !1,
+  // When `true`, the calculation for the relevance score (used for sorting) will
+  // ignore the field-length norm.
+  // More info: https://fusejs.io/concepts/scoring-theory.html#field-length-norm
+  ignoreFieldNorm: !1,
+  // The weight to determine how much field length norm effects scoring.
+  fieldNormWeight: 1
+};
+var d = {
+  ...wt,
+  ...Rt,
+  ...Ot,
+  ...At
+};
+const It = /[^ ]+/g;
+function bt(t = 1, e = 3) {
+  const s = /* @__PURE__ */ new Map(), r = Math.pow(10, e);
+  return {
+    get(i) {
+      const n = i.match(It).length;
+      if (s.has(n))
+        return s.get(n);
+      const c = 1 / Math.pow(n, 0.5 * t), o = parseFloat(Math.round(c * r) / r);
+      return s.set(n, o), o;
+    },
+    clear() {
+      s.clear();
+    }
+  };
+}
+class te {
+  constructor({
+    getFn: e = d.getFn,
+    fieldNormWeight: s = d.fieldNormWeight
+  } = {}) {
+    this.norm = bt(s, 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((s, r) => {
+      this._keysMap[s.id] = r;
+    });
+  }
+  create() {
+    this.isCreated || !this.docs.length || (this.isCreated = !0, _(this.docs[0]) ? this.docs.forEach((e, s) => {
+      this._addString(e, s);
+    }) : this.docs.forEach((e, s) => {
+      this._addObject(e, s);
+    }), this.norm.clear());
+  }
+  // Adds a doc to the end of the index
+  add(e) {
+    const s = this.size();
+    _(e) ? this._addString(e, s) : this._addObject(e, s);
+  }
+  // Removes the doc at the specified index of the index
+  removeAt(e) {
+    this.records.splice(e, 1);
+    for (let s = e, r = this.size(); s < r; s += 1)
+      this.records[s].i -= 1;
+  }
+  getValueForItemAtKeyId(e, s) {
+    return e[this._keysMap[s]];
+  }
+  size() {
+    return this.records.length;
+  }
+  _addString(e, s) {
+    if (!y(e) || z(e))
+      return;
+    let r = {
+      v: e,
+      i: s,
+      n: this.norm.get(e)
+    };
+    this.records.push(r);
+  }
+  _addObject(e, s) {
+    let r = { i: s, $: {} };
+    this.keys.forEach((i, n) => {
+      let c = i.getFn ? i.getFn(e) : this.getFn(e, i.path);
+      if (y(c)) {
+        if (x(c)) {
+          let o = [];
+          const a = [{ nestedArrIndex: -1, value: c }];
+          for (; a.length; ) {
+            const { nestedArrIndex: h, value: l } = a.pop();
+            if (y(l))
+              if (_(l) && !z(l)) {
+                let u = {
+                  v: l,
+                  i: h,
+                  n: this.norm.get(l)
+                };
+                o.push(u);
+              } else x(l) && l.forEach((u, f) => {
+                a.push({
+                  nestedArrIndex: f,
+                  value: u
+                });
+              });
+          }
+          r.$[n] = o;
+        } else if (_(c) && !z(c)) {
+          let o = {
+            v: c,
+            n: this.norm.get(c)
+          };
+          r.$[n] = o;
+        }
+      }
+    }), this.records.push(r);
+  }
+  toJSON() {
+    return {
+      keys: this.keys,
+      records: this.records
+    };
+  }
+}
+function Re(t, e, { getFn: s = d.getFn, fieldNormWeight: r = d.fieldNormWeight } = {}) {
+  const i = new te({ getFn: s, fieldNormWeight: r });
+  return i.setKeys(t.map(xe)), i.setSources(e), i.create(), i;
+}
+function Lt(t, { getFn: e = d.getFn, fieldNormWeight: s = d.fieldNormWeight } = {}) {
+  const { keys: r, records: i } = t, n = new te({ getFn: e, fieldNormWeight: s });
+  return n.setKeys(r), n.setIndexRecords(i), n;
+}
+function F(t, {
+  errors: e = 0,
+  currentLocation: s = 0,
+  expectedLocation: r = 0,
+  distance: i = d.distance,
+  ignoreLocation: n = d.ignoreLocation
+} = {}) {
+  const c = e / t.length;
+  if (n)
+    return c;
+  const o = Math.abs(r - s);
+  return i ? c + o / i : o ? 1 : c;
+}
+function Pt(t = [], e = d.minMatchCharLength) {
+  let s = [], r = -1, i = -1, n = 0;
+  for (let c = t.length; n < c; n += 1) {
+    let o = t[n];
+    o && r === -1 ? r = n : !o && r !== -1 && (i = n - 1, i - r + 1 >= e && s.push([r, i]), r = -1);
+  }
+  return t[n - 1] && n - r >= e && s.push([r, n - 1]), s;
+}
+const b = 32;
+function kt(t, e, s, {
+  location: r = d.location,
+  distance: i = d.distance,
+  threshold: n = d.threshold,
+  findAllMatches: c = d.findAllMatches,
+  minMatchCharLength: o = d.minMatchCharLength,
+  includeMatches: a = d.includeMatches,
+  ignoreLocation: h = d.ignoreLocation
+} = {}) {
+  if (e.length > b)
+    throw new Error(Mt(b));
+  const l = e.length, u = t.length, f = Math.max(0, Math.min(r, u));
+  let g = n, p = f;
+  const m = o > 1 || a, A = m ? Array(u) : [];
+  let S;
+  for (; (S = t.indexOf(e, p)) > -1; ) {
+    let M = F(e, {
+      currentLocation: S,
+      expectedLocation: f,
+      distance: i,
+      ignoreLocation: h
+    });
+    if (g = Math.min(M, g), p = S + l, m) {
+      let R = 0;
+      for (; R < l; )
+        A[S + R] = 1, R += 1;
+    }
+  }
+  p = -1;
+  let L = [], I = 1, T = l + u;
+  const Le = 1 << l - 1;
+  for (let M = 0; M < l; M += 1) {
+    let R = 0, w = T;
+    for (; R < w; )
+      F(e, {
+        errors: M,
+        currentLocation: f + w,
+        expectedLocation: f,
+        distance: i,
+        ignoreLocation: h
+      }) <= g ? R = w : T = w, w = Math.floor((T - R) / 2 + R);
+    T = w;
+    let se = Math.max(1, f - w + 1), D = c ? u : Math.min(f + w, u) + l, P = Array(D + 2);
+    P[D + 1] = (1 << M) - 1;
+    for (let E = D; E >= se; E -= 1) {
+      let C = E - 1, re = s[t.charAt(C)];
+      if (m && (A[C] = +!!re), P[E] = (P[E + 1] << 1 | 1) & re, M && (P[E] |= (L[E + 1] | L[E]) << 1 | 1 | L[E + 1]), P[E] & Le && (I = F(e, {
+        errors: M,
+        currentLocation: C,
+        expectedLocation: f,
+        distance: i,
+        ignoreLocation: h
+      }), I <= g)) {
+        if (g = I, p = C, p <= f)
+          break;
+        se = Math.max(1, 2 * f - p);
+      }
+    }
+    if (F(e, {
+      errors: M + 1,
+      currentLocation: f,
+      expectedLocation: f,
+      distance: i,
+      ignoreLocation: h
+    }) > g)
+      break;
+    L = P;
+  }
+  const j = {
+    isMatch: p >= 0,
+    // Count exact matches (those with a score of 0) to be "almost" exact
+    score: Math.max(1e-3, I)
+  };
+  if (m) {
+    const M = Pt(A, o);
+    M.length ? a && (j.indices = M) : j.isMatch = !1;
+  }
+  return j;
+}
+function vt(t) {
+  let e = {};
+  for (let s = 0, r = t.length; s < r; s += 1) {
+    const i = t.charAt(s);
+    e[i] = (e[i] || 0) | 1 << r - s - 1;
+  }
+  return e;
+}
+class we {
+  constructor(e, {
+    location: s = d.location,
+    threshold: r = d.threshold,
+    distance: i = d.distance,
+    includeMatches: n = d.includeMatches,
+    findAllMatches: c = d.findAllMatches,
+    minMatchCharLength: o = d.minMatchCharLength,
+    isCaseSensitive: a = d.isCaseSensitive,
+    ignoreLocation: h = d.ignoreLocation
+  } = {}) {
+    if (this.options = {
+      location: s,
+      threshold: r,
+      distance: i,
+      includeMatches: n,
+      findAllMatches: c,
+      minMatchCharLength: o,
+      isCaseSensitive: a,
+      ignoreLocation: h
+    }, this.pattern = a ? e : e.toLowerCase(), this.chunks = [], !this.pattern.length)
+      return;
+    const l = (f, g) => {
+      this.chunks.push({
+        pattern: f,
+        alphabet: vt(f),
+        startIndex: g
+      });
+    }, u = this.pattern.length;
+    if (u > b) {
+      let f = 0;
+      const g = u % b, p = u - g;
+      for (; f < p; )
+        l(this.pattern.substr(f, b), f), f += b;
+      if (g) {
+        const m = u - b;
+        l(this.pattern.substr(m), m);
+      }
+    } else
+      l(this.pattern, 0);
+  }
+  searchIn(e) {
+    const { isCaseSensitive: s, includeMatches: r } = this.options;
+    if (s || (e = e.toLowerCase()), this.pattern === e) {
+      let p = {
+        isMatch: !0,
+        score: 0
+      };
+      return r && (p.indices = [[0, e.length - 1]]), p;
+    }
+    const {
+      location: i,
+      distance: n,
+      threshold: c,
+      findAllMatches: o,
+      minMatchCharLength: a,
+      ignoreLocation: h
+    } = this.options;
+    let l = [], u = 0, f = !1;
+    this.chunks.forEach(({ pattern: p, alphabet: m, startIndex: A }) => {
+      const { isMatch: S, score: L, indices: I } = kt(e, p, m, {
+        location: i + A,
+        distance: n,
+        threshold: c,
+        findAllMatches: o,
+        minMatchCharLength: a,
+        includeMatches: r,
+        ignoreLocation: h
+      });
+      S && (f = !0), u += L, S && I && (l = [...l, ...I]);
+    });
+    let g = {
+      isMatch: f,
+      score: f ? u / this.chunks.length : 1
+    };
+    return f && r && (g.indices = l), g;
+  }
+}
+class O {
+  constructor(e) {
+    this.pattern = e;
+  }
+  static isMultiMatch(e) {
+    return le(e, this.multiRegex);
+  }
+  static isSingleMatch(e) {
+    return le(e, this.singleRegex);
+  }
+  search() {
+  }
+}
+function le(t, e) {
+  const s = t.match(e);
+  return s ? s[1] : null;
+}
+class Tt extends O {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "exact";
+  }
+  static get multiRegex() {
+    return /^="(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^=(.*)$/;
+  }
+  search(e) {
+    const s = e === this.pattern;
+    return {
+      isMatch: s,
+      score: s ? 0 : 1,
+      indices: [0, this.pattern.length - 1]
+    };
+  }
+}
+class Ct extends O {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "inverse-exact";
+  }
+  static get multiRegex() {
+    return /^!"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^!(.*)$/;
+  }
+  search(e) {
+    const r = e.indexOf(this.pattern) === -1;
+    return {
+      isMatch: r,
+      score: r ? 0 : 1,
+      indices: [0, e.length - 1]
+    };
+  }
+}
+class Ft extends O {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "prefix-exact";
+  }
+  static get multiRegex() {
+    return /^\^"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^\^(.*)$/;
+  }
+  search(e) {
+    const s = e.startsWith(this.pattern);
+    return {
+      isMatch: s,
+      score: s ? 0 : 1,
+      indices: [0, this.pattern.length - 1]
+    };
+  }
+}
+class Nt extends O {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "inverse-prefix-exact";
+  }
+  static get multiRegex() {
+    return /^!\^"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^!\^(.*)$/;
+  }
+  search(e) {
+    const s = !e.startsWith(this.pattern);
+    return {
+      isMatch: s,
+      score: s ? 0 : 1,
+      indices: [0, e.length - 1]
+    };
+  }
+}
+class $t extends O {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "suffix-exact";
+  }
+  static get multiRegex() {
+    return /^"(.*)"\$$/;
+  }
+  static get singleRegex() {
+    return /^(.*)\$$/;
+  }
+  search(e) {
+    const s = e.endsWith(this.pattern);
+    return {
+      isMatch: s,
+      score: s ? 0 : 1,
+      indices: [e.length - this.pattern.length, e.length - 1]
+    };
+  }
+}
+class jt extends O {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "inverse-suffix-exact";
+  }
+  static get multiRegex() {
+    return /^!"(.*)"\$$/;
+  }
+  static get singleRegex() {
+    return /^!(.*)\$$/;
+  }
+  search(e) {
+    const s = !e.endsWith(this.pattern);
+    return {
+      isMatch: s,
+      score: s ? 0 : 1,
+      indices: [0, e.length - 1]
+    };
+  }
+}
+class Oe extends O {
+  constructor(e, {
+    location: s = d.location,
+    threshold: r = d.threshold,
+    distance: i = d.distance,
+    includeMatches: n = d.includeMatches,
+    findAllMatches: c = d.findAllMatches,
+    minMatchCharLength: o = d.minMatchCharLength,
+    isCaseSensitive: a = d.isCaseSensitive,
+    ignoreLocation: h = d.ignoreLocation
+  } = {}) {
+    super(e), this._bitapSearch = new we(e, {
+      location: s,
+      threshold: r,
+      distance: i,
+      includeMatches: n,
+      findAllMatches: c,
+      minMatchCharLength: o,
+      isCaseSensitive: a,
+      ignoreLocation: h
+    });
+  }
+  static get type() {
+    return "fuzzy";
+  }
+  static get multiRegex() {
+    return /^"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^(.*)$/;
+  }
+  search(e) {
+    return this._bitapSearch.searchIn(e);
+  }
+}
+class Ae extends O {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "include";
+  }
+  static get multiRegex() {
+    return /^'"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^'(.*)$/;
+  }
+  search(e) {
+    let s = 0, r;
+    const i = [], n = this.pattern.length;
+    for (; (r = e.indexOf(this.pattern, s)) > -1; )
+      s = r + n, i.push([r, s - 1]);
+    const c = !!i.length;
+    return {
+      isMatch: c,
+      score: c ? 0 : 1,
+      indices: i
+    };
+  }
+}
+const G = [
+  Tt,
+  Ae,
+  Ft,
+  Nt,
+  jt,
+  $t,
+  Ct,
+  Oe
+], he = G.length, Dt = / +(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/, Kt = "|";
+function Yt(t, e = {}) {
+  return t.split(Kt).map((s) => {
+    let r = s.trim().split(Dt).filter((n) => n && !!n.trim()), i = [];
+    for (let n = 0, c = r.length; n < c; n += 1) {
+      const o = r[n];
+      let a = !1, h = -1;
+      for (; !a && ++h < he; ) {
+        const l = G[h];
+        let u = l.isMultiMatch(o);
+        u && (i.push(new l(u, e)), a = !0);
+      }
+      if (!a)
+        for (h = -1; ++h < he; ) {
+          const l = G[h];
+          let u = l.isSingleMatch(o);
+          if (u) {
+            i.push(new l(u, e));
+            break;
+          }
+        }
+    }
+    return i;
+  });
+}
+const Wt = /* @__PURE__ */ new Set([Oe.type, Ae.type]);
+class zt {
+  constructor(e, {
+    isCaseSensitive: s = d.isCaseSensitive,
+    includeMatches: r = d.includeMatches,
+    minMatchCharLength: i = d.minMatchCharLength,
+    ignoreLocation: n = d.ignoreLocation,
+    findAllMatches: c = d.findAllMatches,
+    location: o = d.location,
+    threshold: a = d.threshold,
+    distance: h = d.distance
+  } = {}) {
+    this.query = null, this.options = {
+      isCaseSensitive: s,
+      includeMatches: r,
+      minMatchCharLength: i,
+      findAllMatches: c,
+      ignoreLocation: n,
+      location: o,
+      threshold: a,
+      distance: h
+    }, this.pattern = s ? e : e.toLowerCase(), this.query = Yt(this.pattern, this.options);
+  }
+  static condition(e, s) {
+    return s.useExtendedSearch;
+  }
+  searchIn(e) {
+    const s = this.query;
+    if (!s)
+      return {
+        isMatch: !1,
+        score: 1
+      };
+    const { includeMatches: r, isCaseSensitive: i } = this.options;
+    e = i ? e : e.toLowerCase();
+    let n = 0, c = [], o = 0;
+    for (let a = 0, h = s.length; a < h; a += 1) {
+      const l = s[a];
+      c.length = 0, n = 0;
+      for (let u = 0, f = l.length; u < f; u += 1) {
+        const g = l[u], { isMatch: p, indices: m, score: A } = g.search(e);
+        if (p) {
+          if (n += 1, o += A, r) {
+            const S = g.constructor.type;
+            Wt.has(S) ? c = [...c, ...m] : c.push(m);
+          }
+        } else {
+          o = 0, n = 0, c.length = 0;
+          break;
+        }
+      }
+      if (n) {
+        let u = {
+          isMatch: !0,
+          score: o / n
+        };
+        return r && (u.indices = c), u;
+      }
+    }
+    return {
+      isMatch: !1,
+      score: 1
+    };
+  }
+}
+const J = [];
+function Ht(...t) {
+  J.push(...t);
+}
+function Q(t, e) {
+  for (let s = 0, r = J.length; s < r; s += 1) {
+    let i = J[s];
+    if (i.condition(t, e))
+      return new i(t, e);
+  }
+  return new we(t, e);
+}
+const $ = {
+  AND: "$and",
+  OR: "$or"
+}, X = {
+  PATH: "$path",
+  PATTERN: "$val"
+}, Z = (t) => !!(t[$.AND] || t[$.OR]), Bt = (t) => !!t[X.PATH], Vt = (t) => !x(t) && _e(t) && !Z(t), ue = (t) => ({
+  [$.AND]: Object.keys(t).map((e) => ({
+    [e]: t[e]
+  }))
+});
+function Ie(t, e, { auto: s = !0 } = {}) {
+  const r = (i) => {
+    let n = Object.keys(i);
+    const c = Bt(i);
+    if (!c && n.length > 1 && !Z(i))
+      return r(ue(i));
+    if (Vt(i)) {
+      const a = c ? i[X.PATH] : n[0], h = c ? i[X.PATTERN] : i[a];
+      if (!_(h))
+        throw new Error(yt(a));
+      const l = {
+        keyId: U(a),
+        pattern: h
+      };
+      return s && (l.searcher = Q(h, e)), l;
+    }
+    let o = {
+      children: [],
+      operator: n[0]
+    };
+    return n.forEach((a) => {
+      const h = i[a];
+      x(h) && h.forEach((l) => {
+        o.children.push(r(l));
+      });
+    }), o;
+  };
+  return Z(t) || (t = ue(t)), r(t);
+}
+function Ut(t, { ignoreFieldNorm: e = d.ignoreFieldNorm }) {
+  t.forEach((s) => {
+    let r = 1;
+    s.matches.forEach(({ key: i, norm: n, score: c }) => {
+      const o = i ? i.weight : null;
+      r *= Math.pow(
+        c === 0 && o ? Number.EPSILON : c,
+        (o || 1) * (e ? 1 : n)
+      );
+    }), s.score = r;
+  });
+}
+function Gt(t, e) {
+  const s = t.matches;
+  e.matches = [], y(s) && s.forEach((r) => {
+    if (!y(r.indices) || !r.indices.length)
+      return;
+    const { indices: i, value: n } = r;
+    let c = {
+      indices: i,
+      value: n
+    };
+    r.key && (c.key = r.key.src), r.idx > -1 && (c.refIndex = r.idx), e.matches.push(c);
+  });
+}
+function Jt(t, e) {
+  e.score = t.score;
+}
+function Qt(t, e, {
+  includeMatches: s = d.includeMatches,
+  includeScore: r = d.includeScore
+} = {}) {
+  const i = [];
+  return s && i.push(Gt), r && i.push(Jt), t.map((n) => {
+    const { idx: c } = n, o = {
+      item: e[c],
+      refIndex: c
+    };
+    return i.length && i.forEach((a) => {
+      a(n, o);
+    }), o;
+  });
+}
+class k {
+  constructor(e, s = {}, r) {
+    this.options = { ...d, ...s }, this.options.useExtendedSearch, this._keyStore = new St(this.options.keys), this.setCollection(e, r);
+  }
+  setCollection(e, s) {
+    if (this._docs = e, s && !(s instanceof te))
+      throw new Error(mt);
+    this._myIndex = s || Re(this.options.keys, this._docs, {
+      getFn: this.options.getFn,
+      fieldNormWeight: this.options.fieldNormWeight
+    });
+  }
+  add(e) {
+    y(e) && (this._docs.push(e), this._myIndex.add(e));
+  }
+  remove(e = () => !1) {
+    const s = [];
+    for (let r = 0, i = this._docs.length; r < i; r += 1) {
+      const n = this._docs[r];
+      e(n, r) && (this.removeAt(r), r -= 1, i -= 1, s.push(n));
+    }
+    return s;
+  }
+  removeAt(e) {
+    this._docs.splice(e, 1), this._myIndex.removeAt(e);
+  }
+  getIndex() {
+    return this._myIndex;
+  }
+  search(e, { limit: s = -1 } = {}) {
+    const {
+      includeMatches: r,
+      includeScore: i,
+      shouldSort: n,
+      sortFn: c,
+      ignoreFieldNorm: o
+    } = this.options;
+    let a = _(e) ? _(this._docs[0]) ? this._searchStringList(e) : this._searchObjectList(e) : this._searchLogical(e);
+    return Ut(a, { ignoreFieldNorm: o }), n && a.sort(c), Ee(s) && s > -1 && (a = a.slice(0, s)), Qt(a, this._docs, {
+      includeMatches: r,
+      includeScore: i
+    });
+  }
+  _searchStringList(e) {
+    const s = Q(e, this.options), { records: r } = this._myIndex, i = [];
+    return r.forEach(({ v: n, i: c, n: o }) => {
+      if (!y(n))
+        return;
+      const { isMatch: a, score: h, indices: l } = s.searchIn(n);
+      a && i.push({
+        item: n,
+        idx: c,
+        matches: [{ score: h, value: n, norm: o, indices: l }]
+      });
+    }), i;
+  }
+  _searchLogical(e) {
+    const s = Ie(e, this.options), r = (o, a, h) => {
+      if (!o.children) {
+        const { keyId: u, searcher: f } = o, g = this._findMatches({
+          key: this._keyStore.get(u),
+          value: this._myIndex.getValueForItemAtKeyId(a, u),
+          searcher: f
+        });
+        return g && g.length ? [
+          {
+            idx: h,
+            item: a,
+            matches: g
+          }
+        ] : [];
+      }
+      const l = [];
+      for (let u = 0, f = o.children.length; u < f; u += 1) {
+        const g = o.children[u], p = r(g, a, h);
+        if (p.length)
+          l.push(...p);
+        else if (o.operator === $.AND)
+          return [];
+      }
+      return l;
+    }, i = this._myIndex.records, n = {}, c = [];
+    return i.forEach(({ $: o, i: a }) => {
+      if (y(o)) {
+        let h = r(s, o, a);
+        h.length && (n[a] || (n[a] = { idx: a, item: o, matches: [] }, c.push(n[a])), h.forEach(({ matches: l }) => {
+          n[a].matches.push(...l);
+        }));
+      }
+    }), c;
+  }
+  _searchObjectList(e) {
+    const s = Q(e, this.options), { keys: r, records: i } = this._myIndex, n = [];
+    return i.forEach(({ $: c, i: o }) => {
+      if (!y(c))
+        return;
+      let a = [];
+      r.forEach((h, l) => {
+        a.push(
+          ...this._findMatches({
+            key: h,
+            value: c[l],
+            searcher: s
+          })
+        );
+      }), a.length && n.push({
+        idx: o,
+        item: c,
+        matches: a
+      });
+    }), n;
+  }
+  _findMatches({ key: e, value: s, searcher: r }) {
+    if (!y(s))
+      return [];
+    let i = [];
+    if (x(s))
+      s.forEach(({ v: n, i: c, n: o }) => {
+        if (!y(n))
+          return;
+        const { isMatch: a, score: h, indices: l } = r.searchIn(n);
+        a && i.push({
+          score: h,
+          key: e,
+          value: n,
+          idx: c,
+          norm: o,
+          indices: l
+        });
+      });
+    else {
+      const { v: n, n: c } = s, { isMatch: o, score: a, indices: h } = r.searchIn(n);
+      o && i.push({ score: a, key: e, value: n, norm: c, indices: h });
+    }
+    return i;
+  }
+}
+k.version = "7.0.0";
+k.createIndex = Re;
+k.parseIndex = Lt;
+k.config = d;
+k.parseQuery = Ie;
+Ht(zt);
+const Xt = {
+  threshold: 0.3
+}, Zt = (t) => (e) => {
+  const s = new k(e, {
+    keys: Object.keys(e[0]),
+    ...Xt,
+    ...t
+  });
+  return {
+    type: "fuse",
+    page: (r, i) => e.slice(r * i, (r + 1) * i),
+    search: (r) => s.search(r).map(({ item: i }) => i),
+    retrieve: (r) => e.filter((i) => r.includes(i.key))
+  };
+}, qt = Zt(), es = ({
+  term: t,
+  searcher: e = qt
+}) => ht(({ data: s }) => typeof e == "function" ? t.length === 0 || (s == null ? void 0 : s.length) === 0 ? { data: s, transformed: !1 } : { data: e(s).search(t), transformed: !0 } : { data: e.search(t), transformed: !0 }), be = ({
+  debounce: t = 250,
+  value: e,
+  onChange: s,
+  transformBefore: r
+}) => {
+  const [i, n] = tt({
+    onChange: s,
+    value: e,
+    initial: ""
+  }), { setTransform: c, deleteTransform: o } = fe(), a = Pe(c, t, []), h = qe(
+    (l) => {
+      n(l), l.length === 0 ? o("filter") : (r != null && (l = r(l)), a("filter", es({ term: l })));
+    },
+    [n, r]
+  );
+  return { value: i, onChange: h };
+}, ts = ({
+  children: t = (s) => /* @__PURE__ */ Ze.jsx(ke, { placeholder: "Filter", ...s }),
+  ...e
+}) => t(be(e)), hs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Column: ve,
+  ColumnContext: Te,
+  Core: Ce,
+  DataProvider: Fe,
+  Filter: ts,
+  Hover: Ne,
+  ItemFrame: $e,
+  List: st,
+  Search: je,
+  Selector: De,
+  selectValueIsZero: Ke,
+  useDataContext: Ye,
+  useDataUtilContext: fe,
+  useFilter: be,
+  useGetTransformedData: We,
+  useHoverContext: ze,
+  useSearch: He,
+  useSelect: Be,
+  useSelection: Ve,
+  useSelectionContext: Ue,
+  useSelectionUtils: Ge,
+  useSetSourceData: Je,
+  useSourceData: Qe,
+  useTransformedData: Xe
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  ts as F,
+  es as c,
+  hs as e,
+  Zt as f,
+  ht as p
+};