reg-cli 0.18.16 → 0.19.0-rc0

package/{report/ui/dist/worker.js → dist/shared/report-worker.js}

@@ -7,7 +7,10 @@
     if (typeof value == "string") {
       return value;
     }
-    let result = value + "";
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    const result = value + "";
     return result == "0" && 1 / value == -Infinity ? "-0" : result;
   }
   function toString(value) {
@@ -49,7 +52,7 @@
       this._keyMap = {};
       let totalWeight = 0;
       keys.forEach((key) => {
-        let obj = createKey(key);
+        const obj = createKey(key);
         this._keys.push(obj);
         this._keyMap[obj.id] = obj;
         totalWeight += obj.weight;
@@ -94,7 +97,13 @@
       id = createKeyId(name);
       getFn = key.getFn;
     }
-    return { path, id, weight, src, getFn };
+    return {
+      path,
+      id,
+      weight,
+      src,
+      getFn
+    };
   }
   function createKeyPath(key) {
     return isArray(key) ? key : key.split(".");
@@ -103,29 +112,35 @@
     return isArray(key) ? key.join(".") : key;
   }
   function get(obj, path) {
-    let list = [];
+    const list = [];
     let arr = false;
-    const deepGet = (obj2, path2, index) => {
+    const deepGet = (obj2, path2, index, arrayIndex) => {
       if (!isDefined(obj2)) {
         return;
       }
       if (!path2[index]) {
-        list.push(obj2);
+        list.push(arrayIndex !== void 0 ? {
+          v: obj2,
+          i: arrayIndex
+        } : obj2);
       } else {
-        let key = path2[index];
+        const key = path2[index];
         const value = obj2[key];
         if (!isDefined(value)) {
           return;
         }
-        if (index === path2.length - 1 && (isString(value) || isNumber(value) || isBoolean(value))) {
-          list.push(toString(value));
+        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)) {
           arr = true;
           for (let i = 0, len = value.length; i < len; i += 1) {
-            deepGet(value[i], path2, index + 1);
+            deepGet(value[i], path2, index + 1, i);
           }
         } else if (path2.length) {
-          deepGet(value, path2, index + 1);
+          deepGet(value, path2, index + 1, arrayIndex);
         }
       }
     };
@@ -133,67 +148,37 @@
     return arr ? list : list[0];
   }
   const MatchOptions = {
-    // Whether the matches should be included in the result set. When `true`, each record in the result
-    // set will include the indices of the matched characters.
-    // These can consequently be used for highlighting purposes.
     includeMatches: false,
-    // When `true`, the matching function will continue to the end of a search pattern even if
-    // a perfect match has already been located in the string.
     findAllMatches: false,
-    // Minimum number of characters that must be matched before a result is considered a match
     minMatchCharLength: 1
   };
   const BasicOptions = {
-    // When `true`, the algorithm continues searching to the end of the input even if a perfect
-    // match is found before the end of the same input.
     isCaseSensitive: false,
-    // When `true`, the algorithm will ignore diacritics (accents) in comparisons
     ignoreDiacritics: false,
-    // When true, the matching function will continue to the end of a search pattern even if
     includeScore: false,
-    // List of properties that will be searched. This also supports nested properties.
     keys: [],
-    // Whether to sort the result list, by score
     shouldSort: true,
-    // Default sort function: sort by ascending score, ascending index
     sortFn: (a, b) => a.score === b.score ? a.idx < b.idx ? -1 : 1 : a.score < b.score ? -1 : 1
   };
   const FuzzyOptions = {
-    // Approximately where in the text is the pattern expected to be found?
     location: 0,
-    // At what point does the match algorithm give up. A threshold of '0.0' requires a perfect match
-    // (of both letters and location), a threshold of '1.0' would match anything.
     threshold: 0.6,
-    // Determines how close the match must be to the fuzzy location (specified above).
-    // An exact letter match which is 'distance' characters away from the fuzzy location
-    // would score as a complete mismatch. A distance of '0' requires the match be at
-    // the exact location specified, a threshold of '1000' would require a perfect match
-    // to be within 800 characters of the fuzzy location to be found using a 0.8 threshold.
     distance: 100
   };
   const AdvancedOptions = {
-    // When `true`, it enables the use of unix-like search commands
     useExtendedSearch: false,
-    // The get function to use when fetching an object's properties.
-    // The default will search nested paths *ie foo.bar.baz*
+    useTokenSearch: false,
     getFn: get,
-    // When `true`, search will ignore `location` and `distance`, so it won't matter
-    // where in the string the pattern appears.
-    // More info: https://fusejs.io/concepts/scoring-theory.html#fuzziness-score
     ignoreLocation: false,
-    // When `true`, the calculation for the relevance score (used for sorting) will
-    // ignore the field-length norm.
-    // More info: https://fusejs.io/concepts/scoring-theory.html#field-length-norm
     ignoreFieldNorm: false,
-    // The weight to determine how much field length norm effects scoring.
     fieldNormWeight: 1
   };
-  var Config = {
+  const Config = Object.freeze({
     ...BasicOptions,
     ...MatchOptions,
     ...FuzzyOptions,
     ...AdvancedOptions
-  };
+  });
   const SPACE = /[^ ]+/g;
   function norm(weight = 1, mantissa = 3) {
     const cache = /* @__PURE__ */ new Map();
@@ -222,6 +207,9 @@
       this.norm = norm(fieldNormWeight, 3);
       this.getFn = getFn;
       this.isCreated = false;
+      this.docs = [];
+      this.keys = [];
+      this._keysMap = {};
       this.setIndexRecords();
     }
     setSources(docs = []) {
@@ -269,6 +257,15 @@
         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;
+      }
+    }
     getValueForItemAtKeyId(item, keyId) {
       return item[this._keysMap[keyId]];
     }
