reg-cli 0.19.0-rc0 → 0.19.0-rc2

package/dist/shared/report-worker.js

@@ -4,12 +4,8 @@
     return !Array.isArray ? getTag(value) === "[object Array]" : Array.isArray(value);
   }
   function baseToString(value) {
-    if (typeof value == "string") {
-      return value;
-    }
-    if (typeof value === "bigint") {
-      return value.toString();
-    }
+    if (typeof value == "string") return value;
+    if (typeof value === "bigint") return value.toString();
     const result = value + "";
     return result == "0" && 1 / value == -Infinity ? "-0" : result;
   }
@@ -41,12 +37,14 @@
     return value == null ? value === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(value);
   }
   const INCORRECT_INDEX_TYPE = "Incorrect 'index' type";
+  const INVALID_DOC_INDEX = "Invalid doc index: must be a non-negative integer within the bounds of the docs array";
   const LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = (key) => `Invalid value for key ${key}`;
   const PATTERN_LENGTH_TOO_LARGE = (max) => `Pattern length exceeds max of ${max}.`;
   const MISSING_KEY_PROPERTY = (name) => `Missing ${name} property in key`;
   const INVALID_KEY_WEIGHT_VALUE = (key) => `Property 'weight' in key '${key}' must be a positive integer`;
+  const FUSE_MATCH_TOKEN_SEARCH_UNSUPPORTED = "Fuse.match does not support useTokenSearch: token search requires corpus-level statistics (df, fieldCount) that a one-off string comparison does not have. Use new Fuse(...).search(...) instead.";
   const hasOwn = Object.prototype.hasOwnProperty;
