@oneclick.dev/cms-core-modules 0.0.122 → 0.0.123

package/dist/fuse-Deb-Iq39.mjs

@@ -0,0 +1,1473 @@
+function y(s) {
+  return Array.isArray ? Array.isArray(s) : he(s) === "[object Array]";
+}
+function me(s) {
+  if (typeof s == "string")
+    return s;
+  if (typeof s == "bigint")
+    return s.toString();
+  const e = s + "";
+  return e == "0" && 1 / s == -1 / 0 ? "-0" : e;
+}
+function K(s) {
+  return s == null ? "" : me(s);
+}
+function C(s) {
+  return typeof s == "string";
+}
+function T(s) {
+  return typeof s == "number";
+}
+function Ce(s) {
+  return s === !0 || s === !1 || Ee(s) && he(s) == "[object Boolean]";
+}
+function ue(s) {
+  return typeof s == "object";
+}
+function Ee(s) {
+  return ue(s) && s !== null;
+}
+function M(s) {
+  return s != null;
+}
+function $(s) {
+  return !s.trim().length;
+}
+function he(s) {
+  return s == null ? s === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(s);
+}
+const Me = "Incorrect 'index' type", _e = (s) => `Invalid value for key ${s}`, Fe = (s) => `Pattern length exceeds max of ${s}.`, De = (s) => `Missing ${s} property in key`, Ie = (s) => `Property 'weight' in key '${s}' must be a positive integer`, se = Object.prototype.hasOwnProperty;
+class Be {
+  constructor(e) {
+    this._keys = [], this._keyMap = {};
+    let t = 0;
+    e.forEach((n) => {
+      const i = ae(n);
+      this._keys.push(i), this._keyMap[i.id] = i, t += i.weight;
+    }), this._keys.forEach((n) => {
+      n.weight /= t;
+    });
+  }
+  get(e) {
+    return this._keyMap[e];
+  }
+  keys() {
+    return this._keys;
+  }
+  toJSON() {
+    return JSON.stringify(this._keys);
+  }
+}
+function ae(s) {
+  let e = null, t = null, n = null, i = 1, r = null;
+  if (C(s) || y(s))
+    n = s, e = ne(s), t = H(s);
+  else {
+    if (!se.call(s, "name"))
+      throw new Error(De("name"));
+    const c = s.name;
+    if (n = c, se.call(s, "weight") && (i = s.weight, i <= 0))
+      throw new Error(Ie(c));
+    e = ne(c), t = H(c), r = s.getFn;
+  }
+  return {
+    path: e,
+    id: t,
+    weight: i,
+    src: n,
+    getFn: r
+  };
+}
+function ne(s) {
+  return y(s) ? s : s.split(".");
+}
+function H(s) {
+  return y(s) ? s.join(".") : s;
+}
+function Se(s, e) {
+  const t = [];
+  let n = !1;
+  const i = (r, c, h, o) => {
+    if (M(r))
+      if (!c[h])
+        t.push(o !== void 0 ? {
+          v: r,
+          i: o
+        } : r);
+      else {
+        const l = c[h], u = r[l];
+        if (!M(u))
+          return;
+        if (h === c.length - 1 && (C(u) || T(u) || Ce(u) || typeof u == "bigint"))
+          t.push(o !== void 0 ? {
+            v: K(u),
+            i: o
+          } : K(u));
+        else if (y(u)) {
+          n = !0;
+          for (let f = 0, d = u.length; f < d; f += 1)
+            i(u[f], c, h + 1, f);
+        } else c.length && i(u, c, h + 1, o);
+      }
+  };
+  return i(s, C(e) ? e.split(".") : e, 0), n ? t : t[0];
+}
+const ye = {
+  includeMatches: !1,
+  findAllMatches: !1,
+  minMatchCharLength: 1
+}, xe = {
+  isCaseSensitive: !1,
+  ignoreDiacritics: !1,
+  includeScore: !1,
+  keys: [],
+  shouldSort: !0,
+  sortFn: (s, e) => s.score === e.score ? s.idx < e.idx ? -1 : 1 : s.score < e.score ? -1 : 1
+}, ve = {
+  location: 0,
+  threshold: 0.6,
+  distance: 100
+}, ke = {
+  useExtendedSearch: !1,
+  useTokenSearch: !1,
+  getFn: Se,
+  ignoreLocation: !1,
+  ignoreFieldNorm: !1,
+  fieldNormWeight: 1
+}, g = Object.freeze({
+  ...xe,
+  ...ye,
+  ...ve,
+  ...ke
+}), we = /[^ ]+/g;
+function be(s = 1, e = 3) {
+  const t = /* @__PURE__ */ new Map(), n = Math.pow(10, e);
+  return {
+    get(i) {
+      const r = i.match(we).length;
+      if (t.has(r))
+        return t.get(r);
+      const c = 1 / Math.pow(r, 0.5 * s), h = parseFloat(Math.round(c * n) / n);
+      return t.set(r, h), h;
+    },
+    clear() {
+      t.clear();
+    }
+  };
+}
+class X {
+  constructor({
+    getFn: e = g.getFn,
+    fieldNormWeight: t = g.fieldNormWeight
+  } = {}) {
+    this.norm = be(t, 3), this.getFn = e, this.isCreated = !1, this.docs = [], this.keys = [], this._keysMap = {}, this.setIndexRecords();
+  }
+  setSources(e = []) {
+    this.docs = e;
+  }
+  setIndexRecords(e = []) {
+    this.records = e;
+  }
+  setKeys(e = []) {
+    this.keys = e, this._keysMap = {}, e.forEach((t, n) => {
+      this._keysMap[t.id] = n;
+    });
+  }
+  create() {
+    this.isCreated || !this.docs.length || (this.isCreated = !0, C(this.docs[0]) ? this.docs.forEach((e, t) => {
+      this._addString(e, t);
+    }) : this.docs.forEach((e, t) => {
+      this._addObject(e, t);
+    }), this.norm.clear());
+  }
+  // Adds a doc to the end of the index
+  add(e) {
+    const t = this.size();
+    C(e) ? this._addString(e, t) : this._addObject(e, t);
+  }
+  // Removes the doc at the specified index of the index
+  removeAt(e) {
+    this.records.splice(e, 1);
+    for (let t = e, n = this.size(); t < n; t += 1)
+      this.records[t].i -= 1;
+  }
+  // Removes docs at the specified indices (must be sorted ascending)
+  removeAll(e) {
+    for (let t = e.length - 1; t >= 0; t -= 1)
+      this.records.splice(e[t], 1);
+    for (let t = 0, n = this.records.length; t < n; t += 1)
+      this.records[t].i = t;
+  }
+  getValueForItemAtKeyId(e, t) {
+    return e[this._keysMap[t]];
+  }
+  size() {
+    return this.records.length;
+  }
+  _addString(e, t) {
+    if (!M(e) || $(e))
+      return;
+    const n = {
+      v: e,
+      i: t,
+      n: this.norm.get(e)
+    };
+    this.records.push(n);
+  }
+  _addObject(e, t) {
+    const n = {
+      i: t,
+      $: {}
+    };
+    this.keys.forEach((i, r) => {
+      const c = i.getFn ? i.getFn(e) : this.getFn(e, i.path);
+      if (M(c)) {
+        if (y(c)) {
+          const h = [];
+          for (let o = 0, l = c.length; o < l; o += 1) {
+            const u = c[o];
+            if (M(u)) {
+              if (C(u)) {
+                if (!$(u)) {
+                  const f = {
+                    v: u,
+                    i: o,
+                    n: this.norm.get(u)
+                  };
+                  h.push(f);
+                }
+              } else if (M(u.v)) {
+                const f = C(u.v) ? u.v : K(u.v);
+                if (!$(f)) {
+                  const d = {
+                    v: f,
+                    i: u.i,
+                    n: this.norm.get(f)
+                  };
+                  h.push(d);
+                }
+              }
+            }
+          }
+          n.$[r] = h;
+        } else if (C(c) && !$(c)) {
+          const h = {
+            v: c,
+            n: this.norm.get(c)
+          };
+          n.$[r] = h;
+        }
+      }
+    }), this.records.push(n);
+  }
+  toJSON() {
+    return {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      keys: this.keys.map(({
+        getFn: e,
+        ...t
+      }) => t),
+      records: this.records
+    };
+  }
+}
+function le(s, e, {
+  getFn: t = g.getFn,
+  fieldNormWeight: n = g.fieldNormWeight
+} = {}) {
+  const i = new X({
+    getFn: t,
+    fieldNormWeight: n
+  });
+  return i.setKeys(s.map(ae)), i.setSources(e), i.create(), i;
+}
+function Le(s, {
+  getFn: e = g.getFn,
+  fieldNormWeight: t = g.fieldNormWeight
+} = {}) {
+  const {
+    keys: n,
+    records: i
+  } = s, r = new X({
+    getFn: e,
+    fieldNormWeight: t
+  });
+  return r.setKeys(n), r.setIndexRecords(i), r;
+}
+function Oe(s = [], e = g.minMatchCharLength) {
+  const t = [];
+  let n = -1, i = -1, r = 0;
+  for (let c = s.length; r < c; r += 1) {
+    const h = s[r];
+    h && n === -1 ? n = r : !h && n !== -1 && (i = r - 1, i - n + 1 >= e && t.push([n, i]), n = -1);
+  }
+  return s[r - 1] && r - n >= e && t.push([n, r - 1]), t;
+}
+const k = 32;
+function Re(s, e, t, {
+  location: n = g.location,
+  distance: i = g.distance,
+  threshold: r = g.threshold,
+  findAllMatches: c = g.findAllMatches,
+  minMatchCharLength: h = g.minMatchCharLength,
+  includeMatches: o = g.includeMatches,
+  ignoreLocation: l = g.ignoreLocation
+} = {}) {
+  if (e.length > k)
+    throw new Error(Fe(k));
+  const u = e.length, f = s.length, d = Math.max(0, Math.min(n, f));
+  let a = r, p = d;
+  const A = (E, I) => {
+    const _ = E / u;
+    if (l) return _;
+    const L = Math.abs(d - I);
+    return i ? _ + L / i : L ? 1 : _;
+  }, m = h > 1 || o, D = m ? Array(f) : [];
+  let B;
+  for (; (B = s.indexOf(e, p)) > -1; ) {
+    const E = A(0, B);
+    if (a = Math.min(E, a), p = B + u, m) {
+      let I = 0;
+      for (; I < u; )
+        D[B + I] = 1, I += 1;
+    }
+  }
+  p = -1;
+  let S = [], v = 1, R = u + f;
+  const pe = 1 << u - 1;
+  for (let E = 0; E < u; E += 1) {
+    let I = 0, _ = R;
+    for (; I < _; )
+      A(E, d + _) <= a ? I = _ : R = _, _ = Math.floor((R - I) / 2 + I);
+    R = _;
+    let L = Math.max(1, d - _ + 1);
+    const W = c ? f : Math.min(d + _, f) + u, b = Array(W + 2);
+    b[W + 1] = (1 << E) - 1;
+    for (let F = W; F >= L; F -= 1) {
+      const N = F - 1, te = t[s[N]];
+      if (m && (D[N] = +!!te), b[F] = (b[F + 1] << 1 | 1) & te, E && (b[F] |= (S[F + 1] | S[F]) << 1 | 1 | S[F + 1]), b[F] & pe && (v = A(E, N), v <= a)) {
+        if (a = v, p = N, p <= d)
+          break;
+        L = Math.max(1, 2 * d - p);
+      }
+    }
+    if (A(E + 1, d) > a)
+      break;
+    S = b;
+  }
+  const j = {
+    isMatch: p >= 0,
+    // Count exact matches (those with a score of 0) to be "almost" exact
+    score: Math.max(1e-3, v)
+  };
+  if (m) {
+    const E = Oe(D, h);
+    E.length ? o && (j.indices = E) : j.isMatch = !1;
+  }
+  return j;
+}
+function Ne(s) {
+  const e = {};
+  for (let t = 0, n = s.length; t < n; t += 1) {
+    const i = s.charAt(t);
+    e[i] = (e[i] || 0) | 1 << n - t - 1;
+  }
+  return e;
+}
+function Z(s) {
+  if (s.length <= 1) return s;
+  s.sort((t, n) => t[0] - n[0] || t[1] - n[1]);
+  const e = [s[0]];
+  for (let t = 1, n = s.length; t < n; t += 1) {
+    const i = e[e.length - 1], r = s[t];
+    r[0] <= i[1] + 1 ? i[1] = Math.max(i[1], r[1]) : e.push(r);
+  }
+  return e;
+}
+const fe = {
+  ł: "l",
+  // ł
+  Ł: "L",
+  // Ł
+  đ: "d",
+  // đ
+  Đ: "D",
+  // Đ
+  ø: "o",
+  // ø
+  Ø: "O",
+  // Ø
+  ħ: "h",
+  // ħ
+  Ħ: "H",
+  // Ħ
+  ŧ: "t",
+  // ŧ
+  Ŧ: "T",
+  // Ŧ
+  ı: "i",
+  // ı
+  ß: "ss"
+  // ß
+}, $e = new RegExp("[" + Object.keys(fe).join("") + "]", "g"), O = String.prototype.normalize ? (s) => s.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, "").replace($e, (e) => fe[e]) : (s) => s;
+class q {
+  constructor(e, {
+    location: t = g.location,
+    threshold: n = g.threshold,
+    distance: i = g.distance,
+    includeMatches: r = g.includeMatches,
+    findAllMatches: c = g.findAllMatches,
+    minMatchCharLength: h = g.minMatchCharLength,
+    isCaseSensitive: o = g.isCaseSensitive,
+    ignoreDiacritics: l = g.ignoreDiacritics,
+    ignoreLocation: u = g.ignoreLocation
+  } = {}) {
+    if (this.options = {
+      location: t,
+      threshold: n,
+      distance: i,
+      includeMatches: r,
+      findAllMatches: c,
+      minMatchCharLength: h,
+      isCaseSensitive: o,
+      ignoreDiacritics: l,
+      ignoreLocation: u
+    }, e = o ? e : e.toLowerCase(), e = l ? O(e) : e, this.pattern = e, this.chunks = [], !this.pattern.length)
+      return;
+    const f = (a, p) => {
+      this.chunks.push({
+        pattern: a,
+        alphabet: Ne(a),
+        startIndex: p
+      });
+    }, d = this.pattern.length;
+    if (d > k) {
+      let a = 0;
+      const p = d % k, A = d - p;
+      for (; a < A; )
+        f(this.pattern.substr(a, k), a), a += k;
+      if (p) {
+        const m = d - k;
+        f(this.pattern.substr(m), m);
+      }
+    } else
+      f(this.pattern, 0);
+  }
+  searchIn(e) {
+    const {
+      isCaseSensitive: t,
+      ignoreDiacritics: n,
+      includeMatches: i
+    } = this.options;
+    if (e = t ? e : e.toLowerCase(), e = n ? O(e) : e, this.pattern === e) {
+      const A = {
+        isMatch: !0,
+        score: 0
+      };
+      return i && (A.indices = [[0, e.length - 1]]), A;
+    }
+    const {
+      location: r,
+      distance: c,
+      threshold: h,
+      findAllMatches: o,
+      minMatchCharLength: l,
+      ignoreLocation: u
+    } = this.options, f = [];
+    let d = 0, a = !1;
+    this.chunks.forEach(({
+      pattern: A,
+      alphabet: m,
+      startIndex: D
+    }) => {
+      const {
+        isMatch: B,
+        score: S,
+        indices: v
+      } = Re(e, A, m, {
+        location: r + D,
+        distance: c,
+        threshold: h,
+        findAllMatches: o,
+        minMatchCharLength: l,
+        includeMatches: i,
+        ignoreLocation: u
+      });
+      B && (a = !0), d += S, B && v && f.push(...v);
+    });
+    const p = {
+      isMatch: a,
+      score: a ? d / this.chunks.length : 1
+    };
+    return a && i && (p.indices = Z(f)), p;
+  }
+}
+class x {
+  constructor(e) {
+    this.pattern = e;
+  }
+  static isMultiMatch(e) {
+    return ie(e, this.multiRegex);
+  }
+  static isSingleMatch(e) {
+    return ie(e, this.singleRegex);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  search(e) {
+    return {
+      isMatch: !1,
+      score: 1
+    };
+  }
+}
+function ie(s, e) {
+  const t = s.match(e);
+  return t ? t[1] : null;
+}
+class Te extends x {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "exact";
+  }
+  static get multiRegex() {
+    return /^="(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^=(.*)$/;
+  }
+  search(e) {
+    const t = e === this.pattern;
+    return {
+      isMatch: t,
+      score: t ? 0 : 1,
+      indices: [0, this.pattern.length - 1]
+    };
+  }
+}
+class ze extends x {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "inverse-exact";
+  }
+  static get multiRegex() {
+    return /^!"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^!(.*)$/;
+  }
+  search(e) {
+    const n = e.indexOf(this.pattern) === -1;
+    return {
+      isMatch: n,
+      score: n ? 0 : 1,
+      indices: [0, e.length - 1]
+    };
+  }
+}
+class Pe extends x {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "prefix-exact";
+  }
+  static get multiRegex() {
+    return /^\^"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^\^(.*)$/;
+  }
+  search(e) {
+    const t = e.startsWith(this.pattern);
+    return {
+      isMatch: t,
+      score: t ? 0 : 1,
+      indices: [0, this.pattern.length - 1]
+    };
+  }
+}
+class je extends x {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "inverse-prefix-exact";
+  }
+  static get multiRegex() {
+    return /^!\^"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^!\^(.*)$/;
+  }
+  search(e) {
+    const t = !e.startsWith(this.pattern);
+    return {
+      isMatch: t,
+      score: t ? 0 : 1,
+      indices: [0, e.length - 1]
+    };
+  }
+}
+class We extends x {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "suffix-exact";
+  }
+  static get multiRegex() {
+    return /^"(.*)"\$$/;
+  }
+  static get singleRegex() {
+    return /^(.*)\$$/;
+  }
+  search(e) {
+    const t = e.endsWith(this.pattern);
+    return {
+      isMatch: t,
+      score: t ? 0 : 1,
+      indices: [e.length - this.pattern.length, e.length - 1]
+    };
+  }
+}
+class Ke extends x {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "inverse-suffix-exact";
+  }
+  static get multiRegex() {
+    return /^!"(.*)"\$$/;
+  }
+  static get singleRegex() {
+    return /^!(.*)\$$/;
+  }
+  search(e) {
+    const t = !e.endsWith(this.pattern);
+    return {
+      isMatch: t,
+      score: t ? 0 : 1,
+      indices: [0, e.length - 1]
+    };
+  }
+}
+class de extends x {
+  constructor(e, {
+    location: t = g.location,
+    threshold: n = g.threshold,
+    distance: i = g.distance,
+    includeMatches: r = g.includeMatches,
+    findAllMatches: c = g.findAllMatches,
+    minMatchCharLength: h = g.minMatchCharLength,
+    isCaseSensitive: o = g.isCaseSensitive,
+    ignoreDiacritics: l = g.ignoreDiacritics,
+    ignoreLocation: u = g.ignoreLocation
+  } = {}) {
+    super(e), this._bitapSearch = new q(e, {
+      location: t,
+      threshold: n,
+      distance: i,
+      includeMatches: r,
+      findAllMatches: c,
+      minMatchCharLength: h,
+      isCaseSensitive: o,
+      ignoreDiacritics: l,
+      ignoreLocation: u
+    });
+  }
+  static get type() {
+    return "fuzzy";
+  }
+  static get multiRegex() {
+    return /^"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^(.*)$/;
+  }
+  search(e) {
+    return this._bitapSearch.searchIn(e);
+  }
+}
+class ge extends x {
+  constructor(e) {
+    super(e);
+  }
+  static get type() {
+    return "include";
+  }
+  static get multiRegex() {
+    return /^'"(.*)"$/;
+  }
+  static get singleRegex() {
+    return /^'(.*)$/;
+  }
+  search(e) {
+    let t = 0, n;
+    const i = [], r = this.pattern.length;
+    for (; (n = e.indexOf(this.pattern, t)) > -1; )
+      t = n + r, i.push([n, t - 1]);
+    const c = !!i.length;
+    return {
+      isMatch: c,
+      score: c ? 0 : 1,
+      indices: i
+    };
+  }
+}
+const Q = [Te, ge, Pe, je, Ke, We, ze, de], re = Q.length, He = "\0", Qe = "|";
+function Ge(s) {
+  const e = [], t = s.length;
+  let n = 0;
+  for (; n < t; ) {
+    for (; n < t && s[n] === " "; ) n++;
+    if (n >= t) break;
+    let i = n;
+    for (; i < t && s[i] !== " " && s[i] !== '"'; ) i++;
+    if (i < t && s[i] === '"') {
+      for (i++; i < t; ) {
+        if (s[i] === '"') {
+          const r = i + 1;
+          if (r >= t || s[r] === " ") {
+            i++;
+            break;
+          }
+          if (s[r] === "$" && (r + 1 >= t || s[r + 1] === " ")) {
+            i += 2;
+            break;
+          }
+        }
+        i++;
+      }
+      e.push(s.substring(n, i)), n = i;
+    } else {
+      for (; i < t && s[i] !== " "; ) i++;
+      e.push(s.substring(n, i)), n = i;
+    }
+  }
+  return e;
+}
+function Ye(s, e = {}) {
+  return s.replace(/\\\|/g, He).split(Qe).map((n) => {
+    const i = n.replace(/\u0000/g, "|"), r = Ge(i.trim()).filter((h) => h && !!h.trim()), c = [];
+    for (let h = 0, o = r.length; h < o; h += 1) {
+      const l = r[h];
+      let u = !1, f = -1;
+      for (; !u && ++f < re; ) {
+        const d = Q[f], a = d.isMultiMatch(l);
+        a && (c.push(new d(a, e)), u = !0);
+      }
+      if (!u)
+        for (f = -1; ++f < re; ) {
+          const d = Q[f], a = d.isSingleMatch(l);
+          if (a) {
+            c.push(new d(a, e));
+            break;
+          }
+        }
+    }
+    return c;
+  });
+}
+const Ue = /* @__PURE__ */ new Set([de.type, ge.type]);
+class Ve {
+  constructor(e, {
+    isCaseSensitive: t = g.isCaseSensitive,
+    ignoreDiacritics: n = g.ignoreDiacritics,
+    includeMatches: i = g.includeMatches,
+    minMatchCharLength: r = g.minMatchCharLength,
+    ignoreLocation: c = g.ignoreLocation,
+    findAllMatches: h = g.findAllMatches,
+    location: o = g.location,
+    threshold: l = g.threshold,
+    distance: u = g.distance
+  } = {}) {
+    this.query = null, this.options = {
+      isCaseSensitive: t,
+      ignoreDiacritics: n,
+      includeMatches: i,
+      minMatchCharLength: r,
+      findAllMatches: h,
+      ignoreLocation: c,
+      location: o,
+      threshold: l,
+      distance: u
+    }, e = t ? e : e.toLowerCase(), e = n ? O(e) : e, this.pattern = e, this.query = Ye(this.pattern, this.options);
+  }
+  static condition(e, t) {
+    return t.useExtendedSearch;
+  }
+  // Note: searchIn operates on a single text value and sets hasInverse on the
+  // result when inverse patterns are involved. _searchObjectList uses this to
+  // switch from "ANY key" to "ALL keys" aggregation. See #712.
+  searchIn(e) {
+    const t = this.query;
+    if (!t)
+      return {
+        isMatch: !1,
+        score: 1
+      };
+    const {
+      includeMatches: n,
+      isCaseSensitive: i,
+      ignoreDiacritics: r
+    } = this.options;
+    e = i ? e : e.toLowerCase(), e = r ? O(e) : e;
+    let c = 0;
+    const h = [];
+    let o = 0, l = !1;
+    for (let u = 0, f = t.length; u < f; u += 1) {
+      const d = t[u];
+      h.length = 0, c = 0, l = !1;
+      for (let a = 0, p = d.length; a < p; a += 1) {
+        const A = d[a], {
+          isMatch: m,
+          indices: D,
+          score: B
+        } = A.search(e);
+        if (m) {
+          c += 1, o += B;
+          const S = A.constructor.type;
+          S.startsWith("inverse") && (l = !0), n && (Ue.has(S) ? h.push(...D) : h.push(D));
+        } else {
+          o = 0, c = 0, h.length = 0, l = !1;
+          break;
+        }
+      }
+      if (c) {
+        const a = {
+          isMatch: !0,
+          score: o / c
+        };
+        return l && (a.hasInverse = !0), n && (a.indices = Z(h)), a;
+      }
+    }
+    return {
+      isMatch: !1,
+      score: 1
+    };
+  }
+}
+const G = [];
+function ee(...s) {
+  G.push(...s);
+}
+function z(s, e) {
+  for (let t = 0, n = G.length; t < n; t += 1) {
+    const i = G[t];
+    if (i.condition(s, e))
+      return new i(s, e);
+  }
+  return new q(s, e);
+}
+const P = {
+  AND: "$and",
+  OR: "$or"
+}, Y = {
+  PATH: "$path",
+  PATTERN: "$val"
+}, U = (s) => !!(s[P.AND] || s[P.OR]), Je = (s) => !!s[Y.PATH], Xe = (s) => !y(s) && ue(s) && !U(s), ce = (s) => ({
+  [P.AND]: Object.keys(s).map((e) => ({
+    [e]: s[e]
+  }))
+});
+function Ae(s, e, {
+  auto: t = !0
+} = {}) {
+  const n = (i) => {
+    if (C(i)) {
+      const o = {
+        keyId: null,
+        pattern: i
+      };
+      return t && (o.searcher = z(i, e)), o;
+    }
+    const r = Object.keys(i), c = Je(i);
+    if (!c && r.length > 1 && !U(i))
+      return n(ce(i));
+    if (Xe(i)) {
+      const o = c ? i[Y.PATH] : r[0], l = c ? i[Y.PATTERN] : i[o];
+      if (!C(l))
+        throw new Error(_e(o));
+      const u = {
+        keyId: H(o),
+        pattern: l
+      };
+      return t && (u.searcher = z(l, e)), u;
+    }
+    const h = {
+      children: [],
+      operator: r[0]
+    };
+    return r.forEach((o) => {
+      const l = i[o];
+      y(l) && l.forEach((u) => {
+        h.children.push(n(u));
+      });
+    }), h;
+  };
+  return U(s) || (s = ce(s)), n(s);
+}
+function V(s, {
+  ignoreFieldNorm: e = g.ignoreFieldNorm
+}) {
+  let t = 1;
+  return s.forEach(({
+    key: n,
+    norm: i,
+    score: r
+  }) => {
+    const c = n ? n.weight : null;
+    t *= Math.pow(r === 0 && c ? Number.EPSILON : r, (c || 1) * (e ? 1 : i));
+  }), t;
+}
+function Ze(s, {
+  ignoreFieldNorm: e = g.ignoreFieldNorm
+}) {
+  s.forEach((t) => {
+    t.score = V(t.matches, {
+      ignoreFieldNorm: e
+    });
+  });
+}
+class qe {
+  constructor(e) {
+    this.limit = e, this.heap = [];
+  }
+  get size() {
+    return this.heap.length;
+  }
+  shouldInsert(e) {
+    return this.size < this.limit || e < this.heap[0].score;
+  }
+  insert(e) {
+    this.size < this.limit ? (this.heap.push(e), this._bubbleUp(this.size - 1)) : e.score < this.heap[0].score && (this.heap[0] = e, this._sinkDown(0));
+  }
+  extractSorted(e) {
+    return this.heap.sort(e);
+  }
+  _bubbleUp(e) {
+    const t = this.heap;
+    for (; e > 0; ) {
+      const n = e - 1 >> 1;
+      if (t[e].score <= t[n].score) break;
+      const i = t[e];
+      t[e] = t[n], t[n] = i, e = n;
+    }
+  }
+  _sinkDown(e) {
+    const t = this.heap, n = t.length;
+    let i = e;
+    do {
+      e = i;
+      const r = 2 * e + 1, c = 2 * e + 2;
+      if (r < n && t[r].score > t[i].score && (i = r), c < n && t[c].score > t[i].score && (i = c), i !== e) {
+        const h = t[e];
+        t[e] = t[i], t[i] = h;
+      }
+    } while (i !== e);
+  }
+}
+function et(s, e) {
+  const t = s.matches;
+  e.matches = [], M(t) && t.forEach((n) => {
+    if (!M(n.indices) || !n.indices.length)
+      return;
+    const {
+      indices: i,
+      value: r
+    } = n, c = {
+      indices: i,
+      value: r
+    };
+    n.key && (c.key = n.key.src), n.idx > -1 && (c.refIndex = n.idx), e.matches.push(c);
+  });
+}
+function tt(s, e) {
+  e.score = s.score;
+}
+function st(s, e, {
+  includeMatches: t = g.includeMatches,
+  includeScore: n = g.includeScore
+} = {}) {
+  const i = [];
+  return t && i.push(et), n && i.push(tt), s.map((r) => {
+    const {
+      idx: c
+    } = r, h = {
+      item: e[c],
+      refIndex: c
+    };
+    return i.length && i.forEach((o) => {
+      o(r, h);
+    }), h;
+  });
+}
+const nt = /\b\w+\b/g;
+function J({
+  isCaseSensitive: s = !1,
+  ignoreDiacritics: e = !1
+} = {}) {
+  return {
+    tokenize(t) {
+      return s || (t = t.toLowerCase()), e && (t = O(t)), t.match(nt) || [];
+    }
+  };
+}
+function it(s, e, t) {
+  const n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+  let r = 0;
+  function c(h, o, l, u) {
+    const f = t.tokenize(h);
+    if (!f.length) return;
+    r++;
+    const d = /* @__PURE__ */ new Map();
+    for (const a of f)
+      d.set(a, (d.get(a) || 0) + 1);
+    for (const [a, p] of d) {
+      const A = {
+        docIdx: o,
+        keyIdx: l,
+        subIdx: u,
+        tf: p
+      };
+      let m = n.get(a);
+      m || (m = [], n.set(a, m)), m.push(A), i.set(a, (i.get(a) || 0) + 1);
+    }
+  }
+  for (const h of s) {
+    const {
+      i: o,
+      v: l,
+      $: u
+    } = h;
+    if (l !== void 0) {
+      c(l, o, -1, -1);
+      continue;
+    }
+    if (u)
+      for (let f = 0; f < e; f++) {
+        const d = u[f];
+        if (d)
+          if (Array.isArray(d))
+            for (const a of d)
+              c(a.v, o, f, a.i ?? -1);
+          else
+            c(d.v, o, f, -1);
+      }
+  }
+  return {
+    terms: n,
+    fieldCount: r,
+    df: i
+  };
+}
+function rt(s, e, t, n) {
+  const {
+    i,
+    v: r,
+    $: c
+  } = e;
+  function h(o, l, u) {
+    const f = n.tokenize(o);
+    if (!f.length) return;
+    s.fieldCount++;
+    const d = /* @__PURE__ */ new Map();
+    for (const a of f)
+      d.set(a, (d.get(a) || 0) + 1);
+    for (const [a, p] of d) {
+      const A = {
+        docIdx: i,
+        keyIdx: l,
+        subIdx: u,
+        tf: p
+      };
+      let m = s.terms.get(a);
+      m || (m = [], s.terms.set(a, m)), m.push(A), s.df.set(a, (s.df.get(a) || 0) + 1);
+    }
+  }
+  if (r !== void 0) {
+    h(r, -1, -1);
+    return;
+  }
+  if (c)
+    for (let o = 0; o < t; o++) {
+      const l = c[o];
+      if (l)
+        if (Array.isArray(l))
+          for (const u of l)
+            h(u.v, o, u.i ?? -1);
+        else
+          h(l.v, o, -1);
+    }
+}
+function oe(s, e) {
+  for (const [t, n] of s.terms) {
+    const i = n.filter((c) => c.docIdx !== e), r = n.length - i.length;
+    r > 0 && (s.fieldCount -= r, s.df.set(t, (s.df.get(t) || 0) - r), i.length === 0 ? (s.terms.delete(t), s.df.delete(t)) : s.terms.set(t, i));
+  }
+}
+class w {
+  // Statics are assigned in entry.ts
+  constructor(e, t, n) {
+    this.options = {
+      ...g,
+      ...t
+    }, this.options.useExtendedSearch, this.options.useTokenSearch, this._keyStore = new Be(this.options.keys), this._docs = e, this._myIndex = null, this._invertedIndex = null, this.setCollection(e, n), this._lastQuery = null, this._lastSearcher = null;
+  }
+  _getSearcher(e) {
+    if (this._lastQuery === e)
+      return this._lastSearcher;
+    const t = this._invertedIndex ? {
+      ...this.options,
+      _invertedIndex: this._invertedIndex
+    } : this.options, n = z(e, t);
+    return this._lastQuery = e, this._lastSearcher = n, n;
+  }
+  setCollection(e, t) {
+    if (this._docs = e, t && !(t instanceof X))
+      throw new Error(Me);
+    if (this._myIndex = t || le(this.options.keys, this._docs, {
+      getFn: this.options.getFn,
+      fieldNormWeight: this.options.fieldNormWeight
+    }), this.options.useTokenSearch) {
+      const n = J({
+        isCaseSensitive: this.options.isCaseSensitive,
+        ignoreDiacritics: this.options.ignoreDiacritics
+      });
+      this._invertedIndex = it(this._myIndex.records, this._myIndex.keys.length, n);
+    }
+  }
+  add(e) {
+    if (M(e) && (this._docs.push(e), this._myIndex.add(e), this._invertedIndex)) {
+      const t = this._myIndex.records[this._myIndex.records.length - 1], n = J({
+        isCaseSensitive: this.options.isCaseSensitive,
+        ignoreDiacritics: this.options.ignoreDiacritics
+      });
+      rt(this._invertedIndex, t, this._myIndex.keys.length, n);
+    }
+  }
+  remove(e = () => !1) {
+    const t = [], n = [];
+    for (let i = 0, r = this._docs.length; i < r; i += 1)
+      e(this._docs[i], i) && (t.push(this._docs[i]), n.push(i));
+    if (n.length) {
+      if (this._invertedIndex)
+        for (const i of n)
+          oe(this._invertedIndex, i);
+      for (let i = n.length - 1; i >= 0; i -= 1)
+        this._docs.splice(n[i], 1);
+      this._myIndex.removeAll(n);
+    }
+    return t;
+  }
+  removeAt(e) {
+    this._invertedIndex && oe(this._invertedIndex, e);
+    const t = this._docs.splice(e, 1)[0];
+    return this._myIndex.removeAt(e), t;
+  }
+  getIndex() {
+    return this._myIndex;
+  }
+  search(e, t) {
+    const {
+      limit: n = -1
+    } = t || {}, {
+      includeMatches: i,
+      includeScore: r,
+      shouldSort: c,
+      sortFn: h,
+      ignoreFieldNorm: o
+    } = this.options;
+    if (C(e) && !e.trim()) {
+      let f = this._docs.map((d, a) => ({
+        item: d,
+        refIndex: a
+      }));
+      return T(n) && n > -1 && (f = f.slice(0, n)), f;
+    }
+    const l = T(n) && n > 0 && C(e);
+    let u;
+    if (l) {
+      const f = new qe(n);
+      C(this._docs[0]) ? this._searchStringList(e, {
+        heap: f,
+        ignoreFieldNorm: o
+      }) : this._searchObjectList(e, {
+        heap: f,
+        ignoreFieldNorm: o
+      }), u = f.extractSorted(h);
+    } else
+      u = C(e) ? C(this._docs[0]) ? this._searchStringList(e) : this._searchObjectList(e) : this._searchLogical(e), Ze(u, {
+        ignoreFieldNorm: o
+      }), c && u.sort(h), T(n) && n > -1 && (u = u.slice(0, n));
+    return st(u, this._docs, {
+      includeMatches: i,
+      includeScore: r
+    });
+  }
+  _searchStringList(e, {
+    heap: t,
+    ignoreFieldNorm: n
+  } = {}) {
+    const i = this._getSearcher(e), {
+      records: r
+    } = this._myIndex, c = t ? null : [];
+    return r.forEach(({
+      v: h,
+      i: o,
+      n: l
+    }) => {
+      if (!M(h))
+        return;
+      const {
+        isMatch: u,
+        score: f,
+        indices: d
+      } = i.searchIn(h);
+      if (u) {
+        const a = {
+          item: h,
+          idx: o,
+          matches: [{
+            score: f,
+            value: h,
+            norm: l,
+            indices: d
+          }]
+        };
+        t ? (a.score = V(a.matches, {
+          ignoreFieldNorm: n
+        }), t.shouldInsert(a.score) && t.insert(a)) : c.push(a);
+      }
+    }), c;
+  }
+  _searchLogical(e) {
+    const t = Ae(e, this.options), n = (h, o, l) => {
+      if (!("children" in h)) {
+        const {
+          keyId: a,
+          searcher: p
+        } = h;
+        let A;
+        return a === null ? (A = [], this._myIndex.keys.forEach((m, D) => {
+          A.push(...this._findMatches({
+            key: m,
+            value: o[D],
+            searcher: p
+          }));
+        })) : A = this._findMatches({
+          key: this._keyStore.get(a),
+          value: this._myIndex.getValueForItemAtKeyId(o, a),
+          searcher: p
+        }), A && A.length ? [{
+          idx: l,
+          item: o,
+          matches: A
+        }] : [];
+      }
+      const {
+        children: u,
+        operator: f
+      } = h, d = [];
+      for (let a = 0, p = u.length; a < p; a += 1) {
+        const A = u[a], m = n(A, o, l);
+        if (m.length)
+          d.push(...m);
+        else if (f === P.AND)
+          return [];
+      }
+      return d;
+    }, i = this._myIndex.records, r = /* @__PURE__ */ new Map(), c = [];
+    return i.forEach(({
+      $: h,
+      i: o
+    }) => {
+      if (M(h)) {
+        const l = n(t, h, o);
+        l.length && (r.has(o) || (r.set(o, {
+          idx: o,
+          item: h,
+          matches: []
+        }), c.push(r.get(o))), l.forEach(({
+          matches: u
+        }) => {
+          r.get(o).matches.push(...u);
+        }));
+      }
+    }), c;
+  }
+  // When a search involves inverse patterns (e.g. !Syrup), the aggregation
+  // across keys switches from "ANY key matches" to "ALL keys must match."
+  // This is signaled by hasInverse on the SearchResult from ExtendedSearch.
+  //
+  // For mixed patterns like "^hello !Syrup", a key failure is ambiguous —
+  // it could be the positive or inverse term that failed. In that case we
+  // conservatively exclude the item, which is strictly better than the old
+  // behavior of including it. See: https://github.com/krisk/Fuse/issues/712
+  _searchObjectList(e, {
+    heap: t,
+    ignoreFieldNorm: n
+  } = {}) {
+    const i = this._getSearcher(e), {
+      keys: r,
+      records: c
+    } = this._myIndex, h = t ? null : [];
+    return c.forEach(({
+      $: o,
+      i: l
+    }) => {
+      if (!M(o))
+        return;
+      const u = [];
+      let f = !1, d = !1;
+      if (r.forEach((a, p) => {
+        const A = this._findMatches({
+          key: a,
+          value: o[p],
+          searcher: i
+        });
+        A.length ? (u.push(...A), A[0].hasInverse && (d = !0)) : f = !0;
+      }), !(d && f) && u.length) {
+        const a = {
+          idx: l,
+          item: o,
+          matches: u
+        };
+        t ? (a.score = V(a.matches, {
+          ignoreFieldNorm: n
+        }), t.shouldInsert(a.score) && t.insert(a)) : h.push(a);
+      }
+    }), h;
+  }
+  _findMatches({
+    key: e,
+    value: t,
+    searcher: n
+  }) {
+    if (!M(t))
+      return [];
+    const i = [];
+    if (y(t))
+      t.forEach(({
+        v: r,
+        i: c,
+        n: h
+      }) => {
+        if (!M(r))
+          return;
+        const {
+          isMatch: o,
+          score: l,
+          indices: u,
+          hasInverse: f
+        } = n.searchIn(r);
+        o && i.push({
+          score: l,
+          key: e,
+          value: r,
+          idx: c,
+          norm: h,
+          indices: u,
+          hasInverse: f
+        });
+      });
+    else {
+      const {
+        v: r,
+        n: c
+      } = t, {
+        isMatch: h,
+        score: o,
+        indices: l,
+        hasInverse: u
+      } = n.searchIn(r);
+      h && i.push({
+        score: o,
+        key: e,
+        value: r,
+        norm: c,
+        indices: l,
+        hasInverse: u
+      });
+    }
+    return i;
+  }
+}
+class ct {
+  static condition(e, t) {
+    return t.useTokenSearch;
+  }
+  constructor(e, t) {
+    this.options = t, this.analyzer = J({
+      isCaseSensitive: t.isCaseSensitive,
+      ignoreDiacritics: t.ignoreDiacritics
+    });
+    const n = this.analyzer.tokenize(e), i = t._invertedIndex, {
+      df: r,
+      fieldCount: c
+    } = i;
+    this.termSearchers = [], this.idfWeights = [];
+    for (const h of n) {
+      this.termSearchers.push(new q(h, {
+        location: t.location,
+        threshold: t.threshold,
+        distance: t.distance,
+        includeMatches: t.includeMatches,
+        findAllMatches: t.findAllMatches,
+        minMatchCharLength: t.minMatchCharLength,
+        isCaseSensitive: t.isCaseSensitive,
+        ignoreDiacritics: t.ignoreDiacritics,
+        ignoreLocation: !0
+      }));
+      const o = r.get(h) || 0, l = Math.log(1 + (c - o + 0.5) / (o + 0.5));
+      this.idfWeights.push(l);
+    }
+  }
+  searchIn(e) {
+    if (!this.termSearchers.length)
+      return {
+        isMatch: !1,
+        score: 1
+      };
+    const t = [];
+    let n = 0, i = 0, r = 0;
+    for (let o = 0; o < this.termSearchers.length; o++) {
+      const l = this.termSearchers[o].searchIn(e), u = this.idfWeights[o];
+      i += u, l.isMatch && (r++, n += u * (1 - l.score), l.indices && t.push(...l.indices));
+    }
+    if (r === 0)
+      return {
+        isMatch: !1,
+        score: 1
+      };
+    const c = i > 0 ? 1 - n / i : 0, h = {
+      isMatch: !0,
+      score: Math.max(1e-3, c)
+    };
+    return this.options.includeMatches && t.length && (h.indices = Z(t)), h;
+  }
+}
+w.version = "7.3.0";
+w.createIndex = le;
+w.parseIndex = Le;
+w.config = g;
+w.match = function(s, e, t) {
+  return z(s, {
+    ...g,
+    ...t
+  }).searchIn(e);
+};
+w.parseQuery = Ae;
+ee(Ve);
+ee(ct);
+w.use = function(...s) {
+  s.forEach((e) => ee(e));
+};
+export {
+  w as F
+};