@@ -279,7 +276,7 @@
       if (!isDefined(doc) || isBlank(doc)) {
         return;
       }
-      let record = {
+      const record = {
         v: doc,
         i: docIndex,
         n: this.norm.get(doc)
@@ -287,39 +284,46 @@
       this.records.push(record);
     }
     _addObject(doc, docIndex) {
-      let record = { i: docIndex, $: {} };
+      const record = {
+        i: docIndex,
+        $: {}
+      };
       this.keys.forEach((key, keyIndex) => {
-        let value = key.getFn ? key.getFn(doc) : this.getFn(doc, key.path);
+        const value = key.getFn ? key.getFn(doc) : this.getFn(doc, key.path);
         if (!isDefined(value)) {
           return;
         }
         if (isArray(value)) {
-          let subRecords = [];
-          const stack = [{ nestedArrIndex: -1, value }];
-          while (stack.length) {
-            const { nestedArrIndex, value: value2 } = stack.pop();
-            if (!isDefined(value2)) {
+          const subRecords = [];
+          for (let i = 0, len = value.length; i < len; i += 1) {
+            const item = value[i];
+            if (!isDefined(item)) {
               continue;
             }
-            if (isString(value2) && !isBlank(value2)) {
-              let subRecord = {
-                v: value2,
-                i: nestedArrIndex,
-                n: this.norm.get(value2)
-              };
-              subRecords.push(subRecord);
-            } else if (isArray(value2)) {
-              value2.forEach((item, k) => {
-                stack.push({
-                  nestedArrIndex: k,
-                  value: item
-                });
-              });
-            } else ;
+            if (isString(item)) {
+              if (!isBlank(item)) {
+                const subRecord = {
+                  v: item,
+                  i,
+                  n: this.norm.get(item)
+                };
+                subRecords.push(subRecord);
+              }
+            } else if (isDefined(item.v)) {
+              const text = isString(item.v) ? item.v : toString(item.v);
+              if (!isBlank(text)) {
+                const subRecord = {
+                  v: text,
+                  i: item.i,
+                  n: this.norm.get(text)
+                };
+                subRecords.push(subRecord);
+              }
+            }
           }
           record.$[keyIndex] = subRecords;
         } else if (isString(value) && !isBlank(value)) {
-          let subRecord = {
+          const subRecord = {
             v: value,
             n: this.norm.get(value)
           };
@@ -330,49 +334,51 @@
     }
     toJSON() {
       return {
-        keys: this.keys,
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        keys: this.keys.map(({
+          getFn,
+          ...key
+        }) => key),
         records: this.records
       };
     }
   }
-  function createIndex(keys, docs, { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}) {
-    const myIndex = new FuseIndex({ getFn, fieldNormWeight });
+  function createIndex(keys, docs, {
+    getFn = Config.getFn,
+    fieldNormWeight = Config.fieldNormWeight
+  } = {}) {
+    const myIndex = new FuseIndex({
+      getFn,
+      fieldNormWeight
+    });
     myIndex.setKeys(keys.map(createKey));
     myIndex.setSources(docs);
     myIndex.create();
     return myIndex;
   }
-  function parseIndex(data, { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}) {
-    const { keys, records } = data;
-    const myIndex = new FuseIndex({ getFn, fieldNormWeight });
+  function parseIndex(data, {
+    getFn = Config.getFn,
+    fieldNormWeight = Config.fieldNormWeight
+  } = {}) {
+    const {
+      keys,
+      records
+    } = data;
+    const myIndex = new FuseIndex({
+      getFn,
+      fieldNormWeight
+    });
     myIndex.setKeys(keys);
     myIndex.setIndexRecords(records);
     return myIndex;
   }
-  function computeScore$1(pattern, {
-    errors = 0,
-    currentLocation = 0,
-    expectedLocation = 0,
-    distance = Config.distance,
-    ignoreLocation = Config.ignoreLocation
-  } = {}) {
-    const accuracy = errors / pattern.length;
-    if (ignoreLocation) {
-      return accuracy;
-    }
-    const proximity = Math.abs(expectedLocation - currentLocation);
-    if (!distance) {
-      return proximity ? 1 : accuracy;
-    }
-    return accuracy + proximity / distance;
-  }
   function convertMaskToIndices(matchmask = [], minMatchCharLength = Config.minMatchCharLength) {
-    let indices = [];
+    const indices = [];
     let start = -1;
     let end = -1;
     let i = 0;
     for (let len = matchmask.length; i < len; i += 1) {
-      let match = matchmask[i];
+      const match = matchmask[i];
       if (match && start === -1) {
         start = i;
       } else if (!match && start !== -1) {
@@ -406,16 +412,18 @@
     const expectedLocation = Math.max(0, Math.min(location, textLen));
     let currentThreshold = threshold;
     let bestLocation = expectedLocation;
+    const calcScore = (errors, currentLocation) => {
+      const accuracy = errors / patternLen;
+      if (ignoreLocation) return accuracy;
+      const proximity = Math.abs(expectedLocation - currentLocation);
+      if (!distance) return proximity ? 1 : accuracy;
+      return accuracy + proximity / distance;
+    };
     const computeMatches = minMatchCharLength > 1 || includeMatches;
     const matchMask = computeMatches ? Array(textLen) : [];
     let index;
     while ((index = text.indexOf(pattern, bestLocation)) > -1) {
-      let score = computeScore$1(pattern, {
-        currentLocation: index,
-        expectedLocation,
-        distance,
-        ignoreLocation
-      });
+      const score = calcScore(0, index);
       currentThreshold = Math.min(score, currentThreshold);
       bestLocation = index + patternLen;
       if (computeMatches) {
@@ -435,13 +443,7 @@
       let binMin = 0;
       let binMid = binMax;
       while (binMin < binMid) {
-        const score2 = computeScore$1(pattern, {
-          errors: i,
-          currentLocation: expectedLocation + binMid,
-          expectedLocation,
-          distance,
-          ignoreLocation
-        });
+        const score2 = calcScore(i, expectedLocation + binMid);
         if (score2 <= currentThreshold) {
           binMin = binMid;
         } else {
@@ -451,12 +453,12 @@
       }
       binMax = binMid;
       let start = Math.max(1, expectedLocation - binMid + 1);
-      let finish = findAllMatches ? textLen : Math.min(expectedLocation + binMid, textLen) + patternLen;
-      let bitArr = Array(finish + 2);
+      const finish = findAllMatches ? textLen : Math.min(expectedLocation + binMid, textLen) + patternLen;
+      const bitArr = Array(finish + 2);
       bitArr[finish + 1] = (1 << i) - 1;
       for (let j = finish; j >= start; j -= 1) {
-        let currentLocation = j - 1;
-        let charMatch = patternAlphabet[text.charAt(currentLocation)];
+        const currentLocation = j - 1;
+        const charMatch = patternAlphabet[text[currentLocation]];
         if (computeMatches) {
           matchMask[currentLocation] = +!!charMatch;
         }
@@ -465,13 +467,7 @@
           bitArr[j] |= (lastBitArr[j + 1] | lastBitArr[j]) << 1 | 1 | lastBitArr[j + 1];
         }
         if (bitArr[j] & mask) {
-          finalScore = computeScore$1(pattern, {
-            errors: i,
-            currentLocation,
-            expectedLocation,
-            distance,
-            ignoreLocation
-          });
+          finalScore = calcScore(i, currentLocation);
           if (finalScore <= currentThreshold) {
             currentThreshold = finalScore;
             bestLocation = currentLocation;
@@ -482,13 +478,7 @@
           }
         }
       }
-      const score = computeScore$1(pattern, {
-        errors: i + 1,
-        currentLocation: expectedLocation,
-        expectedLocation,
-        distance,
-        ignoreLocation
-      });
+      const score = calcScore(i + 1, expectedLocation);
       if (score > currentThreshold) {
         break;
       }
@@ -510,14 +500,56 @@
     return result;
   }
   function createPatternAlphabet(pattern) {
-    let mask = {};
+    const mask = {};
     for (let i = 0, len = pattern.length; i < len; i += 1) {
       const char = pattern.charAt(i);
       mask[char] = (mask[char] || 0) | 1 << len - i - 1;
     }
     return mask;
   }
-  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, "") : (str) => str;
+  function mergeIndices(indices) {
+    if (indices.length <= 1) return indices;
+    indices.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+    const merged = [indices[0]];
+    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);
+      }
+    }
+    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,
@@ -573,11 +605,15 @@
       }
     }
     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) {
-        let result2 = {
+        const result2 = {
           isMatch: true,
           score: 0
         };
@@ -594,11 +630,19 @@
         minMatchCharLength,
         ignoreLocation
       } = this.options;
-      let allIndices = [];
+      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,
@@ -612,15 +656,15 @@
         }
         totalScore += score;
         if (isMatch && indices) {
-          allIndices = [...allIndices, ...indices];
+          allIndices.push(...indices);
         }
       });
-      let result = {
+      const result = {
         isMatch: hasMatches,
         score: hasMatches ? totalScore / this.chunks.length : 1
       };
       if (hasMatches && includeMatches) {
-        result.indices = allIndices;
+        result.indices = mergeIndices(allIndices);
       }
       return result;
     }
@@ -635,7 +679,12 @@
     static isSingleMatch(pattern) {
       return getMatch(pattern, this.singleRegex);
     }
-    search() {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    search(_text) {
+      return {
+        isMatch: false,
+        score: 1
+      };
     }
   }
   function getMatch(pattern, exp) {
@@ -843,30 +892,58 @@
       };
     }
   }
-  const searchers = [
-    ExactMatch,
-    IncludeMatch,
-    PrefixExactMatch,
-    InversePrefixExactMatch,
-    InverseSuffixExactMatch,
-    SuffixExactMatch,
-    InverseExactMatch,
-    FuzzyMatch
-  ];
+  const searchers = [ExactMatch, IncludeMatch, PrefixExactMatch, InversePrefixExactMatch, InverseSuffixExactMatch, SuffixExactMatch, InverseExactMatch, FuzzyMatch];
   const searchersLen = searchers.length;
-  const SPACE_RE = / +(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/;
+  const ESCAPED_PIPE = "\0";
   const OR_TOKEN = "|";
+  function tokenize(pattern) {
+    const tokens = [];
+    const len = pattern.length;
+    let i = 0;
+    while (i < len) {
+      while (i < len && pattern[i] === " ") i++;
+      if (i >= len) break;
+      let j = i;
+      while (j < len && pattern[j] !== " " && pattern[j] !== '"') j++;
+      if (j < len && pattern[j] === '"') {
+        j++;
+        while (j < len) {
+          if (pattern[j] === '"') {
+            const next = j + 1;
+            if (next >= len || pattern[next] === " ") {
+              j++;
+              break;
+            }
+            if (pattern[next] === "$" && (next + 1 >= len || pattern[next + 1] === " ")) {
+              j += 2;
+              break;
+            }
+          }
+          j++;
+        }
+        tokens.push(pattern.substring(i, j));
+        i = j;
+      } else {
+        while (j < len && pattern[j] !== " ") j++;
+        tokens.push(pattern.substring(i, j));
+        i = j;
+      }
+    }
+    return tokens;
+  }
   function parseQuery(pattern, options = {}) {
-    return pattern.split(OR_TOKEN).map((item) => {
-      let query = item.trim().split(SPACE_RE).filter((item2) => item2 && !!item2.trim());
-      let results = [];
+    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());
+      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];
-          let token = searcher.isMultiMatch(queryItem);
+          const token = searcher.isMultiMatch(queryItem);
           if (token) {
             results.push(new searcher(token, options));
             found = true;
@@ -878,7 +955,7 @@
         idx = -1;
         while (++idx < searchersLen) {
           const searcher = searchers[idx];
-          let token = searcher.isSingleMatch(queryItem);
+          const token = searcher.isSingleMatch(queryItem);
           if (token) {
             results.push(new searcher(token, options));
             break;
@@ -921,6 +998,9 @@
     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) {
@@ -929,26 +1009,39 @@
           score: 1
         };
       }
-      const { includeMatches, isCaseSensitive, ignoreDiacritics } = this.options;
+      const {
+        includeMatches,
+        isCaseSensitive,
+        ignoreDiacritics
+      } = this.options;
       text = isCaseSensitive ? text : text.toLowerCase();
       text = ignoreDiacritics ? stripDiacritics(text) : text;
       let numMatches = 0;
-      let allIndices = [];
+      const allIndices = [];
       let totalScore = 0;
+      let hasInverse = false;
       for (let i = 0, qLen = query.length; i < qLen; i += 1) {
         const searchers2 = 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);
+          const {
+            isMatch,
+            indices,
+            score
+          } = searcher.search(text);
           if (isMatch) {
             numMatches += 1;
             totalScore += score;
+            const type = searcher.constructor.type;
+            if (type.startsWith("inverse")) {
+              hasInverse = true;
+            }
             if (includeMatches) {
-              const type = searcher.constructor.type;
               if (MultiMatchSet.has(type)) {
-                allIndices = [...allIndices, ...indices];
+                allIndices.push(...indices);
               } else {
                 allIndices.push(indices);
               }
@@ -957,16 +1050,20 @@
             totalScore = 0;
             numMatches = 0;
             allIndices.length = 0;
+            hasInverse = false;
             break;
           }
         }
         if (numMatches) {
-          let result = {
+          const result = {
             isMatch: true,
             score: totalScore / numMatches
           };
+          if (hasInverse) {
+            result.hasInverse = true;
+          }
           if (includeMatches) {
-            result.indices = allIndices;
+            result.indices = mergeIndices(allIndices);
           }
           return result;
         }
@@ -983,7 +1080,7 @@
   }
   function createSearcher(pattern, options) {
     for (let i = 0, len = registeredSearchers.length; i < len; i += 1) {
-      let searcherClass = registeredSearchers[i];
+      const searcherClass = registeredSearchers[i];
       if (searcherClass.condition(pattern, options)) {
         return new searcherClass(pattern, options);
       }
@@ -1006,9 +1103,21 @@
       [key]: query[key]
     }))
   });
-  function parse(query, options, { auto = true } = {}) {
+  function parse(query, options, {
+    auto = true
+  } = {}) {
     const next = (query2) => {
-      let keys = Object.keys(query2);
+      if (isString(query2)) {
+        const obj = {
+          keyId: null,
+          pattern: query2
+        };
+        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));
@@ -1028,7 +1137,7 @@
         }
         return obj;
       }
-      let node = {
+      const node = {
         children: [],
         operator: keys[0]
       };
@@ -1047,19 +1156,85 @@
     }
     return next(query);
   }
-  function computeScore(results, { ignoreFieldNorm = Config.ignoreFieldNorm }) {
+  function computeScoreSingle(matches, {
+    ignoreFieldNorm = Config.ignoreFieldNorm
+  }) {
+    let totalScore = 1;
+    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
+  }) {
     results.forEach((result) => {
-      let totalScore = 1;
-      result.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)
-        );
+      result.score = computeScoreSingle(result.matches, {
+        ignoreFieldNorm
       });
-      result.score = totalScore;
     });
   }