-  class KeyStore {
+  var KeyStore = class {
     constructor(keys) {
       this._keys = [];
       this._keyMap = {};
@@ -70,7 +68,7 @@
     toJSON() {
       return JSON.stringify(this._keys);
     }
-  }
+  };
   function createKey(key) {
     let path = null;
     let id = null;
@@ -82,20 +80,16 @@
       path = createKeyPath(key);
       id = createKeyId(key);
     } else {
-      if (!hasOwn.call(key, "name")) {
-        throw new Error(MISSING_KEY_PROPERTY("name"));
-      }
+      if (!hasOwn.call(key, "name")) throw new Error(MISSING_KEY_PROPERTY("name"));
       const name = key.name;
       src = name;
-      if (hasOwn.call(key, "weight")) {
+      if (hasOwn.call(key, "weight") && key.weight !== void 0) {
         weight = key.weight;
-        if (weight <= 0) {
-          throw new Error(INVALID_KEY_WEIGHT_VALUE(name));
-        }
+        if (weight <= 0) throw new Error(INVALID_KEY_WEIGHT_VALUE(createKeyId(name)));
       }
       path = createKeyPath(name);
       id = createKeyId(name);
-      getFn = key.getFn;
+      getFn = key.getFn ?? null;
     }
     return {
       path,
@@ -115,33 +109,22 @@
     const list = [];
     let arr = false;
     const deepGet = (obj2, path2, index, arrayIndex) => {
-      if (!isDefined(obj2)) {
-        return;
-      }
-      if (!path2[index]) {
-        list.push(arrayIndex !== void 0 ? {
-          v: obj2,
+      if (!isDefined(obj2)) return;
+      if (!path2[index]) list.push(arrayIndex !== void 0 ? {
+        v: obj2,
+        i: arrayIndex
+      } : obj2);
+      else {
+        const value = obj2[path2[index]];
+        if (!isDefined(value)) return;
+        if (index === path2.length - 1 && (isString(value) || isNumber(value) || isBoolean(value) || typeof value === "bigint")) list.push(arrayIndex !== void 0 ? {
+          v: toString(value),
           i: arrayIndex
-        } : obj2);
-      } else {
-        const key = path2[index];
-        const value = obj2[key];
-        if (!isDefined(value)) {
-          return;
-        }
-        if (index === path2.length - 1 && (isString(value) || isNumber(value) || isBoolean(value) || typeof value === "bigint")) {
-          list.push(arrayIndex !== void 0 ? {
-            v: toString(value),
-            i: arrayIndex
-          } : toString(value));
-        } else if (isArray(value)) {
+        } : toString(value));
+        else if (isArray(value)) {
           arr = true;
-          for (let i = 0, len = value.length; i < len; i += 1) {
-            deepGet(value[i], path2, index + 1, i);
-          }
-        } else if (path2.length) {
-          deepGet(value, path2, index + 1, arrayIndex);
-        }
+          for (let i = 0, len = value.length; i < len; i += 1) deepGet(value[i], path2, index + 1, i);
+        } else if (path2.length) deepGet(value, path2, index + 1, arrayIndex);
       }
     };
     deepGet(obj, isString(path) ? path.split(".") : path, 0);
@@ -168,6 +151,8 @@
   const AdvancedOptions = {
     useExtendedSearch: false,
     useTokenSearch: false,
+    tokenize: void 0,
+    tokenMatch: "any",
     getFn: get,
     ignoreLocation: false,
     ignoreFieldNorm: false,
@@ -179,18 +164,25 @@
     ...FuzzyOptions,
     ...AdvancedOptions
   });
-  const SPACE = /[^ ]+/g;
+  function isWordSeparator(code) {
+    return code >= 9 && code <= 13 || code === 32 || code === 160;
+  }
   function norm(weight = 1, mantissa = 3) {
     const cache = /* @__PURE__ */ new Map();
     const m = Math.pow(10, mantissa);
     return {
       get(value) {
-        const numTokens = value.match(SPACE).length;
-        if (cache.has(numTokens)) {
-          return cache.get(numTokens);
-        }
-        const norm2 = 1 / Math.pow(numTokens, 0.5 * weight);
-        const n = parseFloat(Math.round(norm2 * m) / m);
+        let numTokens = 0;
+        let inWord = false;
+        for (let i = 0; i < value.length; i++) if (!isWordSeparator(value.charCodeAt(i))) {
+          if (!inWord) {
+            numTokens++;
+            inWord = true;
+          }
+        } else inWord = false;
+        if (numTokens === 0) numTokens = 1;
+        if (cache.has(numTokens)) return cache.get(numTokens);
+        const n = Math.round(m / Math.pow(numTokens, 0.5 * weight)) / m;
         cache.set(numTokens, n);
         return n;
       },
@@ -199,11 +191,8 @@
       }
     };
   }
-  class FuseIndex {
-    constructor({
-      getFn = Config.getFn,
-      fieldNormWeight = Config.fieldNormWeight
-    } = {}) {
+  var FuseIndex = class {
+    constructor({ getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}) {
       this.norm = norm(fieldNormWeight, 3);
       this.getFn = getFn;
       this.isCreated = false;
@@ -226,44 +215,53 @@
       });
     }
     create() {
-      if (this.isCreated || !this.docs.length) {
-        return;
-      }
+      if (this.isCreated || !this.docs.length) return;
       this.isCreated = true;
-      if (isString(this.docs[0])) {
-        this.docs.forEach((doc, docIndex) => {
-          this._addString(doc, docIndex);
-        });
-      } else {
-        this.docs.forEach((doc, docIndex) => {
-          this._addObject(doc, docIndex);
-        });
-      }
+      const len = this.docs.length;
+      this.records = new Array(len);
+      let recordCount = 0;
+      if (isString(this.docs[0])) for (let i = 0; i < len; i++) {
+        const record = this._createStringRecord(this.docs[i], i);
+        if (record) this.records[recordCount++] = record;
+      }
+      else for (let i = 0; i < len; i++) this.records[recordCount++] = this._createObjectRecord(this.docs[i], i);
+      this.records.length = recordCount;
       this.norm.clear();
     }
-    // Adds a doc to the end of the index
-    add(doc) {
-      const idx = this.size();
+    add(doc, docIndex) {
+      if (!Number.isInteger(docIndex) || docIndex < 0) throw new Error(INVALID_DOC_INDEX);
       if (isString(doc)) {
-        this._addString(doc, idx);
-      } else {
-        this._addObject(doc, idx);
+        const record2 = this._createStringRecord(doc, docIndex);
+        if (record2) this.records.push(record2);
+        return record2;
       }
+      const record = this._createObjectRecord(doc, docIndex);
+      this.records.push(record);
+      return record;
     }
-    // Removes the doc at the specified index of the index
     removeAt(idx) {
-      this.records.splice(idx, 1);
-      for (let i = idx, len = this.size(); i < len; i += 1) {
-        this.records[i].i -= 1;
+      if (!Number.isInteger(idx) || idx < 0) throw new Error(INVALID_DOC_INDEX);
+      for (let i = 0, len = this.records.length; i < len; i += 1) if (this.records[i].i === idx) {
+        this.records.splice(i, 1);
+        break;
       }
+      for (let i = 0, len = this.records.length; i < len; i += 1) if (this.records[i].i > idx) this.records[i].i -= 1;
     }
-    // Removes docs at the specified indices (must be sorted ascending)
     removeAll(indices) {
-      for (let i = indices.length - 1; i >= 0; i -= 1) {
-        this.records.splice(indices[i], 1);
-      }
-      for (let i = 0, len = this.records.length; i < len; i += 1) {
-        this.records[i].i = i;
+      const toRemove = /* @__PURE__ */ new Set();
+      for (const v of indices) if (Number.isInteger(v) && v >= 0) toRemove.add(v);
+      if (toRemove.size === 0) return;
+      this.records = this.records.filter((r) => !toRemove.has(r.i));
+      const sorted = Array.from(toRemove).sort((a, b) => a - b);
+      for (const record of this.records) {
+        let lo = 0;
+        let hi = sorted.length;
+        while (lo < hi) {
+          const mid = lo + hi >>> 1;
+          if (sorted[mid] < record.i) lo = mid + 1;
+          else hi = mid;
+        }
+        record.i -= lo;
       }
     }
     getValueForItemAtKeyId(item, keyId) {
@@ -272,34 +270,28 @@
     size() {
       return this.records.length;
     }
-    _addString(doc, docIndex) {
-      if (!isDefined(doc) || isBlank(doc)) {
-        return;
-      }
-      const record = {
+    _createStringRecord(doc, docIndex) {
+      if (!isDefined(doc) || isBlank(doc)) return null;
+      return {
         v: doc,
         i: docIndex,
         n: this.norm.get(doc)
       };
-      this.records.push(record);
     }
-    _addObject(doc, docIndex) {
+    _createObjectRecord(doc, docIndex) {
       const record = {
         i: docIndex,
         $: {}
       };
-      this.keys.forEach((key, keyIndex) => {
+      for (let keyIndex = 0, keyLen = this.keys.length; keyIndex < keyLen; keyIndex++) {
+        const key = this.keys[keyIndex];
         const value = key.getFn ? key.getFn(doc) : this.getFn(doc, key.path);
-        if (!isDefined(value)) {
-          return;
-        }
+        if (!isDefined(value)) continue;
         if (isArray(value)) {
           const subRecords = [];
           for (let i = 0, len = value.length; i < len; i += 1) {
             const item = value[i];
-            if (!isDefined(item)) {
-              continue;
-            }
+            if (!isDefined(item)) continue;
             if (isString(item)) {
               if (!isBlank(item)) {
                 const subRecord = {
@@ -329,24 +321,17 @@
           };
           record.$[keyIndex] = subRecord;
         }
-      });
-      this.records.push(record);
+      }
+      return record;
     }
     toJSON() {
       return {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        keys: this.keys.map(({
-          getFn,
-          ...key
-        }) => key),
+        keys: this.keys.map(({ getFn, ...key }) => key),
         records: this.records
       };
     }
-  }
-  function createIndex(keys, docs, {
-    getFn = Config.getFn,
-    fieldNormWeight = Config.fieldNormWeight
-  } = {}) {
+  };
+  function createIndex(keys, docs, { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}) {
     const myIndex = new FuseIndex({
       getFn,
       fieldNormWeight
@@ -356,14 +341,8 @@
     myIndex.create();
     return myIndex;
   }
-  function parseIndex(data, {
-    getFn = Config.getFn,
-    fieldNormWeight = Config.fieldNormWeight
-  } = {}) {
-    const {
-      keys,
-      records
-    } = data;
+  function parseIndex(data, { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}) {
+    const { keys, records } = data;
     const myIndex = new FuseIndex({
       getFn,
       fieldNormWeight
@@ -379,34 +358,18 @@
     let i = 0;
     for (let len = matchmask.length; i < len; i += 1) {
       const match = matchmask[i];
-      if (match && start === -1) {
-        start = i;
-      } else if (!match && start !== -1) {
+      if (match && start === -1) start = i;
+      else if (!match && start !== -1) {
         end = i - 1;
-        if (end - start + 1 >= minMatchCharLength) {
-          indices.push([start, end]);
-        }
+        if (end - start + 1 >= minMatchCharLength) indices.push([start, end]);
         start = -1;
       }
     }
-    if (matchmask[i - 1] && i - start >= minMatchCharLength) {
-      indices.push([start, i - 1]);
-    }
+    if (matchmask[i - 1] && i - start >= minMatchCharLength) indices.push([start, i - 1]);
     return indices;
   }
-  const MAX_BITS = 32;
-  function search(text, pattern, patternAlphabet, {
-    location = Config.location,
-    distance = Config.distance,
-    threshold = Config.threshold,
-    findAllMatches = Config.findAllMatches,
-    minMatchCharLength = Config.minMatchCharLength,
-    includeMatches = Config.includeMatches,
-    ignoreLocation = Config.ignoreLocation
-  } = {}) {
-    if (pattern.length > MAX_BITS) {
-      throw new Error(PATTERN_LENGTH_TOO_LARGE(MAX_BITS));
-    }
+  function search(text, pattern, patternAlphabet, { location = Config.location, distance = Config.distance, threshold = Config.threshold, findAllMatches = Config.findAllMatches, minMatchCharLength = Config.minMatchCharLength, includeMatches = Config.includeMatches, ignoreLocation = Config.ignoreLocation } = {}) {
+    if (pattern.length > 32) throw new Error(PATTERN_LENGTH_TOO_LARGE(32));
     const patternLen = pattern.length;
     const textLen = text.length;
     const expectedLocation = Math.max(0, Math.min(location, textLen));
@@ -437,18 +400,15 @@
     bestLocation = -1;
     let lastBitArr = [];
     let finalScore = 1;
+    let bestErrors = 0;
     let binMax = patternLen + textLen;
     const mask = 1 << patternLen - 1;
     for (let i = 0; i < patternLen; i += 1) {
       let binMin = 0;
       let binMid = binMax;
       while (binMin < binMid) {
-        const score2 = calcScore(i, expectedLocation + binMid);
-        if (score2 <= currentThreshold) {
-          binMin = binMid;
-        } else {
-          binMax = binMid;
-        }
+        if (calcScore(i, expectedLocation + binMid) <= currentThreshold) binMin = binMid;
+        else binMax = binMid;
         binMid = Math.floor((binMax - binMin) / 2 + binMin);
       }
       binMax = binMid;
@@ -459,43 +419,34 @@
       for (let j = finish; j >= start; j -= 1) {
         const currentLocation = j - 1;
         const charMatch = patternAlphabet[text[currentLocation]];
-        if (computeMatches) {
-          matchMask[currentLocation] = +!!charMatch;
-        }
         bitArr[j] = (bitArr[j + 1] << 1 | 1) & charMatch;
-        if (i) {
-          bitArr[j] |= (lastBitArr[j + 1] | lastBitArr[j]) << 1 | 1 | lastBitArr[j + 1];
-        }
+        if (i) bitArr[j] |= (lastBitArr[j + 1] | lastBitArr[j]) << 1 | 1 | lastBitArr[j + 1];
         if (bitArr[j] & mask) {
           finalScore = calcScore(i, currentLocation);
           if (finalScore <= currentThreshold) {
             currentThreshold = finalScore;
             bestLocation = currentLocation;
-            if (bestLocation <= expectedLocation) {
-              break;
-            }
+            bestErrors = i;
+            if (bestLocation <= expectedLocation) break;
             start = Math.max(1, 2 * expectedLocation - bestLocation);
           }
         }
       }
-      const score = calcScore(i + 1, expectedLocation);
-      if (score > currentThreshold) {
-        break;
-      }
+      if (calcScore(i + 1, expectedLocation) > currentThreshold) break;
       lastBitArr = bitArr;
     }
+    if (computeMatches && bestLocation >= 0) {
+      const matchEnd = Math.min(textLen - 1, bestLocation + patternLen - 1 + bestErrors);
+      for (let k = bestLocation; k <= matchEnd; k += 1) if (patternAlphabet[text[k]]) matchMask[k] = 1;
+    }
     const result = {
       isMatch: bestLocation >= 0,
-      // Count exact matches (those with a score of 0) to be "almost" exact
       score: Math.max(1e-3, finalScore)
     };
     if (computeMatches) {
       const indices = convertMaskToIndices(matchMask, minMatchCharLength);
-      if (!indices.length) {
-        result.isMatch = false;
-      } else if (includeMatches) {
-        result.indices = indices;
-      }
+      if (!indices.length) result.isMatch = false;
+      else if (includeMatches) result.indices = indices;
     }
     return result;
   }
@@ -514,54 +465,29 @@
     for (let i = 1, len = indices.length; i < len; i += 1) {
       const last = merged[merged.length - 1];
       const curr = indices[i];
-      if (curr[0] <= last[1] + 1) {
-        last[1] = Math.max(last[1], curr[1]);
-      } else {
-        merged.push(curr);
-      }
+      if (curr[0] <= last[1] + 1) last[1] = Math.max(last[1], curr[1]);
+      else merged.push(curr);
     }
     return merged;
   }
   const NON_DECOMPOSABLE_MAP = {
     "ł": "l",
-    // ł
     "Ł": "L",
-    // Ł
     "đ": "d",
-    // đ
     "Đ": "D",
-    // Đ
     "ø": "o",
-    // ø
     "Ø": "O",
-    // Ø
     "ħ": "h",
-    // ħ
     "Ħ": "H",
-    // Ħ
     "ŧ": "t",
-    // ŧ
     "Ŧ": "T",
-    // Ŧ
     "ı": "i",
-    // ı
     "ß": "ss"
-    // ß
   };
   const NON_DECOMPOSABLE_RE = new RegExp("[" + Object.keys(NON_DECOMPOSABLE_MAP).join("") + "]", "g");
-  const stripDiacritics = String.prototype.normalize ? (str) => str.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(NON_DECOMPOSABLE_RE, (ch) => NON_DECOMPOSABLE_MAP[ch]) : (str) => str;
-  class BitapSearch {
-    constructor(pattern, {
-      location = Config.location,
-      threshold = Config.threshold,
-      distance = Config.distance,
-      includeMatches = Config.includeMatches,
-      findAllMatches = Config.findAllMatches,
-      minMatchCharLength = Config.minMatchCharLength,
-      isCaseSensitive = Config.isCaseSensitive,
-      ignoreDiacritics = Config.ignoreDiacritics,
-      ignoreLocation = Config.ignoreLocation
-    } = {}) {
+  const stripDiacritics = typeof String.prototype.normalize === "function" ? (str) => str.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(NON_DECOMPOSABLE_RE, (ch) => NON_DECOMPOSABLE_MAP[ch]) : (str) => str;
+  var BitapSearch = class {
+    constructor(pattern, { location = Config.location, threshold = Config.threshold, distance = Config.distance, includeMatches = Config.includeMatches, findAllMatches = Config.findAllMatches, minMatchCharLength = Config.minMatchCharLength, isCaseSensitive = Config.isCaseSensitive, ignoreDiacritics = Config.ignoreDiacritics, ignoreLocation = Config.ignoreLocation } = {}) {
       this.options = {
         location,
         threshold,
@@ -577,9 +503,7 @@
       pattern = ignoreDiacritics ? stripDiacritics(pattern) : pattern;
       this.pattern = pattern;
       this.chunks = [];
-      if (!this.pattern.length) {
-        return;
-      }
+      if (!this.pattern.length) return;
       const addChunk = (pattern2, startIndex) => {
         this.chunks.push({
           pattern: pattern2,
@@ -588,61 +512,42 @@
         });
       };
       const len = this.pattern.length;
-      if (len > MAX_BITS) {
+      if (len > 32) {
         let i = 0;
-        const remainder = len % MAX_BITS;
+        const remainder = len % 32;
         const end = len - remainder;
         while (i < end) {
-          addChunk(this.pattern.substr(i, MAX_BITS), i);
-          i += MAX_BITS;
+          addChunk(this.pattern.substr(i, 32), i);
+          i += 32;
         }
         if (remainder) {
-          const startIndex = len - MAX_BITS;
+          const startIndex = len - 32;
           addChunk(this.pattern.substr(startIndex), startIndex);
         }
-      } else {
-        addChunk(this.pattern, 0);
-      }
+      } else addChunk(this.pattern, 0);
     }
     searchIn(text) {
-      const {
-        isCaseSensitive,
-        ignoreDiacritics,
-        includeMatches
-      } = this.options;
+      const { isCaseSensitive, ignoreDiacritics, includeMatches } = this.options;
       text = isCaseSensitive ? text : text.toLowerCase();
       text = ignoreDiacritics ? stripDiacritics(text) : text;
       if (this.pattern === text) {
+        if (text.length < this.options.minMatchCharLength) return {
+          isMatch: false,
+          score: 1
+        };
         const result2 = {
           isMatch: true,
           score: 0
         };
-        if (includeMatches) {
-          result2.indices = [[0, text.length - 1]];
-        }
+        if (includeMatches) result2.indices = [[0, text.length - 1]];
         return result2;
       }
-      const {
-        location,
-        distance,
-        threshold,
-        findAllMatches,
-        minMatchCharLength,
-        ignoreLocation
-      } = this.options;
+      const { location, distance, threshold, findAllMatches, minMatchCharLength, ignoreLocation } = this.options;
       const allIndices = [];
       let totalScore = 0;
       let hasMatches = false;
-      this.chunks.forEach(({
-        pattern,
-        alphabet,
-        startIndex
-      }) => {
-        const {
-          isMatch,
-          score,
-          indices
-        } = search(text, pattern, alphabet, {
+      this.chunks.forEach(({ pattern, alphabet, startIndex }) => {
+        const { isMatch, score, indices } = search(text, pattern, alphabet, {
           location: location + startIndex,
           distance,
           threshold,
@@ -651,249 +556,169 @@
           includeMatches,
           ignoreLocation
         });
-        if (isMatch) {
-          hasMatches = true;
-        }
+        if (isMatch) hasMatches = true;
         totalScore += score;
-        if (isMatch && indices) {
-          allIndices.push(...indices);
-        }
+        if (isMatch && indices) allIndices.push(...indices);
       });
       const result = {
         isMatch: hasMatches,
         score: hasMatches ? totalScore / this.chunks.length : 1
       };
-      if (hasMatches && includeMatches) {
-        result.indices = mergeIndices(allIndices);
-      }
+      if (hasMatches && includeMatches) result.indices = mergeIndices(allIndices);
       return result;
     }
+  };
+  const MULTI_MATCH_TYPES = /* @__PURE__ */ new Set(["fuzzy", "include"]);
+  function isInverse(type) {
+    return type.startsWith("inverse");
   }
-  class BaseMatch {
-    constructor(pattern) {
-      this.pattern = pattern;
-    }
-    static isMultiMatch(pattern) {
-      return getMatch(pattern, this.multiRegex);
-    }
-    static isSingleMatch(pattern) {
-      return getMatch(pattern, this.singleRegex);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    search(_text) {
-      return {
-        isMatch: false,
-        score: 1
-      };
-    }
-  }
-  function getMatch(pattern, exp) {
-    const matches = pattern.match(exp);
-    return matches ? matches[1] : null;
-  }
-  class ExactMatch extends BaseMatch {
-    constructor(pattern) {
-      super(pattern);
-    }
-    static get type() {
-      return "exact";
-    }
-    static get multiRegex() {
-      return /^="(.*)"$/;
-    }
-    static get singleRegex() {
-      return /^=(.*)$/;
-    }
-    search(text) {
-      const isMatch = text === this.pattern;
-      return {
-        isMatch,
-        score: isMatch ? 0 : 1,
-        indices: [0, this.pattern.length - 1]
-      };
-    }
-  }
-  class InverseExactMatch extends BaseMatch {
-    constructor(pattern) {
-      super(pattern);
-    }
-    static get type() {
-      return "inverse-exact";
-    }
-    static get multiRegex() {
-      return /^!"(.*)"$/;
-    }
-    static get singleRegex() {
-      return /^!(.*)$/;
-    }
-    search(text) {
-      const index = text.indexOf(this.pattern);
-      const isMatch = index === -1;
-      return {
-        isMatch,
-        score: isMatch ? 0 : 1,
-        indices: [0, text.length - 1]
-      };
-    }
-  }
-  class PrefixExactMatch extends BaseMatch {
-    constructor(pattern) {
-      super(pattern);
-    }
-    static get type() {
-      return "prefix-exact";
-    }
-    static get multiRegex() {
-      return /^\^"(.*)"$/;
-    }
-    static get singleRegex() {
-      return /^\^(.*)$/;
-    }
-    search(text) {
-      const isMatch = text.startsWith(this.pattern);
-      return {
-        isMatch,
-        score: isMatch ? 0 : 1,
-        indices: [0, this.pattern.length - 1]
-      };
-    }
-  }
-  class InversePrefixExactMatch extends BaseMatch {
-    constructor(pattern) {
-      super(pattern);
-    }
-    static get type() {
-      return "inverse-prefix-exact";
-    }
-    static get multiRegex() {
-      return /^!\^"(.*)"$/;
-    }
-    static get singleRegex() {
-      return /^!\^(.*)$/;
-    }
-    search(text) {
-      const isMatch = !text.startsWith(this.pattern);
-      return {
-        isMatch,
-        score: isMatch ? 0 : 1,
-        indices: [0, text.length - 1]
-      };
-    }
-  }
-  class SuffixExactMatch extends BaseMatch {
-    constructor(pattern) {
-      super(pattern);
-    }
-    static get type() {
-      return "suffix-exact";
-    }
-    static get multiRegex() {
-      return /^"(.*)"\$$/;
-    }
-    static get singleRegex() {
-      return /^(.*)\$$/;
-    }
-    search(text) {
-      const isMatch = text.endsWith(this.pattern);
-      return {
-        isMatch,
-        score: isMatch ? 0 : 1,
-        indices: [text.length - this.pattern.length, text.length - 1]
-      };
-    }
-  }
-  class InverseSuffixExactMatch extends BaseMatch {
-    constructor(pattern) {
-      super(pattern);
-    }
-    static get type() {
-      return "inverse-suffix-exact";
-    }
-    static get multiRegex() {
-      return /^!"(.*)"\$$/;
-    }
-    static get singleRegex() {
-      return /^!(.*)\$$/;
-    }
-    search(text) {
-      const isMatch = !text.endsWith(this.pattern);
-      return {
-        isMatch,
-        score: isMatch ? 0 : 1,
-        indices: [0, text.length - 1]
-      };
-    }
-  }
-  class FuzzyMatch extends BaseMatch {
-    constructor(pattern, {
-      location = Config.location,
-      threshold = Config.threshold,
-      distance = Config.distance,
-      includeMatches = Config.includeMatches,
-      findAllMatches = Config.findAllMatches,
-      minMatchCharLength = Config.minMatchCharLength,
-      isCaseSensitive = Config.isCaseSensitive,
-      ignoreDiacritics = Config.ignoreDiacritics,
-      ignoreLocation = Config.ignoreLocation
-    } = {}) {
-      super(pattern);
-      this._bitapSearch = new BitapSearch(pattern, {
-        location,
-        threshold,
-        distance,
-        includeMatches,
-        findAllMatches,
-        minMatchCharLength,
-        isCaseSensitive,
-        ignoreDiacritics,
-        ignoreLocation
-      });
-    }
-    static get type() {
-      return "fuzzy";
-    }
-    static get multiRegex() {
-      return /^"(.*)"$/;
-    }
-    static get singleRegex() {
-      return /^(.*)$/;
-    }
-    search(text) {
-      return this._bitapSearch.searchIn(text);
-    }
-  }
-  class IncludeMatch extends BaseMatch {
-    constructor(pattern) {
-      super(pattern);
-    }
-    static get type() {
-      return "include";
-    }
-    static get multiRegex() {
-      return /^'"(.*)"$/;
-    }
-    static get singleRegex() {
-      return /^'(.*)$/;
-    }
-    search(text) {
-      let location = 0;
-      let index;
-      const indices = [];
-      const patternLen = this.pattern.length;
-      while ((index = text.indexOf(this.pattern, location)) > -1) {
-        location = index + patternLen;
-        indices.push([index, location - 1]);
+  const matchers = [
+    {
+      type: "exact",
+      multiRegex: /^="(.*)"$/,
+      singleRegex: /^=(.*)$/,
+      create: (pattern) => ({
+        type: "exact",
+        search(text) {
+          const isMatch = text === pattern;
+          return {
+            isMatch,
+            score: isMatch ? 0 : 1,
+            indices: [0, pattern.length - 1]
+          };
+        }
+      })
+    },
+    {
+      type: "include",
+      multiRegex: /^'"(.*)"$/,
+      singleRegex: /^'(.*)$/,
+      create: (pattern) => ({
+        type: "include",
+        search(text) {
+          let location = 0;
+          let index;
+          const indices = [];
+          const patternLen = pattern.length;
+          while ((index = text.indexOf(pattern, location)) > -1) {
+            location = index + patternLen;
+            indices.push([index, location - 1]);
+          }
+          const isMatch = !!indices.length;
+          return {
+            isMatch,
+            score: isMatch ? 0 : 1,
+            indices
+          };
+        }
+      })
+    },
+    {
+      type: "prefix-exact",
+      multiRegex: /^\^"(.*)"$/,
+      singleRegex: /^\^(.*)$/,
+      create: (pattern) => ({
+        type: "prefix-exact",
+        search(text) {
+          const isMatch = text.startsWith(pattern);
+          return {
+            isMatch,
+            score: isMatch ? 0 : 1,
+            indices: [0, pattern.length - 1]
+          };
+        }
+      })
+    },
+    {
+      type: "inverse-prefix-exact",
+      multiRegex: /^!\^"(.*)"$/,
+      singleRegex: /^!\^(.*)$/,
+      create: (pattern) => ({
+        type: "inverse-prefix-exact",
+        search(text) {
+          const isMatch = !text.startsWith(pattern);
+          return {
+            isMatch,
+            score: isMatch ? 0 : 1,
+            indices: [0, text.length - 1]
+          };
+        }
+      })
+    },
+    {
+      type: "inverse-suffix-exact",
+      multiRegex: /^!"(.*)"\$$/,
+      singleRegex: /^!(.*)\$$/,
+      create: (pattern) => ({
+        type: "inverse-suffix-exact",
+        search(text) {
+          const isMatch = !text.endsWith(pattern);
+          return {
+            isMatch,
+            score: isMatch ? 0 : 1,
+            indices: [0, text.length - 1]
+          };
+        }
+      })
+    },
+    {
+      type: "suffix-exact",
+      multiRegex: /^"(.*)"\$$/,
+      singleRegex: /^(.*)\$$/,
+      create: (pattern) => ({
+        type: "suffix-exact",
+        search(text) {
+          const isMatch = text.endsWith(pattern);
+          return {
+            isMatch,
+            score: isMatch ? 0 : 1,
+            indices: [text.length - pattern.length, text.length - 1]
+          };
+        }
+      })
+    },
+    {
+      type: "inverse-exact",
+      multiRegex: /^!"(.*)"$/,
+      singleRegex: /^!(.*)$/,
+      create: (pattern) => ({
+        type: "inverse-exact",
+        search(text) {
+          const isMatch = text.indexOf(pattern) === -1;
+          return {
+            isMatch,
+            score: isMatch ? 0 : 1,
+            indices: [0, text.length - 1]
+          };
+        }
+      })
+    },
+    {
+      type: "fuzzy",
+      multiRegex: /^"(.*)"$/,
+      singleRegex: /^(.*)$/,
+      create: (pattern, options = {}) => {
+        const bitap = new BitapSearch(pattern, {
+          location: options.location ?? Config.location,
+          threshold: options.threshold ?? Config.threshold,
+          distance: options.distance ?? Config.distance,
+          includeMatches: options.includeMatches ?? Config.includeMatches,
+          findAllMatches: options.findAllMatches ?? Config.findAllMatches,
+          minMatchCharLength: options.minMatchCharLength ?? Config.minMatchCharLength,
+          isCaseSensitive: options.isCaseSensitive ?? Config.isCaseSensitive,
+          ignoreDiacritics: options.ignoreDiacritics ?? Config.ignoreDiacritics,
+          ignoreLocation: options.ignoreLocation ?? Config.ignoreLocation
+        });
+        return {
+          type: "fuzzy",
+          search(text) {
+            return bitap.searchIn(text);
+          }
+        };
       }
-      const isMatch = !!indices.length;
-      return {
-        isMatch,
-        score: isMatch ? 0 : 1,
-        indices
-      };
     }
-  }
-  const searchers = [ExactMatch, IncludeMatch, PrefixExactMatch, InversePrefixExactMatch, InverseSuffixExactMatch, SuffixExactMatch, InverseExactMatch, FuzzyMatch];
-  const searchersLen = searchers.length;
+  ];
+  const matchersLen = matchers.length;
   const ESCAPED_PIPE = "\0";
   const OR_TOKEN = "|";
   function tokenize(pattern) {
@@ -931,33 +756,33 @@
     }
     return tokens;
   }
+  function getMatch(pattern, exp) {
+    const matches = pattern.match(exp);
+    return matches ? matches[1] : null;
+  }
   function parseQuery(pattern, options = {}) {
-    const escaped = pattern.replace(/\\\|/g, ESCAPED_PIPE);
-    return escaped.split(OR_TOKEN).map((item) => {
-      const restored = item.replace(/\u0000/g, "|");
-      const query = tokenize(restored.trim()).filter((item2) => item2 && !!item2.trim());
+    return pattern.replace(/\\\|/g, ESCAPED_PIPE).split(OR_TOKEN).map((item) => {
+      const query = tokenize(item.replace(/\u0000/g, "|").trim()).filter((item2) => item2 && !!item2.trim());
       const results = [];
       for (let i = 0, len = query.length; i < len; i += 1) {
         const queryItem = query[i];
         let found = false;
         let idx = -1;
-        while (!found && ++idx < searchersLen) {
-          const searcher = searchers[idx];
-          const token = searcher.isMultiMatch(queryItem);
+        while (!found && ++idx < matchersLen) {
+          const def = matchers[idx];
+          const token = getMatch(queryItem, def.multiRegex);
           if (token) {
-            results.push(new searcher(token, options));
+            results.push(def.create(token, options));
             found = true;
           }
         }
-        if (found) {
-          continue;
-        }
+        if (found) continue;
         idx = -1;
-        while (++idx < searchersLen) {
-          const searcher = searchers[idx];
-          const token = searcher.isSingleMatch(queryItem);
+        while (++idx < matchersLen) {
+          const def = matchers[idx];
+          const token = getMatch(queryItem, def.singleRegex);
           if (token) {
-            results.push(new searcher(token, options));
+            results.push(def.create(token, options));
             break;
           }
         }
@@ -965,19 +790,8 @@
       return results;
     });
   }
-  const MultiMatchSet = /* @__PURE__ */ new Set([FuzzyMatch.type, IncludeMatch.type]);
-  class ExtendedSearch {
-    constructor(pattern, {
-      isCaseSensitive = Config.isCaseSensitive,
-      ignoreDiacritics = Config.ignoreDiacritics,
-      includeMatches = Config.includeMatches,
-      minMatchCharLength = Config.minMatchCharLength,
-      ignoreLocation = Config.ignoreLocation,
-      findAllMatches = Config.findAllMatches,
-      location = Config.location,
-      threshold = Config.threshold,
-      distance = Config.distance
-    } = {}) {
+  var ExtendedSearch = class {
+    constructor(pattern, { isCaseSensitive = Config.isCaseSensitive, ignoreDiacritics = Config.ignoreDiacritics, includeMatches = Config.includeMatches, minMatchCharLength = Config.minMatchCharLength, ignoreLocation = Config.ignoreLocation, findAllMatches = Config.findAllMatches, location = Config.location, threshold = Config.threshold, distance = Config.distance } = {}) {
       this.query = null;
       this.options = {
         isCaseSensitive,
@@ -998,22 +812,13 @@
     static condition(_, options) {
       return options.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(text) {
       const query = this.query;
-      if (!query) {
-        return {
-          isMatch: false,
-          score: 1
-        };
-      }
-      const {
-        includeMatches,
-        isCaseSensitive,
-        ignoreDiacritics
-      } = this.options;
+      if (!query) return {
+        isMatch: false,
+        score: 1
+      };
+      const { includeMatches, isCaseSensitive, ignoreDiacritics } = this.options;
       text = isCaseSensitive ? text : text.toLowerCase();
       text = ignoreDiacritics ? stripDiacritics(text) : text;
       let numMatches = 0;
@@ -1021,31 +826,19 @@
       let totalScore = 0;
       let hasInverse = false;
       for (let i = 0, qLen = query.length; i < qLen; i += 1) {
-        const searchers2 = query[i];
+        const searchers = query[i];
         allIndices.length = 0;
         numMatches = 0;
         hasInverse = false;
-        for (let j = 0, pLen = searchers2.length; j < pLen; j += 1) {
-          const searcher = searchers2[j];
-          const {
-            isMatch,
-            indices,
-            score
-          } = searcher.search(text);
+        for (let j = 0, pLen = searchers.length; j < pLen; j += 1) {
+          const matcher = searchers[j];
+          const { isMatch, indices, score } = matcher.search(text);
           if (isMatch) {
             numMatches += 1;
             totalScore += score;
-            const type = searcher.constructor.type;
-            if (type.startsWith("inverse")) {
-              hasInverse = true;
-            }
-            if (includeMatches) {
-              if (MultiMatchSet.has(type)) {
-                allIndices.push(...indices);
-              } else {
-                allIndices.push(indices);
-              }
-            }
+            if (isInverse(matcher.type)) hasInverse = true;
+            if (includeMatches) if (MULTI_MATCH_TYPES.has(matcher.type)) allIndices.push(...indices);
+            else allIndices.push(indices);
           } else {
             totalScore = 0;
             numMatches = 0;
@@ -1059,12 +852,8 @@
             isMatch: true,
             score: totalScore / numMatches
           };
-          if (hasInverse) {
-            result.hasInverse = true;
-          }
-          if (includeMatches) {
-            result.indices = mergeIndices(allIndices);
-          }
+          if (hasInverse) result.hasInverse = true;
+          if (includeMatches) result.indices = mergeIndices(allIndices);
           return result;
         }
       }
@@ -1073,7 +862,7 @@
         score: 1
       };
     }
-  }
+  };
   const registeredSearchers = [];
   function register(...args) {
     registeredSearchers.push(...args);
@@ -1081,9 +870,7 @@
   function createSearcher(pattern, options) {
     for (let i = 0, len = registeredSearchers.length; i < len; i += 1) {
       const searcherClass = registeredSearchers[i];
-      if (searcherClass.condition(pattern, options)) {
-        return new searcherClass(pattern, options);
-      }
+      if (searcherClass.condition(pattern, options)) return new searcherClass(pattern, options);
     }
     return new BitapSearch(pattern, options);
   }
@@ -1098,43 +885,29 @@
   const isExpression = (query) => !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]);
   const isPath = (query) => !!query[KeyType.PATH];
   const isLeaf = (query) => !isArray(query) && isObject(query) && !isExpression(query);
-  const convertToExplicit = (query) => ({
-    [LogicalOperator.AND]: Object.keys(query).map((key) => ({
-      [key]: query[key]
-    }))
-  });
-  function parse(query, options, {
-    auto = true
-  } = {}) {
+  const convertToExplicit = (query) => ({ [LogicalOperator.AND]: Object.keys(query).map((key) => ({ [key]: query[key] })) });
+  function parse(query, options, { auto = true } = {}) {
     const next = (query2) => {
       if (isString(query2)) {
         const obj = {
           keyId: null,
           pattern: query2
         };
-        if (auto) {
-          obj.searcher = createSearcher(query2, options);
-        }
+        if (auto) obj.searcher = createSearcher(query2, options);
         return obj;
       }
       const keys = Object.keys(query2);
       const isQueryPath = isPath(query2);
-      if (!isQueryPath && keys.length > 1 && !isExpression(query2)) {
-        return next(convertToExplicit(query2));
-      }
+      if (!isQueryPath && keys.length > 1 && !isExpression(query2)) return next(convertToExplicit(query2));
       if (isLeaf(query2)) {
         const key = isQueryPath ? query2[KeyType.PATH] : keys[0];
         const pattern = isQueryPath ? query2[KeyType.PATTERN] : query2[key];
-        if (!isString(pattern)) {
-          throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key));
-        }
+        if (!isString(pattern)) throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key));
         const obj = {
           keyId: createKeyId(key),
           pattern
         };
-        if (auto) {
-          obj.searcher = createSearcher(pattern, options);
-        }
+        if (auto) obj.searcher = createSearcher(pattern, options);
         return obj;
       }
       const node = {
@@ -1143,70 +916,54 @@
       };
       keys.forEach((key) => {
         const value = query2[key];
-        if (isArray(value)) {
-          value.forEach((item) => {
-            node.children.push(next(item));
-          });
-        }
+        if (isArray(value)) value.forEach((item) => {
+          node.children.push(next(item));
+        });
       });
       return node;
     };
-    if (!isExpression(query)) {
-      query = convertToExplicit(query);
-    }
+    if (!isExpression(query)) query = convertToExplicit(query);
     return next(query);
   }
-  function computeScoreSingle(matches, {
-    ignoreFieldNorm = Config.ignoreFieldNorm
-  }) {
+  function computeScoreSingle(matches, { ignoreFieldNorm = Config.ignoreFieldNorm }) {
     let totalScore = 1;
-    matches.forEach(({
-      key,
-      norm: norm2,
-      score
-    }) => {
+    matches.forEach(({ key, norm: norm2, score }) => {
       const weight = key ? key.weight : null;
       totalScore *= Math.pow(score === 0 && weight ? Number.EPSILON : score, (weight || 1) * (ignoreFieldNorm ? 1 : norm2));
     });
     return totalScore;
   }
-  function computeScore(results, {
-    ignoreFieldNorm = Config.ignoreFieldNorm
-  }) {
+  function computeScore(results, { ignoreFieldNorm = Config.ignoreFieldNorm }) {
     results.forEach((result) => {
-      result.score = computeScoreSingle(result.matches, {
-        ignoreFieldNorm
-      });
+      result.score = computeScoreSingle(result.matches, { ignoreFieldNorm });
     });
   }
-  class MaxHeap {
-    constructor(limit) {
+  var MaxHeap = class {
+    constructor(limit, comparator) {
       this.limit = limit;
       this.heap = [];
+      this.comparator = comparator;
     }
     get size() {
       return this.heap.length;
     }
-    shouldInsert(score) {
-      return this.size < this.limit || score < this.heap[0].score;
-    }
     insert(item) {
       if (this.size < this.limit) {
         this.heap.push(item);
         this._bubbleUp(this.size - 1);
-      } else if (item.score < this.heap[0].score) {
+      } else if (this.comparator(item, this.heap[0]) < 0) {
         this.heap[0] = item;
         this._sinkDown(0);
       }
     }
-    extractSorted(sortFn) {
-      return this.heap.sort(sortFn);
+    extractSorted() {
+      return this.heap.sort(this.comparator);
     }
     _bubbleUp(i) {
       const heap = this.heap;
       while (i > 0) {
         const parent = i - 1 >> 1;
-        if (heap[i].score <= heap[parent].score) break;
+        if (this.comparator(heap[i], heap[parent]) <= 0) break;
         const tmp = heap[i];
         heap[i] = heap[parent];
         heap[parent] = tmp;
@@ -1221,12 +978,8 @@
         i = largest;
         const left = 2 * i + 1;
         const right = 2 * i + 2;
-        if (left < len && heap[left].score > heap[largest].score) {
-          largest = left;
-        }
-        if (right < len && heap[right].score > heap[largest].score) {
-          largest = right;
-        }
+        if (left < len && this.comparator(heap[left], heap[largest]) > 0) largest = left;
+        if (right < len && this.comparator(heap[right], heap[largest]) > 0) largest = right;
         if (largest !== i) {
           const tmp = heap[i];
           heap[i] = heap[largest];
@@ -1234,201 +987,223 @@
         }
       } while (largest !== i);
     }
-  }
-  function transformMatches(result, data) {
-    const matches = result.matches;
-    data.matches = [];
-    if (!isDefined(matches)) {
-      return;
-    }
-    matches.forEach((match) => {
-      if (!isDefined(match.indices) || !match.indices.length) {
-        return;
-      }
-      const {
-        indices,
-        value
-      } = match;
+  };
+  function formatMatches(result) {
+    const matches = [];
+    result.matches.forEach((match) => {
+      if (!isDefined(match.indices) || !match.indices.length) return;
       const obj = {
-        indices,
-        value
+        indices: match.indices,
+        value: match.value
       };
-      if (match.key) {
-        obj.key = match.key.src;
-      }
-      if (match.idx > -1) {
-        obj.refIndex = match.idx;
-      }
-      data.matches.push(obj);
+      if (match.key) obj.key = match.key.id;
+      if (match.idx > -1) obj.refIndex = match.idx;
+      matches.push(obj);
     });
+    return matches;
   }
-  function transformScore(result, data) {
-    data.score = result.score;
-  }
-  function format(results, docs, {
-    includeMatches = Config.includeMatches,
-    includeScore = Config.includeScore
-  } = {}) {
-    const transformers = [];
-    if (includeMatches) transformers.push(transformMatches);
-    if (includeScore) transformers.push(transformScore);
+  function format(results, docs, { includeMatches = Config.includeMatches, includeScore = Config.includeScore } = {}) {
     return results.map((result) => {
-      const {
-        idx
-      } = result;
+      const { idx } = result;
       const data = {
         item: docs[idx],
         refIndex: idx
       };
-      if (transformers.length) {
-        transformers.forEach((transformer) => {
-          transformer(result, data);
-        });
-      }
+      if (includeMatches) data.matches = formatMatches(result);
+      if (includeScore) data.score = result.score;
       return data;
     });
   }
-  const WORD = /\b\w+\b/g;
-  function createAnalyzer({
-    isCaseSensitive = false,
-    ignoreDiacritics = false
-  } = {}) {
-    return {
-      tokenize(text) {
-        if (!isCaseSensitive) {
-          text = text.toLowerCase();
-        }
-        if (ignoreDiacritics) {
-          text = stripDiacritics(text);
-        }
-        return text.match(WORD) || [];
-      }
-    };
+  const DEFAULT_TOKEN = /[\p{L}\p{M}\p{N}_]+/gu;
+  const warned = /* @__PURE__ */ new WeakSet();
+  function warnNonGlobal(regex) {
+    if (!warned.has(regex)) {
+      warned.add(regex);
+      console.warn(`[Fuse] tokenize regex ${regex} lacks the global flag; only the first match per text will be returned. Add the 'g' flag.`);
+    }
   }
-  function buildInvertedIndex(records, keyCount, analyzer) {
-    const terms = /* @__PURE__ */ new Map();
-    const df = /* @__PURE__ */ new Map();
-    let fieldCount = 0;
-    function addField(text, docIdx, keyIdx, subIdx) {
-      const tokens = analyzer.tokenize(text);
-      if (!tokens.length) return;
-      fieldCount++;
-      const termFreqs = /* @__PURE__ */ new Map();
-      for (const token of tokens) {
-        termFreqs.set(token, (termFreqs.get(token) || 0) + 1);
-      }
-      for (const [term, tf] of termFreqs) {
-        const posting = {
-          docIdx,
-          keyIdx,
-          subIdx,
-          tf
-        };
-        let postings = terms.get(term);
-        if (!postings) {
-          postings = [];
-          terms.set(term, postings);
+  function resolveTokenize(tokenize2) {
+    if (typeof tokenize2 === "function") {
+      let validated = false;
+      return (text) => {
+        const result = tokenize2(text);
+        if (!validated) {
+          validated = true;
+          if (!Array.isArray(result) || result.some((t) => typeof t !== "string")) throw new Error(`[Fuse] tokenize function must return string[]; received ${Array.isArray(result) ? "array containing non-strings" : typeof result}.`);
         }
-        postings.push(posting);
-        df.set(term, (df.get(term) || 0) + 1);
-      }
+        return result;
+      };
     }
-    for (const record of records) {
-      const {
-        i: docIdx,
-        v,
-        $: fields
-      } = record;
-      if (v !== void 0) {
-        addField(v, docIdx, -1, -1);
-        continue;
-      }
-      if (fields) {
-        for (let keyIdx = 0; keyIdx < keyCount; keyIdx++) {
-          const value = fields[keyIdx];
-          if (!value) continue;
-          if (Array.isArray(value)) {
-            for (const sub of value) {
-              addField(sub.v, docIdx, keyIdx, sub.i ?? -1);
-            }
-          } else {
-            addField(value.v, docIdx, keyIdx, -1);
-          }
-        }
-      }
+    if (tokenize2 instanceof RegExp) {
+      if (!tokenize2.global) warnNonGlobal(tokenize2);
+      return (text) => text.match(tokenize2) || [];
     }
-    return {
-      terms,
-      fieldCount,
-      df
-    };
+    return (text) => text.match(DEFAULT_TOKEN) || [];
   }
-  function addToInvertedIndex(index, record, keyCount, analyzer) {
-    const {
-      i: docIdx,
-      v,
-      $: fields
-    } = record;
-    function addField(text, keyIdx, subIdx) {
-      const tokens = analyzer.tokenize(text);
-      if (!tokens.length) return;
-      index.fieldCount++;
-      const termFreqs = /* @__PURE__ */ new Map();
-      for (const token of tokens) {
-        termFreqs.set(token, (termFreqs.get(token) || 0) + 1);
+  function createAnalyzer({ isCaseSensitive = false, ignoreDiacritics = false, tokenize: tokenize2 } = {}) {
+    const tokenizeFn = resolveTokenize(tokenize2);
+    return { tokenize(text) {
+      if (!isCaseSensitive) text = text.toLowerCase();
+      if (ignoreDiacritics) text = stripDiacritics(text);
+      return tokenizeFn(text);
+    } };
+  }
+  var TokenSearch = class {
+    static condition(_, options) {
+      return options.useTokenSearch;
+    }
+    constructor(pattern, options) {
+      this.options = options;
+      this.analyzer = createAnalyzer({
+        isCaseSensitive: options.isCaseSensitive,
+        ignoreDiacritics: options.ignoreDiacritics,
+        tokenize: options.tokenize
+      });
+      const queryTerms = this.analyzer.tokenize(pattern);
+      const { df, fieldCount } = options._invertedIndex;
+      this.termSearchers = [];
+      this.idfWeights = [];
+      for (const term of queryTerms) {
+        this.termSearchers.push(new BitapSearch(term, {
+          location: options.location,
+          threshold: options.threshold,
+          distance: options.distance,
+          includeMatches: options.includeMatches,
+          findAllMatches: options.findAllMatches,
+          minMatchCharLength: options.minMatchCharLength,
+          isCaseSensitive: options.isCaseSensitive,
+          ignoreDiacritics: options.ignoreDiacritics,
+          ignoreLocation: true
+        }));
+        const docFreq = df.get(term) || 0;
+        const idf = Math.log(1 + (fieldCount - docFreq + 0.5) / (docFreq + 0.5));
+        this.idfWeights.push(idf);
       }
-      for (const [term, tf] of termFreqs) {
-        const posting = {
-          docIdx,
-          keyIdx,
-          subIdx,
-          tf
-        };
-        let postings = index.terms.get(term);
-        if (!postings) {
-          postings = [];
-          index.terms.set(term, postings);
+      this.combineAll = options.tokenMatch === "all";
+      this.numTerms = this.termSearchers.length;
+      this.useMask = this.numTerms <= 31;
+    }
+    searchIn(text) {
+      if (!this.termSearchers.length) return {
+        isMatch: false,
+        score: 1
+      };
+      const allIndices = [];
+      let weightedScore = 0;
+      let maxPossibleScore = 0;
+      let matchedCount = 0;
+      let matchedMask = 0;
+      const matchedTerms = this.combineAll && !this.useMask ? /* @__PURE__ */ new Set() : null;
+      for (let i = 0; i < this.termSearchers.length; i++) {
+        const result = this.termSearchers[i].searchIn(text);
+        const idf = this.idfWeights[i];
+        maxPossibleScore += idf;
+        if (result.isMatch) {
+          matchedCount++;
+          weightedScore += idf * (1 - result.score);
+          if (result.indices) allIndices.push(...result.indices);
+          if (this.combineAll) if (this.useMask) matchedMask |= 1 << i;
+          else matchedTerms.add(i);
         }
-        postings.push(posting);
-        index.df.set(term, (index.df.get(term) || 0) + 1);
       }
+      if (matchedCount === 0) return {
+        isMatch: false,
+        score: 1
+      };
+      const normalized = maxPossibleScore > 0 ? 1 - weightedScore / maxPossibleScore : 0;
+      const searchResult = {
+        isMatch: true,
+        score: Math.max(1e-3, normalized)
+      };
+      if (this.options.includeMatches && allIndices.length) searchResult.indices = mergeIndices(allIndices);
+      if (this.combineAll) {
+        if (this.useMask) searchResult.matchedMask = matchedMask;
+        else searchResult.matchedTerms = matchedTerms;
+        searchResult.termCount = this.numTerms;
+      }
+      return searchResult;
+    }
+  };
+  function addField(index, text, docIdx, analyzer) {
+    const tokens = analyzer.tokenize(text);
+    if (!tokens.length) return;
+    index.fieldCount++;
+    index.docFieldCount.set(docIdx, (index.docFieldCount.get(docIdx) || 0) + 1);
+    const distinctTerms = new Set(tokens);
+    let perDocTerms = index.docTermFieldHits.get(docIdx);
+    if (!perDocTerms) {
+      perDocTerms = /* @__PURE__ */ new Map();
+      index.docTermFieldHits.set(docIdx, perDocTerms);
+    }
+    for (const term of distinctTerms) {
+      perDocTerms.set(term, (perDocTerms.get(term) || 0) + 1);
+      index.df.set(term, (index.df.get(term) || 0) + 1);
     }
+  }
+  function ingestRecord(index, record, keyCount, analyzer) {
+    const { i: docIdx, v, $: fields } = record;
     if (v !== void 0) {
-      addField(v, -1, -1);
+      addField(index, v, docIdx, analyzer);
       return;
     }
-    if (fields) {
-      for (let keyIdx = 0; keyIdx < keyCount; keyIdx++) {
-        const value = fields[keyIdx];
-        if (!value) continue;
-        if (Array.isArray(value)) {
-          for (const sub of value) {
-            addField(sub.v, keyIdx, sub.i ?? -1);
-          }
-        } else {
-          addField(value.v, keyIdx, -1);
-        }
-      }
+    if (!fields) return;
+    for (let keyIdx = 0; keyIdx < keyCount; keyIdx++) {
+      const value = fields[keyIdx];
+      if (!value) continue;
+      if (Array.isArray(value)) for (const sub of value) addField(index, sub.v, docIdx, analyzer);
+      else addField(index, value.v, docIdx, analyzer);
     }
   }
+  function buildInvertedIndex(records, keyCount, analyzer) {
+    const index = {
+      fieldCount: 0,
+      df: /* @__PURE__ */ new Map(),
+      docFieldCount: /* @__PURE__ */ new Map(),
+      docTermFieldHits: /* @__PURE__ */ new Map()
+    };
+    for (const record of records) ingestRecord(index, record, keyCount, analyzer);
+    return index;
+  }
+  function addToInvertedIndex(index, record, keyCount, analyzer) {
+    ingestRecord(index, record, keyCount, analyzer);
+  }
   function removeFromInvertedIndex(index, docIdx) {
-    for (const [term, postings] of index.terms) {
-      const filtered = postings.filter((p) => p.docIdx !== docIdx);
-      const removed = postings.length - filtered.length;
-      if (removed > 0) {
-        index.fieldCount -= removed;
-        index.df.set(term, (index.df.get(term) || 0) - removed);
-        if (filtered.length === 0) {
-          index.terms.delete(term);
-          index.df.delete(term);
-        } else {
-          index.terms.set(term, filtered);
-        }
-      }
-    }
+    const fieldCount = index.docFieldCount.get(docIdx);
+    if (fieldCount === void 0) return;
+    index.fieldCount -= fieldCount;
+    index.docFieldCount.delete(docIdx);
+    const perDocTerms = index.docTermFieldHits.get(docIdx);
+    if (!perDocTerms) return;
+    for (const [term, hits] of perDocTerms) {
+      const next = (index.df.get(term) || 0) - hits;
+      if (next <= 0) index.df.delete(term);
+      else index.df.set(term, next);
+    }
+    index.docTermFieldHits.delete(docIdx);
   }
-  class Fuse {
-    // Statics are assigned in entry.ts
+  function removeAndShiftInvertedIndex(index, removedIndices) {
+    if (removedIndices.length === 0) return;
+    const sorted = Array.from(new Set(removedIndices)).sort((a, b) => a - b);
+    for (const idx of sorted) removeFromInvertedIndex(index, idx);
+    const shift = (oldIdx) => {
+      let lo = 0;
+      let hi = sorted.length;
+      while (lo < hi) {
+        const mid = lo + hi >>> 1;
+        if (sorted[mid] < oldIdx) lo = mid + 1;
+        else hi = mid;
+      }
+      return oldIdx - lo;
+    };
+    const firstRemoved = sorted[0];
+    const shiftedDocFieldCount = /* @__PURE__ */ new Map();
+    for (const [oldKey, count] of index.docFieldCount) shiftedDocFieldCount.set(oldKey > firstRemoved ? shift(oldKey) : oldKey, count);
+    index.docFieldCount = shiftedDocFieldCount;
+    const shiftedDocTermFieldHits = /* @__PURE__ */ new Map();
+    for (const [oldKey, terms] of index.docTermFieldHits) shiftedDocTermFieldHits.set(oldKey > firstRemoved ? shift(oldKey) : oldKey, terms);
+    index.docTermFieldHits = shiftedDocTermFieldHits;
+  }
+  var Fuse = class {
     constructor(docs, options, index) {
       this.options = {
         ...Config,
@@ -1445,23 +1220,18 @@
       this._lastSearcher = null;
     }
     _getSearcher(query) {
-      if (this._lastQuery === query) {
-        return this._lastSearcher;
-      }
-      const opts = this._invertedIndex ? {
+      if (this._lastQuery === query) return this._lastSearcher;
+      const searcher = createSearcher(query, this._invertedIndex ? {
         ...this.options,
         _invertedIndex: this._invertedIndex
-      } : this.options;
-      const searcher = createSearcher(query, opts);
+      } : this.options);
       this._lastQuery = query;
       this._lastSearcher = searcher;
       return searcher;
     }
     setCollection(docs, index) {
       this._docs = docs;
-      if (index && !(index instanceof FuseIndex)) {
-        throw new Error(INCORRECT_INDEX_TYPE);
-      }
+      if (index && !(index instanceof FuseIndex)) throw new Error(INCORRECT_INDEX_TYPE);
       this._myIndex = index || createIndex(this.options.keys, this._docs, {
         getFn: this.options.getFn,
         fieldNormWeight: this.options.fieldNormWeight
@@ -1469,155 +1239,129 @@
       if (this.options.useTokenSearch) {
         const analyzer = createAnalyzer({
           isCaseSensitive: this.options.isCaseSensitive,
-          ignoreDiacritics: this.options.ignoreDiacritics
+          ignoreDiacritics: this.options.ignoreDiacritics,
+          tokenize: this.options.tokenize
         });
         this._invertedIndex = buildInvertedIndex(this._myIndex.records, this._myIndex.keys.length, analyzer);
       }
+      this._invalidateSearcherCache();
     }
     add(doc) {
-      if (!isDefined(doc)) {
-        return;
-      }
+      if (!isDefined(doc)) return;
       this._docs.push(doc);
-      this._myIndex.add(doc);
-      if (this._invertedIndex) {
-        const record = this._myIndex.records[this._myIndex.records.length - 1];
+      const record = this._myIndex.add(doc, this._docs.length - 1);
+      if (this._invertedIndex && record) {
         const analyzer = createAnalyzer({
           isCaseSensitive: this.options.isCaseSensitive,
-          ignoreDiacritics: this.options.ignoreDiacritics
+          ignoreDiacritics: this.options.ignoreDiacritics,
+          tokenize: this.options.tokenize
         });
         addToInvertedIndex(this._invertedIndex, record, this._myIndex.keys.length, analyzer);
       }
+      this._invalidateSearcherCache();
     }
     remove(predicate = () => false) {
       const results = [];
       const indicesToRemove = [];
-      for (let i = 0, len = this._docs.length; i < len; i += 1) {
-        if (predicate(this._docs[i], i)) {
-          results.push(this._docs[i]);
-          indicesToRemove.push(i);
-        }
+      for (let i = 0, len = this._docs.length; i < len; i += 1) if (predicate(this._docs[i], i)) {
+        results.push(this._docs[i]);
+        indicesToRemove.push(i);
       }
       if (indicesToRemove.length) {
-        if (this._invertedIndex) {
-          for (const idx of indicesToRemove) {
-            removeFromInvertedIndex(this._invertedIndex, idx);
-          }
-        }
-        for (let i = indicesToRemove.length - 1; i >= 0; i -= 1) {
-          this._docs.splice(indicesToRemove[i], 1);
-        }
+        if (this._invertedIndex) removeAndShiftInvertedIndex(this._invertedIndex, indicesToRemove);
+        const toRemove = new Set(indicesToRemove);
+        this._docs = this._docs.filter((_, i) => !toRemove.has(i));
         this._myIndex.removeAll(indicesToRemove);
+        this._invalidateSearcherCache();
       }
       return results;
     }
     removeAt(idx) {
-      if (this._invertedIndex) {
-        removeFromInvertedIndex(this._invertedIndex, idx);
-      }
+      if (!Number.isInteger(idx) || idx < 0 || idx >= this._docs.length) throw new Error(INVALID_DOC_INDEX);
+      if (this._invertedIndex) removeAndShiftInvertedIndex(this._invertedIndex, [idx]);
       const doc = this._docs.splice(idx, 1)[0];
       this._myIndex.removeAt(idx);
+      this._invalidateSearcherCache();
       return doc;
     }
+    _invalidateSearcherCache() {
+      this._lastQuery = null;
+      this._lastSearcher = null;
+    }
     getIndex() {
       return this._myIndex;
     }
+    _normalizedKeys() {
+      return this._myIndex.keys.map((key) => this._keyStore.get(key.id) || key);
+    }
     search(query, options) {
-      const {
-        limit = -1
-      } = options || {};
-      const {
-        includeMatches,
-        includeScore,
-        shouldSort,
-        sortFn,
-        ignoreFieldNorm
-      } = this.options;
+      const { limit = -1 } = options || {};
+      const { includeMatches, includeScore, shouldSort, sortFn, ignoreFieldNorm } = this.options;
       if (isString(query) && !query.trim()) {
         let docs = this._docs.map((item, idx) => ({
           item,
           refIndex: idx
         }));
-        if (isNumber(limit) && limit > -1) {
-          docs = docs.slice(0, limit);
-        }
+        if (isNumber(limit) && limit > -1) docs = docs.slice(0, limit);
         return docs;
       }
-      const useHeap = isNumber(limit) && limit > 0 && isString(query);
+      const useHeap = shouldSort && isNumber(limit) && limit > 0 && isString(query);
+      const comparator = sortFn;
+      const stable = (a, b) => comparator(a, b) || a.idx - b.idx;
       let results;
       if (useHeap) {
-        const heap = new MaxHeap(limit);
-        if (isString(this._docs[0])) {
-          this._searchStringList(query, {
-            heap,
-            ignoreFieldNorm
-          });
-        } else {
-          this._searchObjectList(query, {
-            heap,
-            ignoreFieldNorm
-          });
-        }
-        results = heap.extractSorted(sortFn);
-      } else {
-        results = isString(query) ? isString(this._docs[0]) ? this._searchStringList(query) : this._searchObjectList(query) : this._searchLogical(query);
-        computeScore(results, {
+        const heap = new MaxHeap(limit, stable);
+        if (isString(this._docs[0])) this._searchStringList(query, {
+          heap,
           ignoreFieldNorm
         });
-        if (shouldSort) {
-          results.sort(sortFn);
-        }
-        if (isNumber(limit) && limit > -1) {
-          results = results.slice(0, limit);
-        }
+        else this._searchObjectList(query, {
+          heap,
+          ignoreFieldNorm
+        });
+        results = heap.extractSorted();
+      } else {
+        results = isString(query) ? isString(this._docs[0]) ? this._searchStringList(query) : this._searchObjectList(query) : this._searchLogical(query);
+        computeScore(results, { ignoreFieldNorm });
+        if (shouldSort) results.sort(isString(query) ? stable : comparator);
+        if (isNumber(limit) && limit > -1) results = results.slice(0, limit);
       }
       return format(results, this._docs, {
         includeMatches,
         includeScore
       });
     }
-    _searchStringList(query, {
-      heap,
-      ignoreFieldNorm
-    } = {}) {
+    _searchStringList(query, { heap, ignoreFieldNorm } = {}) {
       const searcher = this._getSearcher(query);
-      const {
-        records
-      } = this._myIndex;
+      const requireAllTokens = this.options.useTokenSearch && this.options.tokenMatch === "all";
+      const { records } = this._myIndex;
       const results = heap ? null : [];
-      records.forEach(({
-        v: text,
-        i: idx,
-        n: norm2
-      }) => {
-        if (!isDefined(text)) {
-          return;
-        }
-        const {
-          isMatch,
-          score,
-          indices
-        } = searcher.searchIn(text);
-        if (isMatch) {
-          const result = {
-            item: text,
-            idx,
-            matches: [{
-              score,
-              value: text,
-              norm: norm2,
-              indices
-            }]
+      records.forEach(({ v: text, i: idx, n: norm2 }) => {
+        if (!isDefined(text)) return;
+        const searchResult = searcher.searchIn(text);
+        if (searchResult.isMatch) {
+          const match = {
+            score: searchResult.score,
+            value: text,
+            norm: norm2,
+            indices: searchResult.indices
           };
-          if (heap) {
-            result.score = computeScoreSingle(result.matches, {
-              ignoreFieldNorm
-            });
-            if (heap.shouldInsert(result.score)) {
+          if (requireAllTokens) {
+            match.matchedMask = searchResult.matchedMask;
+            match.matchedTerms = searchResult.matchedTerms;
+            match.termCount = searchResult.termCount;
+          }
+          const matches = [match];
+          if (!requireAllTokens || this._coversAllTokens(matches)) {
+            const result = {
+              item: text,
+              idx,
+              matches
+            };
+            if (heap) {
+              result.score = computeScoreSingle(result.matches, { ignoreFieldNorm });
               heap.insert(result);
-            }
-          } else {
-            results.push(result);
+            } else results.push(result);
           }
         }
       });
@@ -1625,61 +1369,46 @@
     }
     _searchLogical(query) {
       const expression = parse(query, this.options);
+      const keys = this._normalizedKeys();
       const evaluate = (node, item, idx) => {
         if (!("children" in node)) {
-          const {
-            keyId,
-            searcher
-          } = node;
+          const { keyId, searcher } = node;
           let matches;
           if (keyId === null) {
             matches = [];
-            this._myIndex.keys.forEach((key, keyIndex) => {
+            keys.forEach((key, keyIndex) => {
               matches.push(...this._findMatches({
                 key,
                 value: item[keyIndex],
                 searcher
               }));
             });
-          } else {
-            matches = this._findMatches({
-              key: this._keyStore.get(keyId),
-              value: this._myIndex.getValueForItemAtKeyId(item, keyId),
-              searcher
-            });
-          }
-          if (matches && matches.length) {
-            return [{
-              idx,
-              item,
-              matches
-            }];
-          }
+          } else matches = this._findMatches({
+            key: this._keyStore.get(keyId),
+            value: this._myIndex.getValueForItemAtKeyId(item, keyId),
+            searcher
+          });
+          if (matches && matches.length) return [{
+            idx,
+            item,
+            matches
+          }];
           return [];
         }
-        const {
-          children,
-          operator
-        } = node;
+        const { children, operator } = node;
         const res = [];
         for (let i = 0, len = children.length; i < len; i += 1) {
           const child = children[i];
           const result = evaluate(child, item, idx);
-          if (result.length) {
-            res.push(...result);
-          } else if (operator === LogicalOperator.AND) {
-            return [];
-          }
+          if (result.length) res.push(...result);
+          else if (operator === LogicalOperator.AND) return [];
         }
         return res;
       };
       const records = this._myIndex.records;
       const resultMap = /* @__PURE__ */ new Map();
       const results = [];
-      records.forEach(({
-        $: item,
-        i: idx
-      }) => {
+      records.forEach(({ $: item, i: idx }) => {
         if (isDefined(item)) {
           const expResults = evaluate(expression, item, idx);
           if (expResults.length) {
@@ -1691,9 +1420,7 @@
               });
               results.push(resultMap.get(idx));
             }
-            expResults.forEach(({
-              matches
-            }) => {
+            expResults.forEach(({ matches }) => {
               resultMap.get(idx).matches.push(...matches);
             });
           }
@@ -1701,31 +1428,14 @@
       });
       return results;
     }
-    // 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(query, {
-      heap,
-      ignoreFieldNorm
-    } = {}) {
+    _searchObjectList(query, { heap, ignoreFieldNorm } = {}) {
       const searcher = this._getSearcher(query);
-      const {
-        keys,
-        records
-      } = this._myIndex;
+      const requireAllTokens = this.options.useTokenSearch && this.options.tokenMatch === "all";
+      const { records } = this._myIndex;
+      const keys = this._normalizedKeys();
       const results = heap ? null : [];
-      records.forEach(({
-        $: item,
-        i: idx
-      }) => {
-        if (!isDefined(item)) {
-          return;
-        }
+      records.forEach(({ $: item, i: idx }) => {
+        if (!isDefined(item)) return;
         const matches = [];
         let anyKeyFailed = false;
         let hasInverse = false;
@@ -1737,195 +1447,104 @@
           });
           if (keyMatches.length) {
             matches.push(...keyMatches);
-            if (keyMatches[0].hasInverse) {
-              hasInverse = true;
-            }
-          } else {
-            anyKeyFailed = true;
-          }
+            if (keyMatches[0].hasInverse) hasInverse = true;
+          } else anyKeyFailed = true;
         });
-        if (hasInverse && anyKeyFailed) {
-          return;
-        }
-        if (matches.length) {
+        if (hasInverse && anyKeyFailed) return;
+        if (matches.length && (!requireAllTokens || this._coversAllTokens(matches))) {
           const result = {
             idx,
             item,
             matches
           };
           if (heap) {
-            result.score = computeScoreSingle(result.matches, {
-              ignoreFieldNorm
-            });
-            if (heap.shouldInsert(result.score)) {
-              heap.insert(result);
-            }
-          } else {
-            results.push(result);
-          }
+            result.score = computeScoreSingle(result.matches, { ignoreFieldNorm });
+            heap.insert(result);
+          } else results.push(result);
         }
       });
       return results;
     }
-    _findMatches({
-      key,
-      value,
-      searcher
-    }) {
-      if (!isDefined(value)) {
-        return [];
-      }
+    _findMatches({ key, value, searcher }) {
+      if (!isDefined(value)) return [];
       const matches = [];
-      if (isArray(value)) {
-        value.forEach(({
-          v: text,
-          i: idx,
-          n: norm2
-        }) => {
-          if (!isDefined(text)) {
-            return;
-          }
-          const {
-            isMatch,
-            score,
-            indices,
-            hasInverse
-          } = searcher.searchIn(text);
-          if (isMatch) {
-            matches.push({
-              score,
-              key,
-              value: text,
-              idx,
-              norm: norm2,
-              indices,
-              hasInverse
-            });
-          }
-        });
-      } else {
-        const {
-          v: text,
-          n: norm2
-        } = value;
-        const {
-          isMatch,
-          score,
-          indices,
-          hasInverse
-        } = searcher.searchIn(text);
-        if (isMatch) {
-          matches.push({
-            score,
+      if (isArray(value)) value.forEach(({ v: text, i: idx, n: norm2 }) => {
+        if (!isDefined(text)) return;
+        const searchResult = searcher.searchIn(text);
+        if (searchResult.isMatch) {
+          const match = {
+            score: searchResult.score,
             key,
             value: text,
+            idx,
             norm: norm2,
-            indices,
-            hasInverse
-          });
+            indices: searchResult.indices,
+            hasInverse: searchResult.hasInverse
+          };
+          if (searchResult.termCount !== void 0) {
+            match.matchedMask = searchResult.matchedMask;
+            match.matchedTerms = searchResult.matchedTerms;
+            match.termCount = searchResult.termCount;
+          }
+          matches.push(match);
         }
-      }
-      return matches;
-    }
-  }
-  class TokenSearch {
-    static condition(_, options) {
-      return options.useTokenSearch;
-    }
-    constructor(pattern, options) {
-      this.options = options;
-      this.analyzer = createAnalyzer({
-        isCaseSensitive: options.isCaseSensitive,
-        ignoreDiacritics: options.ignoreDiacritics
       });
-      const queryTerms = this.analyzer.tokenize(pattern);
-      const invertedIndex = options._invertedIndex;
-      const {
-        df,
-        fieldCount
-      } = invertedIndex;
-      this.termSearchers = [];
-      this.idfWeights = [];
-      for (const term of queryTerms) {
-        this.termSearchers.push(new BitapSearch(term, {
-          location: options.location,
-          threshold: options.threshold,
-          distance: options.distance,
-          includeMatches: options.includeMatches,
-          findAllMatches: options.findAllMatches,
-          minMatchCharLength: options.minMatchCharLength,
-          isCaseSensitive: options.isCaseSensitive,
-          ignoreDiacritics: options.ignoreDiacritics,
-          ignoreLocation: true
-        }));
-        const docFreq = df.get(term) || 0;
-        const idf = Math.log(1 + (fieldCount - docFreq + 0.5) / (docFreq + 0.5));
-        this.idfWeights.push(idf);
-      }
-    }
-    searchIn(text) {
-      if (!this.termSearchers.length) {
-        return {
-          isMatch: false,
-          score: 1
-        };
-      }
-      const allIndices = [];
-      let weightedScore = 0;
-      let maxPossibleScore = 0;
-      let matchedCount = 0;
-      for (let i = 0; i < this.termSearchers.length; i++) {
-        const result = this.termSearchers[i].searchIn(text);
-        const idf = this.idfWeights[i];
-        maxPossibleScore += idf;
-        if (result.isMatch) {
-          matchedCount++;
-          weightedScore += idf * (1 - result.score);
-          if (result.indices) {
-            allIndices.push(...result.indices);
+      else {
+        const { v: text, n: norm2 } = value;
+        const searchResult = searcher.searchIn(text);
+        if (searchResult.isMatch) {
+          const match = {
+            score: searchResult.score,
+            key,
+            value: text,
+            norm: norm2,
+            indices: searchResult.indices,
+            hasInverse: searchResult.hasInverse
+          };
+          if (searchResult.termCount !== void 0) {
+            match.matchedMask = searchResult.matchedMask;
+            match.matchedTerms = searchResult.matchedTerms;
+            match.termCount = searchResult.termCount;
           }
+          matches.push(match);
         }
       }
-      if (matchedCount === 0) {
-        return {
-          isMatch: false,
-          score: 1
-        };
+      return matches;
+    }
+    _coversAllTokens(matches) {
+      const termCount = matches.length ? matches[0].termCount : void 0;
+      if (termCount === void 0) return true;
+      if (termCount <= 31) {
+        let coverage2 = 0;
+        for (let i = 0; i < matches.length; i++) coverage2 |= matches[i].matchedMask || 0;
+        return coverage2 === 2 ** termCount - 1;
       }
-      const normalized = maxPossibleScore > 0 ? 1 - weightedScore / maxPossibleScore : 0;
-      const searchResult = {
-        isMatch: true,
-        score: Math.max(1e-3, normalized)
-      };
-      if (this.options.includeMatches && allIndices.length) {
-        searchResult.indices = mergeIndices(allIndices);
+      const coverage = /* @__PURE__ */ new Set();
+      for (let i = 0; i < matches.length; i++) {
+        const terms = matches[i].matchedTerms;
+        if (terms) for (const t of terms) coverage.add(t);
       }
-      return searchResult;
+      return coverage.size === termCount;
     }
-  }
-  Fuse.version = "7.3.0";
+  };
+  Fuse.version = "7.5.0";
   Fuse.createIndex = createIndex;
   Fuse.parseIndex = parseIndex;
   Fuse.config = Config;
   Fuse.match = function(pattern, text, options) {
-    const searcher = createSearcher(pattern, {
+    if (options && options.useTokenSearch) throw new Error(FUSE_MATCH_TOKEN_SEARCH_UNSUPPORTED);
+    return createSearcher(pattern, {
       ...Config,
       ...options
-    });
-    return searcher.searchIn(text);
+    }).searchIn(text);
   };
-  {
-    Fuse.parseQuery = parse;
-  }
-  {
-    register(ExtendedSearch);
-  }
-  {
-    register(TokenSearch);
-  }
+  Fuse.parseQuery = parse;
+  register(ExtendedSearch);
+  register(TokenSearch);
   Fuse.use = function(...plugins) {
     plugins.forEach((plugin) => register(plugin));
   };
+  var entry_default = Fuse;
   const version = "0.3.5";
   const packageJson = {
     version
@@ -2090,7 +1709,7 @@
       });
     }
     const search2 = (entities) => {
-      const fuse = new Fuse(entities, {
+      const fuse = new entry_default(entities, {
         shouldSort: false,
         isCaseSensitive: false,
         findAllMatches: true,