+  class MaxHeap {
+    constructor(limit) {
+      this.limit = limit;
+      this.heap = [];
+    }
+    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) {
+        this.heap[0] = item;
+        this._sinkDown(0);
+      }
+    }
+    extractSorted(sortFn) {
+      return this.heap.sort(sortFn);
+    }
+    _bubbleUp(i) {
+      const heap = this.heap;
+      while (i > 0) {
+        const parent = i - 1 >> 1;
+        if (heap[i].score <= heap[parent].score) break;
+        const tmp = heap[i];
+        heap[i] = heap[parent];
+        heap[parent] = tmp;
+        i = parent;
+      }
+    }
+    _sinkDown(i) {
+      const heap = this.heap;
+      const len = heap.length;
+      let largest = i;
+      do {
+        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 (largest !== i) {
+          const tmp = heap[i];
+          heap[i] = heap[largest];
+          heap[largest] = tmp;
+        }
+      } while (largest !== i);
+    }
+  }
   function transformMatches(result, data) {
     const matches = result.matches;
     data.matches = [];
@@ -1070,8 +1245,11 @@
       if (!isDefined(match.indices) || !match.indices.length) {
         return;
       }
-      const { indices, value } = match;
-      let obj = {
+      const {
+        indices,
+        value
+      } = match;
+      const obj = {
         indices,
         value
       };
@@ -1095,7 +1273,9 @@
     if (includeMatches) transformers.push(transformMatches);
     if (includeScore) transformers.push(transformScore);
     return results.map((result) => {
-      const { idx } = result;
+      const {
+        idx
+      } = result;
       const data = {
         item: docs[idx],
         refIndex: idx
@@ -1108,12 +1288,174 @@
       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) || [];
+      }
+    };
+  }
+  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);
+        }
+        postings.push(posting);
+        df.set(term, (df.get(term) || 0) + 1);
+      }
+    }
+    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);
+          }
+        }
+      }
+    }
+    return {
+      terms,
+      fieldCount,
+      df
+    };
+  }
+  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);
+      }
+      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);
+        }
+        postings.push(posting);
+        index.df.set(term, (index.df.get(term) || 0) + 1);
+      }
+    }
+    if (v !== void 0) {
+      addField(v, -1, -1);
+      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);
+        }
+      }
+    }
+  }
+  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);
+        }
+      }
+    }
+  }
   class Fuse {
-    constructor(docs, options = {}, index) {
-      this.options = { ...Config, ...options };
+    // Statics are assigned in entry.ts
+    constructor(docs, options, index) {
+      this.options = {
+        ...Config,
+        ...options
+      };
       if (this.options.useExtendedSearch && false) ;
+      if (this.options.useTokenSearch && false) ;
       this._keyStore = new KeyStore(this.options.keys);
+      this._docs = docs;
+      this._myIndex = null;
+      this._invertedIndex = null;
       this.setCollection(docs, index);
+      this._lastQuery = null;
+      this._lastSearcher = null;
+    }
+    _getSearcher(query) {
+      if (this._lastQuery === query) {
+        return this._lastSearcher;
+      }
+      const opts = this._invertedIndex ? {
+        ...this.options,
+        _invertedIndex: this._invertedIndex
+      } : this.options;
+      const searcher = createSearcher(query, opts);
+      this._lastQuery = query;
+      this._lastSearcher = searcher;
+      return searcher;
     }
     setCollection(docs, index) {
       this._docs = docs;
@@ -1124,6 +1466,13 @@
         getFn: this.options.getFn,
         fieldNormWeight: this.options.fieldNormWeight
       });
+      if (this.options.useTokenSearch) {
+        const analyzer = createAnalyzer({
+          isCaseSensitive: this.options.isCaseSensitive,
+          ignoreDiacritics: this.options.ignoreDiacritics
+        });
+        this._invertedIndex = buildInvertedIndex(this._myIndex.records, this._myIndex.keys.length, analyzer);
+      }
     }
     add(doc) {
       if (!isDefined(doc)) {
@@ -1131,28 +1480,52 @@
       }
       this._docs.push(doc);
       this._myIndex.add(doc);
+      if (this._invertedIndex) {
+        const record = this._myIndex.records[this._myIndex.records.length - 1];
+        const analyzer = createAnalyzer({
+          isCaseSensitive: this.options.isCaseSensitive,
+          ignoreDiacritics: this.options.ignoreDiacritics
+        });
+        addToInvertedIndex(this._invertedIndex, record, this._myIndex.keys.length, analyzer);
+      }
     }
     remove(predicate = () => false) {
       const results = [];
+      const indicesToRemove = [];
       for (let i = 0, len = this._docs.length; i < len; i += 1) {
-        const doc = this._docs[i];
-        if (predicate(doc, i)) {
-          this.removeAt(i);
-          i -= 1;
-          len -= 1;
-          results.push(doc);
+        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);
+        }
+        this._myIndex.removeAll(indicesToRemove);
       }
       return results;
     }
     removeAt(idx) {
-      this._docs.splice(idx, 1);
+      if (this._invertedIndex) {
+        removeFromInvertedIndex(this._invertedIndex, idx);
+      }
+      const doc = this._docs.splice(idx, 1)[0];
       this._myIndex.removeAt(idx);
+      return doc;
     }
     getIndex() {
       return this._myIndex;
     }
-    search(query, { limit = -1 } = {}) {
+    search(query, options) {
+      const {
+        limit = -1
+      } = options || {};
       const {
         includeMatches,
         includeScore,
@@ -1160,34 +1533,92 @@
         sortFn,
         ignoreFieldNorm
       } = this.options;
-      let results = isString(query) ? isString(this._docs[0]) ? this._searchStringList(query) : this._searchObjectList(query) : this._searchLogical(query);
-      computeScore(results, { ignoreFieldNorm });
-      if (shouldSort) {
-        results.sort(sortFn);
+      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);
+        }
+        return docs;
       }
-      if (isNumber(limit) && limit > -1) {
-        results = results.slice(0, limit);
+      const useHeap = isNumber(limit) && limit > 0 && isString(query);
+      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, {
+          ignoreFieldNorm
+        });
+        if (shouldSort) {
+          results.sort(sortFn);
+        }
+        if (isNumber(limit) && limit > -1) {
+          results = results.slice(0, limit);
+        }
       }
       return format(results, this._docs, {
         includeMatches,
         includeScore
       });
     }
-    _searchStringList(query) {
-      const searcher = createSearcher(query, this.options);
-      const { records } = this._myIndex;
-      const results = [];
-      records.forEach(({ v: text, i: idx, n: norm2 }) => {
+    _searchStringList(query, {
+      heap,
+      ignoreFieldNorm
+    } = {}) {
+      const searcher = this._getSearcher(query);
+      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);
+        const {
+          isMatch,
+          score,
+          indices
+        } = searcher.searchIn(text);
         if (isMatch) {
-          results.push({
+          const result = {
             item: text,
             idx,
-            matches: [{ score, value: text, norm: norm2, indices }]
-          });
+            matches: [{
+              score,
+              value: text,
+              norm: norm2,
+              indices
+            }]
+          };
+          if (heap) {
+            result.score = computeScoreSingle(result.matches, {
+              ignoreFieldNorm
+            });
+            if (heap.shouldInsert(result.score)) {
+              heap.insert(result);
+            }
+          } else {
+            results.push(result);
+          }
         }
       });
       return results;
@@ -1195,94 +1626,171 @@
     _searchLogical(query) {
       const expression = parse(query, this.options);
       const evaluate = (node, item, idx) => {
-        if (!node.children) {
-          const { keyId, searcher } = node;
-          const matches = this._findMatches({
-            key: this._keyStore.get(keyId),
-            value: this._myIndex.getValueForItemAtKeyId(item, keyId),
+        if (!("children" in node)) {
+          const {
+            keyId,
             searcher
-          });
+          } = node;
+          let matches;
+          if (keyId === null) {
+            matches = [];
+            this._myIndex.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
-              }
-            ];
+            return [{
+              idx,
+              item,
+              matches
+            }];
           }
           return [];
         }
+        const {
+          children,
+          operator
+        } = node;
         const res = [];
-        for (let i = 0, len = node.children.length; i < len; i += 1) {
-          const child = node.children[i];
+        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 (node.operator === LogicalOperator.AND) {
+          } else if (operator === LogicalOperator.AND) {
             return [];
           }
         }
         return res;
       };
       const records = this._myIndex.records;
-      const resultMap = {};
+      const resultMap = /* @__PURE__ */ new Map();
       const results = [];
-      records.forEach(({ $: item, i: idx }) => {
+      records.forEach(({
+        $: item,
+        i: idx
+      }) => {
         if (isDefined(item)) {
-          let expResults = evaluate(expression, item, idx);
+          const expResults = evaluate(expression, item, idx);
           if (expResults.length) {
-            if (!resultMap[idx]) {
-              resultMap[idx] = { idx, item, matches: [] };
-              results.push(resultMap[idx]);
+            if (!resultMap.has(idx)) {
+              resultMap.set(idx, {
+                idx,
+                item,
+                matches: []
+              });
+              results.push(resultMap.get(idx));
             }
-            expResults.forEach(({ matches }) => {
-              resultMap[idx].matches.push(...matches);
+            expResults.forEach(({
+              matches
+            }) => {
+              resultMap.get(idx).matches.push(...matches);
             });
           }
         }
       });
       return results;
     }
-    _searchObjectList(query) {
-      const searcher = createSearcher(query, this.options);
-      const { keys, records } = this._myIndex;
-      const results = [];
-      records.forEach(({ $: item, i: idx }) => {
+    // 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
+    } = {}) {
+      const searcher = this._getSearcher(query);
+      const {
+        keys,
+        records
+      } = this._myIndex;
+      const results = heap ? null : [];
+      records.forEach(({
+        $: item,
+        i: idx
+      }) => {
         if (!isDefined(item)) {
           return;
         }
-        let matches = [];
+        const matches = [];
+        let anyKeyFailed = false;
+        let hasInverse = false;
         keys.forEach((key, keyIndex) => {
-          matches.push(
-            ...this._findMatches({
-              key,
-              value: item[keyIndex],
-              searcher
-            })
-          );
+          const keyMatches = this._findMatches({
+            key,
+            value: item[keyIndex],
+            searcher
+          });
+          if (keyMatches.length) {
+            matches.push(...keyMatches);
+            if (keyMatches[0].hasInverse) {
+              hasInverse = true;
+            }
+          } else {
+            anyKeyFailed = true;
+          }
         });
+        if (hasInverse && anyKeyFailed) {
+          return;
+        }
         if (matches.length) {
-          results.push({
+          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);
+          }
         }
       });
       return results;
     }
-    _findMatches({ key, value, searcher }) {
+    _findMatches({
+      key,
+      value,
+      searcher
+    }) {
       if (!isDefined(value)) {
         return [];
       }
-      let matches = [];
+      const matches = [];
       if (isArray(value)) {
-        value.forEach(({ v: text, i: idx, n: norm2 }) => {
+        value.forEach(({
+          v: text,
+          i: idx,
+          n: norm2
+        }) => {
           if (!isDefined(text)) {
             return;
           }
-          const { isMatch, score, indices } = searcher.searchIn(text);
+          const {
+            isMatch,
+            score,
+            indices,
+            hasInverse
+          } = searcher.searchIn(text);
           if (isMatch) {
             matches.push({
               score,
@@ -1290,30 +1798,134 @@
               value: text,
               idx,
               norm: norm2,
-              indices
+              indices,
+              hasInverse
             });
           }
         });
       } else {
-        const { v: text, n: norm2 } = value;
-        const { isMatch, score, indices } = searcher.searchIn(text);
+        const {
+          v: text,
+          n: norm2
+        } = value;
+        const {
+          isMatch,
+          score,
+          indices,
+          hasInverse
+        } = searcher.searchIn(text);
         if (isMatch) {
-          matches.push({ score, key, value: text, norm: norm2, indices });
+          matches.push({
+            score,
+            key,
+            value: text,
+            norm: norm2,
+            indices,
+            hasInverse
+          });
         }
       }
       return matches;
     }
   }
-  Fuse.version = "7.1.0";
+  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);
+          }
+        }
+      }
+      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);
+      }
+      return searchResult;
+    }
+  }
+  Fuse.version = "7.3.0";
   Fuse.createIndex = createIndex;
   Fuse.parseIndex = parseIndex;
   Fuse.config = Config;
+  Fuse.match = function(pattern, text, options) {
+    const searcher = createSearcher(pattern, {
+      ...Config,
+      ...options
+    });
+    return searcher.searchIn(text);
+  };
   {
     Fuse.parseQuery = parse;
   }
   {
     register(ExtendedSearch);
   }
+  {
+    register(TokenSearch);
+  }
+  Fuse.use = function(...plugins) {
+    plugins.forEach((plugin) => register(plugin));
+  };
   const version = "0.3.5";
   const packageJson = {
     version