@tscircuit/cli 0.1.1467 → 0.1.1468

package/dist/cli/main.js

@@ -7797,6 +7797,18 @@ var require_semver = __commonJS((exports2, module2) => {
   var { safeRe: re, t } = require_re();
   var parseOptions = require_parse_options();
   var { compareIdentifiers } = require_identifiers();
+  var isPrereleaseIdentifier = (prerelease, identifier) => {
+    const identifiers = identifier.split(".");
+    if (identifiers.length > prerelease.length) {
+      return false;
+    }
+    for (let i = 0;i < identifiers.length; i++) {
+      if (compareIdentifiers(prerelease[i], identifiers[i]) !== 0) {
+        return false;
+      }
+    }
+    return true;
+  };
 
   class SemVer {
     constructor(version2, options) {
@@ -8036,8 +8048,9 @@ var require_semver = __commonJS((exports2, module2) => {
             if (identifierBase === false) {
               prerelease = [identifier];
             }
-            if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
-              if (isNaN(this.prerelease[1])) {
+            if (isPrereleaseIdentifier(this.prerelease, identifier)) {
+              const prereleaseBase = this.prerelease[identifier.split(".").length];
+              if (isNaN(prereleaseBase)) {
                 this.prerelease = prerelease;
               }
             } else {
@@ -8508,6 +8521,7 @@ var require_range = __commonJS((exports2, module2) => {
       return this.range;
     }
     parseRange(range) {
+      range = range.replace(BUILDSTRIPRE, "");
       const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
       const memoKey = memoOpts + ":" + range;
       const cached = cache.get(memoKey);
@@ -8589,12 +8603,14 @@ var require_range = __commonJS((exports2, module2) => {
   var SemVer = require_semver();
   var {
     safeRe: re,
+    src,
     t,
     comparatorTrimReplace,
     tildeTrimReplace,
     caretTrimReplace
   } = require_re();
   var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
+  var BUILDSTRIPRE = new RegExp(src[t.BUILD], "g");
   var isNullSet = (c) => c.value === "<0.0.0-0";
   var isAny = (c) => c.value === "";
   var isSatisfiable = (comparators, options) => {
@@ -8623,6 +8639,7 @@ var require_range = __commonJS((exports2, module2) => {
     return comp;
   };
   var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+  var invalidXRangeOrder = (M, m, p) => isX(M) && !isX(m) || isX(m) && p && !isX(p);
   var replaceTildes = (comp, options) => {
     return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
   };
@@ -8682,9 +8699,9 @@ var require_range = __commonJS((exports2, module2) => {
         debug("no pr");
         if (M === "0") {
           if (m === "0") {
-            ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
+            ret = `>=${M}.${m}.${p} <${M}.${m}.${+p + 1}-0`;
           } else {
-            ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
+            ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
           }
         } else {
           ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
@@ -8703,6 +8720,9 @@ var require_range = __commonJS((exports2, module2) => {
     const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
     return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
       debug("xRange", comp, ret, gtlt, M, m, p, pr);
+      if (invalidXRangeOrder(M, m, p)) {
+        return comp;
+      }
       const xM = isX(M);
       const xm = xM || isX(m);
       const xp = xm || isX(p);
@@ -9311,7 +9331,7 @@ var require_subset = __commonJS((exports2, module2) => {
           if (higher === c && higher !== gt) {
             return false;
           }
-        } else if (gt.operator === ">=" && !satisfies(gt.semver, String(c), options)) {
+        } else if (gt.operator === ">=" && !c.test(gt.semver)) {
           return false;
         }
       }
@@ -9326,7 +9346,7 @@ var require_subset = __commonJS((exports2, module2) => {
           if (lower === c && lower !== lt) {
             return false;
           }
-        } else if (lt.operator === "<=" && !satisfies(lt.semver, String(c), options)) {
+        } else if (lt.operator === "<=" && !c.test(lt.semver)) {
           return false;
         }
       }
@@ -22721,7 +22741,7 @@ var require_isarray = __commonJS((exports2, module2) => {
   };
 });
 
-// node_modules/safe-buffer/index.js
+// node_modules/readable-stream/node_modules/safe-buffer/index.js
 var require_safe_buffer = __commonJS((exports2, module2) => {
   var buffer = __require("buffer");
   var Buffer2 = buffer.Buffer;
@@ -23575,9 +23595,64 @@ var require__stream_duplex = __commonJS((exports2, module2) => {
   };
 });
 
+// node_modules/string_decoder/node_modules/safe-buffer/index.js
+var require_safe_buffer2 = __commonJS((exports2, module2) => {
+  var buffer = __require("buffer");
+  var Buffer2 = buffer.Buffer;
+  function copyProps(src, dst) {
+    for (var key in src) {
+      dst[key] = src[key];
+    }
+  }
+  if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
+    module2.exports = buffer;
+  } else {
+    copyProps(buffer, exports2);
+    exports2.Buffer = SafeBuffer;
+  }
+  function SafeBuffer(arg, encodingOrOffset, length) {
+    return Buffer2(arg, encodingOrOffset, length);
+  }
+  copyProps(Buffer2, SafeBuffer);
+  SafeBuffer.from = function(arg, encodingOrOffset, length) {
+    if (typeof arg === "number") {
+      throw new TypeError("Argument must not be a number");
+    }
+    return Buffer2(arg, encodingOrOffset, length);
+  };
+  SafeBuffer.alloc = function(size, fill, encoding) {
+    if (typeof size !== "number") {
+      throw new TypeError("Argument must be a number");
+    }
+    var buf = Buffer2(size);
+    if (fill !== undefined) {
+      if (typeof encoding === "string") {
+        buf.fill(fill, encoding);
+      } else {
+        buf.fill(fill);
+      }
+    } else {
+      buf.fill(0);
+    }
+    return buf;
+  };
+  SafeBuffer.allocUnsafe = function(size) {
+    if (typeof size !== "number") {
+      throw new TypeError("Argument must be a number");
+    }
+    return Buffer2(size);
+  };
+  SafeBuffer.allocUnsafeSlow = function(size) {
+    if (typeof size !== "number") {
+      throw new TypeError("Argument must be a number");
+    }
+    return buffer.SlowBuffer(size);
+  };
+});
+
 // node_modules/string_decoder/lib/string_decoder.js
 var require_string_decoder = __commonJS((exports2) => {
-  var Buffer2 = require_safe_buffer().Buffer;
+  var Buffer2 = require_safe_buffer2().Buffer;
   var isEncoding = Buffer2.isEncoding || function(encoding) {
     encoding = "" + encoding;
     switch (encoding && encoding.toLowerCase()) {
@@ -100688,7 +100763,7 @@ var import_perfect_cli = __toESM2(require_dist2(), 1);
 // lib/getVersion.ts
 import { createRequire as createRequire2 } from "node:module";
 // package.json
-var version = "0.1.1466";
+var version = "0.1.1467";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -100709,7 +100784,7 @@ var package_default = {
     "@tscircuit/image-utils": "^0.0.3",
     "@tscircuit/krt-wasm": "^0.1.0",
     "@tscircuit/math-utils": "0.0.36",
-    "@tscircuit/props": "^0.0.536",
+    "@tscircuit/props": "^0.0.546",
     "@tscircuit/runframe": "^0.0.2057",
     "@tscircuit/schematic-match-adapt": "^0.0.22",
     "@types/bun": "^1.2.2",
@@ -274069,12 +274144,10 @@ function isArray(value) {
   return !Array.isArray ? getTag(value) === "[object Array]" : Array.isArray(value);
 }
 function baseToString(value) {
-  if (typeof value == "string") {
+  if (typeof value == "string")
     return value;
-  }
-  if (typeof value === "bigint") {
+  if (typeof value === "bigint")
     return value.toString();
-  }
   const result = value + "";
   return result == "0" && 1 / value == -Infinity ? "-0" : result;
 }
@@ -274106,13 +274179,14 @@ function getTag(value) {
   return value == null ? value === undefined ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(value);
 }
 var INCORRECT_INDEX_TYPE = "Incorrect 'index' type";
+var INVALID_DOC_INDEX = "Invalid doc index: must be a non-negative integer within the bounds of the docs array";
 var LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = (key) => `Invalid value for key ${key}`;
 var PATTERN_LENGTH_TOO_LARGE = (max) => `Pattern length exceeds max of ${max}.`;
 var MISSING_KEY_PROPERTY = (name) => `Missing ${name} property in key`;
 var INVALID_KEY_WEIGHT_VALUE = (key) => `Property 'weight' in key '${key}' must be a positive integer`;
+var 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.";
 var hasOwn = Object.prototype.hasOwnProperty;
-
-class KeyStore {
+var KeyStore = class {
   constructor(keys) {
     this._keys = [];
     this._keyMap = {};
@@ -274136,7 +274210,7 @@ class KeyStore {
   toJSON() {
     return JSON.stringify(this._keys);
   }
-}
+};
 function createKey(key) {
   let path67 = null;
   let id2 = null;
@@ -274148,20 +274222,18 @@ function createKey(key) {
     path67 = createKeyPath(key);
     id2 = createKeyId(key);
   } else {
-    if (!hasOwn.call(key, "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 !== undefined) {
       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)));
     }
     path67 = createKeyPath(name);
     id2 = createKeyId(name);
-    getFn = key.getFn;
+    getFn = key.getFn ?? null;
   }
   return {
     path: path67,
@@ -274181,33 +274253,28 @@ function get(obj, path67) {
   const list = [];
   let arr = false;
   const deepGet = (obj2, path68, index, arrayIndex) => {
-    if (!isDefined(obj2)) {
+    if (!isDefined(obj2))
       return;
-    }
-    if (!path68[index]) {
+    if (!path68[index])
       list.push(arrayIndex !== undefined ? {
         v: obj2,
         i: arrayIndex
       } : obj2);
-    } else {
-      const key = path68[index];
-      const value = obj2[key];
-      if (!isDefined(value)) {
+    else {
+      const value = obj2[path68[index]];
+      if (!isDefined(value))
         return;
-      }
-      if (index === path68.length - 1 && (isString2(value) || isNumber2(value) || isBoolean(value) || typeof value === "bigint")) {
+      if (index === path68.length - 1 && (isString2(value) || isNumber2(value) || isBoolean(value) || typeof value === "bigint"))
         list.push(arrayIndex !== undefined ? {
           v: toString2(value),
           i: arrayIndex
         } : toString2(value));
-      } else if (isArray(value)) {
+      else if (isArray(value)) {
         arr = true;
-        for (let i2 = 0, len = value.length;i2 < len; i2 += 1) {
+        for (let i2 = 0, len = value.length;i2 < len; i2 += 1)
           deepGet(value[i2], path68, index + 1, i2);
-        }
-      } else if (path68.length) {
+      } else if (path68.length)
         deepGet(value, path68, index + 1, arrayIndex);
-      }
     }
   };
   deepGet(obj, isString2(path67) ? path67.split(".") : path67, 0);
@@ -274234,6 +274301,8 @@ var FuzzyOptions = {
 var AdvancedOptions = {
   useExtendedSearch: false,
   useTokenSearch: false,
+  tokenize: undefined,
+  tokenMatch: "any",
   getFn: get,
   ignoreLocation: false,
   ignoreFieldNorm: false,
@@ -274245,18 +274314,24 @@ var Config = Object.freeze({
   ...FuzzyOptions,
   ...AdvancedOptions
 });
-var SPACE = /[^ ]+/g;
 function norm(weight = 1, mantissa = 3) {
-  const cache = new Map;
+  const cache = /* @__PURE__ */ new Map;
   const m3 = Math.pow(10, mantissa);
   return {
     get(value) {
-      const numTokens = value.match(SPACE).length;
-      if (cache.has(numTokens)) {
+      let numTokens = 1;
+      let inSpace = false;
+      for (let i2 = 0;i2 < value.length; i2++)
+        if (value.charCodeAt(i2) === 32) {
+          if (!inSpace) {
+            numTokens++;
+            inSpace = true;
+          }
+        } else
+          inSpace = false;
+      if (cache.has(numTokens))
         return cache.get(numTokens);
-      }
-      const norm2 = 1 / Math.pow(numTokens, 0.5 * weight);
-      const n3 = parseFloat(Math.round(norm2 * m3) / m3);
+      const n3 = Math.round(m3 / Math.pow(numTokens, 0.5 * weight)) / m3;
       cache.set(numTokens, n3);
       return n3;
     },
@@ -274265,12 +274340,8 @@ function norm(weight = 1, mantissa = 3) {
     }
   };
 }
-
-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;
@@ -274293,41 +274364,69 @@ class FuseIndex {
     });
   }
   create() {
-    if (this.isCreated || !this.docs.length) {
+    if (this.isCreated || !this.docs.length)
       return;
-    }
     this.isCreated = true;
-    if (isString2(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 (isString2(this.docs[0]))
+      for (let i2 = 0;i2 < len; i2++) {
+        const record = this._createStringRecord(this.docs[i2], i2);
+        if (record)
+          this.records[recordCount++] = record;
+      }
+    else
+      for (let i2 = 0;i2 < len; i2++)
+        this.records[recordCount++] = this._createObjectRecord(this.docs[i2], i2);
+    this.records.length = recordCount;
     this.norm.clear();
   }
-  add(doc) {
-    const idx = this.size();
+  add(doc, docIndex) {
+    if (!Number.isInteger(docIndex) || docIndex < 0)
+      throw new Error(INVALID_DOC_INDEX);
     if (isString2(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;
   }
   removeAt(idx) {
-    this.records.splice(idx, 1);
-    for (let i2 = idx, len = this.size();i2 < len; i2 += 1) {
-      this.records[i2].i -= 1;
-    }
+    if (!Number.isInteger(idx) || idx < 0)
+      throw new Error(INVALID_DOC_INDEX);
+    for (let i2 = 0, len = this.records.length;i2 < len; i2 += 1)
+      if (this.records[i2].i === idx) {
+        this.records.splice(i2, 1);
+        break;
+      }
+    for (let i2 = 0, len = this.records.length;i2 < len; i2 += 1)
+      if (this.records[i2].i > idx)
+        this.records[i2].i -= 1;
   }
   removeAll(indices) {
-    for (let i2 = indices.length - 1;i2 >= 0; i2 -= 1) {
-      this.records.splice(indices[i2], 1);
-    }
-    for (let i2 = 0, len = this.records.length;i2 < len; i2 += 1) {
-      this.records[i2].i = i2;
+    const toRemove = /* @__PURE__ */ new Set;
+    for (const v3 of indices)
+      if (Number.isInteger(v3) && v3 >= 0)
+        toRemove.add(v3);
+    if (toRemove.size === 0)
+      return;
+    this.records = this.records.filter((r4) => !toRemove.has(r4.i));
+    const sorted = Array.from(toRemove).sort((a2, b) => a2 - b);
+    for (const record of this.records) {
+      let lo3 = 0;
+      let hi3 = sorted.length;
+      while (lo3 < hi3) {
+        const mid = lo3 + hi3 >>> 1;
+        if (sorted[mid] < record.i)
+          lo3 = mid + 1;
+        else
+          hi3 = mid;
+      }
+      record.i -= lo3;
     }
   }
   getValueForItemAtKeyId(item, keyId) {
@@ -274336,34 +274435,31 @@ class FuseIndex {
   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 i2 = 0, len = value.length;i2 < len; i2 += 1) {
           const item = value[i2];
-          if (!isDefined(item)) {
+          if (!isDefined(item))
             continue;
-          }
           if (isString2(item)) {
             if (!isBlank(item)) {
               const subRecord = {
@@ -274393,23 +274489,17 @@ class FuseIndex {
         };
         record.$[keyIndex] = subRecord;
       }
-    });
-    this.records.push(record);
+    }
+    return record;
   }
   toJSON() {
     return {
-      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
@@ -274419,14 +274509,8 @@ function createIndex(keys, docs, {
   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
@@ -274442,34 +274526,22 @@ function convertMaskToIndices(matchmask = [], minMatchCharLength = Config.minMat
   let i2 = 0;
   for (let len = matchmask.length;i2 < len; i2 += 1) {
     const match = matchmask[i2];
-    if (match && start === -1) {
+    if (match && start === -1)
       start = i2;
-    } else if (!match && start !== -1) {
+    else if (!match && start !== -1) {
       end = i2 - 1;
-      if (end - start + 1 >= minMatchCharLength) {
+      if (end - start + 1 >= minMatchCharLength)
         indices.push([start, end]);
-      }
       start = -1;
     }
   }
-  if (matchmask[i2 - 1] && i2 - start >= minMatchCharLength) {
+  if (matchmask[i2 - 1] && i2 - start >= minMatchCharLength)
     indices.push([start, i2 - 1]);
-  }
   return indices;
 }
-var MAX_BITS = 32;
-function search(text, pattern, patternAlphabet, {
-  location = Config.location,
-  distance: distance7 = 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: distance7 = 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));
@@ -274502,18 +274574,17 @@ function search(text, pattern, patternAlphabet, {
   bestLocation = -1;
   let lastBitArr = [];
   let finalScore = 1;
+  let bestErrors = 0;
   let binMax = patternLen + textLen;
   const mask = 1 << patternLen - 1;
   for (let i2 = 0;i2 < patternLen; i2 += 1) {
     let binMin = 0;
     let binMid = binMax;
     while (binMin < binMid) {
-      const score2 = calcScore(i2, expectedLocation + binMid);
-      if (score2 <= currentThreshold) {
+      if (calcScore(i2, expectedLocation + binMid) <= currentThreshold)
         binMin = binMid;
-      } else {
+      else
         binMax = binMid;
-      }
       binMid = Math.floor((binMax - binMin) / 2 + binMin);
     }
     binMax = binMid;
@@ -274524,42 +274595,41 @@ function search(text, pattern, patternAlphabet, {
     for (let j4 = finish;j4 >= start; j4 -= 1) {
       const currentLocation = j4 - 1;
       const charMatch = patternAlphabet[text[currentLocation]];
-      if (computeMatches) {
-        matchMask[currentLocation] = +!!charMatch;
-      }
       bitArr[j4] = (bitArr[j4 + 1] << 1 | 1) & charMatch;
-      if (i2) {
+      if (i2)
         bitArr[j4] |= (lastBitArr[j4 + 1] | lastBitArr[j4]) << 1 | 1 | lastBitArr[j4 + 1];
-      }
       if (bitArr[j4] & mask) {
         finalScore = calcScore(i2, currentLocation);
         if (finalScore <= currentThreshold) {
           currentThreshold = finalScore;
           bestLocation = currentLocation;
-          if (bestLocation <= expectedLocation) {
+          bestErrors = i2;
+          if (bestLocation <= expectedLocation)
             break;
-          }
           start = Math.max(1, 2 * expectedLocation - bestLocation);
         }
       }
     }
-    const score = calcScore(i2 + 1, expectedLocation);
-    if (score > currentThreshold) {
+    if (calcScore(i2 + 1, expectedLocation) > currentThreshold)
       break;
-    }
     lastBitArr = bitArr;
   }
+  if (computeMatches && bestLocation >= 0) {
+    const matchEnd = Math.min(textLen - 1, bestLocation + patternLen - 1 + bestErrors);
+    for (let k4 = bestLocation;k4 <= matchEnd; k4 += 1)
+      if (patternAlphabet[text[k4]])
+        matchMask[k4] = 1;
+  }
   const result = {
     isMatch: bestLocation >= 0,
     score: Math.max(0.001, finalScore)
   };
   if (computeMatches) {
     const indices = convertMaskToIndices(matchMask, minMatchCharLength);
-    if (!indices.length) {
+    if (!indices.length)
       result.isMatch = false;
-    } else if (includeMatches) {
+    else if (includeMatches)
       result.indices = indices;
-    }
   }
   return result;
 }
@@ -274579,11 +274649,10 @@ function mergeIndices(indices) {
   for (let i2 = 1, len = indices.length;i2 < len; i2 += 1) {
     const last = merged[merged.length - 1];
     const curr = indices[i2];
-    if (curr[0] <= last[1] + 1) {
+    if (curr[0] <= last[1] + 1)
       last[1] = Math.max(last[1], curr[1]);
-    } else {
+    else
       merged.push(curr);
-    }
   }
   return merged;
 }
@@ -274602,20 +274671,9 @@ var NON_DECOMPOSABLE_MAP = {
   "ß": "ss"
 };
 var NON_DECOMPOSABLE_RE = new RegExp("[" + Object.keys(NON_DECOMPOSABLE_MAP).join("") + "]", "g");
-var 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, (ch3) => NON_DECOMPOSABLE_MAP[ch3]) : (str) => str;
-
-class BitapSearch {
-  constructor(pattern, {
-    location = Config.location,
-    threshold = Config.threshold,
-    distance: distance7 = Config.distance,
-    includeMatches = Config.includeMatches,
-    findAllMatches = Config.findAllMatches,
-    minMatchCharLength = Config.minMatchCharLength,
-    isCaseSensitive = Config.isCaseSensitive,
-    ignoreDiacritics = Config.ignoreDiacritics,
-    ignoreLocation = Config.ignoreLocation
-  } = {}) {
+var 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, (ch3) => NON_DECOMPOSABLE_MAP[ch3]) : (str) => str;
+var BitapSearch = class {
+  constructor(pattern, { location = Config.location, threshold = Config.threshold, distance: distance7 = Config.distance, includeMatches = Config.includeMatches, findAllMatches = Config.findAllMatches, minMatchCharLength = Config.minMatchCharLength, isCaseSensitive = Config.isCaseSensitive, ignoreDiacritics = Config.ignoreDiacritics, ignoreLocation = Config.ignoreLocation } = {}) {
     this.options = {
       location,
       threshold,
@@ -274631,9 +274689,8 @@ class BitapSearch {
     pattern = ignoreDiacritics ? stripDiacritics(pattern) : pattern;
     this.pattern = pattern;
     this.chunks = [];
-    if (!this.pattern.length) {
+    if (!this.pattern.length)
       return;
-    }
     const addChunk = (pattern2, startIndex) => {
       this.chunks.push({
         pattern: pattern2,
@@ -274642,28 +274699,23 @@ class BitapSearch {
       });
     };
     const len = this.pattern.length;
-    if (len > MAX_BITS) {
+    if (len > 32) {
       let i2 = 0;
-      const remainder = len % MAX_BITS;
+      const remainder = len % 32;
       const end = len - remainder;
       while (i2 < end) {
-        addChunk(this.pattern.substr(i2, MAX_BITS), i2);
-        i2 += MAX_BITS;
+        addChunk(this.pattern.substr(i2, 32), i2);
+        i2 += 32;
       }
       if (remainder) {
-        const startIndex = len - MAX_BITS;
+        const startIndex = len - 32;
         addChunk(this.pattern.substr(startIndex), startIndex);
       }
-    } else {
+    } 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) {
@@ -274671,32 +274723,16 @@ class BitapSearch {
         isMatch: true,
         score: 0
       };
-      if (includeMatches) {
+      if (includeMatches)
         result2.indices = [[0, text.length - 1]];
-      }
       return result2;
     }
-    const {
-      location,
-      distance: distance7,
-      threshold,
-      findAllMatches,
-      minMatchCharLength,
-      ignoreLocation
-    } = this.options;
+    const { location, distance: distance7, 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: distance7,
         threshold,
@@ -274705,257 +274741,172 @@ class BitapSearch {
         includeMatches,
         ignoreLocation
       });
-      if (isMatch) {
+      if (isMatch)
         hasMatches = true;
-      }
       totalScore += score;
-      if (isMatch && indices) {
+      if (isMatch && indices)
         allIndices.push(...indices);
-      }
     });
     const result = {
       isMatch: hasMatches,
       score: hasMatches ? totalScore / this.chunks.length : 1
     };
-    if (hasMatches && includeMatches) {
+    if (hasMatches && includeMatches)
       result.indices = mergeIndices(allIndices);
-    }
     return result;
   }
+};
+var MULTI_MATCH_TYPES = 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);
-  }
-  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: distance7 = 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: distance7,
-      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]);
+var 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
-    };
   }
-}
-var searchers = [ExactMatch, IncludeMatch, PrefixExactMatch, InversePrefixExactMatch, InverseSuffixExactMatch, SuffixExactMatch, InverseExactMatch, FuzzyMatch];
-var searchersLen = searchers.length;
+];
+var matchersLen = matchers.length;
 var ESCAPED_PIPE = "\x00";
 var OR_TOKEN = "|";
 function tokenize3(pattern) {
@@ -274997,33 +274948,34 @@ function tokenize3(pattern) {
   }
   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 = tokenize3(restored.trim()).filter((item2) => item2 && !!item2.trim());
+  return pattern.replace(/\\\|/g, ESCAPED_PIPE).split(OR_TOKEN).map((item) => {
+    const query = tokenize3(item.replace(/\u0000/g, "|").trim()).filter((item2) => item2 && !!item2.trim());
     const results = [];
     for (let i2 = 0, len = query.length;i2 < len; i2 += 1) {
       const queryItem = query[i2];
       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) {
+      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;
         }
       }
@@ -275031,20 +274983,8 @@ function parseQuery(pattern, options = {}) {
     return results;
   });
 }
-var MultiMatchSet = 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: distance7 = 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: distance7 = Config.distance } = {}) {
     this.query = null;
     this.options = {
       isCaseSensitive,
@@ -275067,17 +275007,12 @@ class ExtendedSearch {
   }
   searchIn(text) {
     const query = this.query;
-    if (!query) {
+    if (!query)
       return {
         isMatch: false,
         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;
@@ -275085,31 +275020,23 @@ class ExtendedSearch {
     let totalScore = 0;
     let hasInverse = false;
     for (let i2 = 0, qLen = query.length;i2 < qLen; i2 += 1) {
-      const searchers2 = query[i2];
+      const searchers = query[i2];
       allIndices.length = 0;
       numMatches = 0;
       hasInverse = false;
-      for (let j4 = 0, pLen = searchers2.length;j4 < pLen; j4 += 1) {
-        const searcher = searchers2[j4];
-        const {
-          isMatch,
-          indices,
-          score
-        } = searcher.search(text);
+      for (let j4 = 0, pLen = searchers.length;j4 < pLen; j4 += 1) {
+        const matcher = searchers[j4];
+        const { isMatch, indices, score } = matcher.search(text);
         if (isMatch) {
           numMatches += 1;
           totalScore += score;
-          const type = searcher.constructor.type;
-          if (type.startsWith("inverse")) {
+          if (isInverse(matcher.type))
             hasInverse = true;
-          }
-          if (includeMatches) {
-            if (MultiMatchSet.has(type)) {
+          if (includeMatches)
+            if (MULTI_MATCH_TYPES.has(matcher.type))
               allIndices.push(...indices);
-            } else {
+            else
               allIndices.push(indices);
-            }
-          }
         } else {
           totalScore = 0;
           numMatches = 0;
@@ -275123,12 +275050,10 @@ class ExtendedSearch {
           isMatch: true,
           score: totalScore / numMatches
         };
-        if (hasInverse) {
+        if (hasInverse)
           result.hasInverse = true;
-        }
-        if (includeMatches) {
+        if (includeMatches)
           result.indices = mergeIndices(allIndices);
-        }
         return result;
       }
     }
@@ -275137,7 +275062,7 @@ class ExtendedSearch {
       score: 1
     };
   }
-}
+};
 var registeredSearchers = [];
 function register2(...args) {
   registeredSearchers.push(...args);
@@ -275145,9 +275070,8 @@ function register2(...args) {
 function createSearcher(pattern, options) {
   for (let i2 = 0, len = registeredSearchers.length;i2 < len; i2 += 1) {
     const searcherClass = registeredSearchers[i2];
-    if (searcherClass.condition(pattern, options)) {
+    if (searcherClass.condition(pattern, options))
       return new searcherClass(pattern, options);
-    }
   }
   return new BitapSearch(pattern, options);
 }
@@ -275162,43 +275086,33 @@ var KeyType = {
 var isExpression = (query) => !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]);
 var isPath = (query) => !!query[KeyType.PATH];
 var isLeaf = (query) => !isArray(query) && isObject3(query) && !isExpression(query);
-var convertToExplicit = (query) => ({
-  [LogicalOperator.AND]: Object.keys(query).map((key) => ({
-    [key]: query[key]
-  }))
-});
-function parse3(query, options, {
-  auto = true
-} = {}) {
+var convertToExplicit = (query) => ({ [LogicalOperator.AND]: Object.keys(query).map((key) => ({ [key]: query[key] })) });
+function parse3(query, options, { auto = true } = {}) {
   const next = (query2) => {
     if (isString2(query2)) {
       const obj = {
         keyId: null,
         pattern: query2
       };
-      if (auto) {
+      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)) {
+    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 (!isString2(pattern)) {
+      if (!isString2(pattern))
         throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key));
-      }
       const obj = {
         keyId: createKeyId(key),
         pattern
       };
-      if (auto) {
+      if (auto)
         obj.searcher = createSearcher(pattern, options);
-      }
       return obj;
     }
     const node = {
@@ -275207,44 +275121,31 @@ function parse3(query, options, {
     };
     keys.forEach((key) => {
       const value = query2[key];
-      if (isArray(value)) {
+      if (isArray(value))
         value.forEach((item) => {
           node.children.push(next(item));
         });
-      }
     });
     return node;
   };
-  if (!isExpression(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 {
+var MaxHeap = class {
   constructor(limit) {
     this.limit = limit;
     this.heap = [];
@@ -275287,12 +275188,10 @@ class MaxHeap {
       i2 = largest;
       const left = 2 * i2 + 1;
       const right = 2 * i2 + 2;
-      if (left < len && heap[left].score > heap[largest].score) {
+      if (left < len && heap[left].score > heap[largest].score)
         largest = left;
-      }
-      if (right < len && heap[right].score > heap[largest].score) {
+      if (right < len && heap[right].score > heap[largest].score)
         largest = right;
-      }
       if (largest !== i2) {
         const tmp = heap[i2];
         heap[i2] = heap[largest];
@@ -275300,207 +275199,258 @@ class MaxHeap {
       }
     } while (largest !== i2);
   }
-}
-function transformMatches(result, data) {
-  const matches = result.matches;
-  data.matches = [];
-  if (!isDefined(matches)) {
-    return;
-  }
-  matches.forEach((match) => {
-    if (!isDefined(match.indices) || !match.indices.length) {
+};
+function formatMatches(result) {
+  const matches = [];
+  result.matches.forEach((match) => {
+    if (!isDefined(match.indices) || !match.indices.length)
       return;
-    }
-    const {
-      indices,
-      value
-    } = match;
     const obj = {
-      indices,
-      value
+      indices: match.indices,
+      value: match.value
     };
-    if (match.key) {
-      obj.key = match.key.src;
-    }
-    if (match.idx > -1) {
+    if (match.key)
+      obj.key = match.key.id;
+    if (match.idx > -1)
       obj.refIndex = match.idx;
-    }
-    data.matches.push(obj);
+    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;
   });
 }
-var 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) || [];
-    }
-  };
+var DEFAULT_TOKEN = /[\p{L}\p{M}\p{N}_]+/gu;
+var warned = /* @__PURE__ */ new WeakSet;
+function warnNonGlobal(regex2) {
+  if (!warned.has(regex2)) {
+    warned.add(regex2);
+    console.warn(`[Fuse] tokenize regex ${regex2} lacks the global flag; only the first match per text will be returned. Add the 'g' flag.`);
+  }
 }
-function buildInvertedIndex(records, keyCount, analyzer) {
-  const terms = new Map;
-  const df3 = new Map;
-  let fieldCount = 0;
-  function addField(text, docIdx, keyIdx, subIdx) {
-    const tokens = analyzer.tokenize(text);
-    if (!tokens.length)
-      return;
-    fieldCount++;
-    const termFreqs = new Map;
-    for (const token of tokens) {
-      termFreqs.set(token, (termFreqs.get(token) || 0) + 1);
-    }
-    for (const [term, tf3] of termFreqs) {
-      const posting = {
-        docIdx,
-        keyIdx,
-        subIdx,
-        tf: tf3
-      };
-      let postings = terms.get(term);
-      if (!postings) {
-        postings = [];
-        terms.set(term, postings);
+function resolveTokenize(tokenize4) {
+  if (typeof tokenize4 === "function") {
+    let validated = false;
+    return (text) => {
+      const result = tokenize4(text);
+      if (!validated) {
+        validated = true;
+        if (!Array.isArray(result) || result.some((t17) => typeof t17 !== "string"))
+          throw new Error(`[Fuse] tokenize function must return string[]; received ${Array.isArray(result) ? "array containing non-strings" : typeof result}.`);
       }
-      postings.push(posting);
-      df3.set(term, (df3.get(term) || 0) + 1);
-    }
+      return result;
+    };
   }
-  for (const record of records) {
-    const {
-      i: docIdx,
-      v: v3,
-      $: fields
-    } = record;
-    if (v3 !== undefined) {
-      addField(v3, 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 (tokenize4 instanceof RegExp) {
+    if (!tokenize4.global)
+      warnNonGlobal(tokenize4);
+    return (text) => text.match(tokenize4) || [];
   }
-  return {
-    terms,
-    fieldCount,
-    df: df3
-  };
+  return (text) => text.match(DEFAULT_TOKEN) || [];
 }
-function addToInvertedIndex(index, record, keyCount, analyzer) {
-  const {
-    i: docIdx,
-    v: v3,
-    $: fields
-  } = record;
-  function addField(text, keyIdx, subIdx) {
-    const tokens = analyzer.tokenize(text);
-    if (!tokens.length)
-      return;
-    index.fieldCount++;
-    const termFreqs = new Map;
-    for (const token of tokens) {
-      termFreqs.set(token, (termFreqs.get(token) || 0) + 1);
-    }
-    for (const [term, tf3] of termFreqs) {
-      const posting = {
-        docIdx,
-        keyIdx,
-        subIdx,
-        tf: tf3
+function createAnalyzer({ isCaseSensitive = false, ignoreDiacritics = false, tokenize: tokenize4 } = {}) {
+  const tokenizeFn = resolveTokenize(tokenize4);
+  return { tokenize(text) {
+    if (!isCaseSensitive)
+      text = text.toLowerCase();
+    if (ignoreDiacritics)
+      text = stripDiacritics(text);
+    return tokenizeFn(text);
+  } };
+}
+var TokenSearch = class {
+  static condition(_4, 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: df3, 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 = df3.get(term) || 0;
+      const idf = Math.log(1 + (fieldCount - docFreq + 0.5) / (docFreq + 0.5));
+      this.idfWeights.push(idf);
+    }
+    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
       };
-      let postings = index.terms.get(term);
-      if (!postings) {
-        postings = [];
-        index.terms.set(term, postings);
+    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 i2 = 0;i2 < this.termSearchers.length; i2++) {
+      const result = this.termSearchers[i2].searchIn(text);
+      const idf = this.idfWeights[i2];
+      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 << i2;
+          else
+            matchedTerms.add(i2);
       }
-      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(0.001, 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: v3, $: fields } = record;
   if (v3 !== undefined) {
-    addField(v3, -1, -1);
+    addField(index, v3, 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((p3) => p3.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 === undefined)
+    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 Fuse2 {
+function removeAndShiftInvertedIndex(index, removedIndices) {
+  if (removedIndices.length === 0)
+    return;
+  const sorted = Array.from(new Set(removedIndices)).sort((a2, b) => a2 - b);
+  for (const idx of sorted)
+    removeFromInvertedIndex(index, idx);
+  const shift = (oldIdx) => {
+    let lo3 = 0;
+    let hi3 = sorted.length;
+    while (lo3 < hi3) {
+      const mid = lo3 + hi3 >>> 1;
+      if (sorted[mid] < oldIdx)
+        lo3 = mid + 1;
+      else
+        hi3 = mid;
+    }
+    return oldIdx - lo3;
+  };
+  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 Fuse2 = class {
   constructor(docs, options, index) {
     this.options = {
       ...Config,
@@ -275519,23 +275469,20 @@ class Fuse2 {
     this._lastSearcher = null;
   }
   _getSearcher(query) {
-    if (this._lastQuery === query) {
+    if (this._lastQuery === query)
       return this._lastSearcher;
-    }
-    const opts = this._invertedIndex ? {
+    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)) {
+    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
@@ -275543,155 +275490,137 @@ class Fuse2 {
     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)) {
+    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 i2 = 0, len = this._docs.length;i2 < len; i2 += 1) {
+    for (let i2 = 0, len = this._docs.length;i2 < len; i2 += 1)
       if (predicate(this._docs[i2], i2)) {
         results.push(this._docs[i2]);
         indicesToRemove.push(i2);
       }
-    }
     if (indicesToRemove.length) {
-      if (this._invertedIndex) {
-        for (const idx of indicesToRemove) {
-          removeFromInvertedIndex(this._invertedIndex, idx);
-        }
-      }
-      for (let i2 = indicesToRemove.length - 1;i2 >= 0; i2 -= 1) {
-        this._docs.splice(indicesToRemove[i2], 1);
-      }
+      if (this._invertedIndex)
+        removeAndShiftInvertedIndex(this._invertedIndex, indicesToRemove);
+      const toRemove = new Set(indicesToRemove);
+      this._docs = this._docs.filter((_4, i2) => !toRemove.has(i2));
       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;
   }
   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 (isString2(query) && !query.trim()) {
       let docs = this._docs.map((item, idx) => ({
         item,
         refIndex: idx
       }));
-      if (isNumber2(limit) && limit > -1) {
+      if (isNumber2(limit) && limit > -1)
         docs = docs.slice(0, limit);
-      }
       return docs;
     }
     const useHeap = isNumber2(limit) && limit > 0 && isString2(query);
     let results;
     if (useHeap) {
       const heap = new MaxHeap(limit);
-      if (isString2(this._docs[0])) {
+      if (isString2(this._docs[0]))
         this._searchStringList(query, {
           heap,
           ignoreFieldNorm
         });
-      } else {
+      else
         this._searchObjectList(query, {
           heap,
           ignoreFieldNorm
         });
-      }
       results = heap.extractSorted(sortFn);
     } else {
       results = isString2(query) ? isString2(this._docs[0]) ? this._searchStringList(query) : this._searchObjectList(query) : this._searchLogical(query);
-      computeScore(results, {
-        ignoreFieldNorm
-      });
-      if (shouldSort) {
+      computeScore(results, { ignoreFieldNorm });
+      if (shouldSort)
         results.sort(sortFn);
-      }
-      if (isNumber2(limit) && limit > -1) {
+      if (isNumber2(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)) {
+    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
-          }]
+      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)) {
-            heap.insert(result);
-          }
-        } else {
-          results.push(result);
+        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 });
+            if (heap.shouldInsert(result.score))
+              heap.insert(result);
+          } else
+            results.push(result);
         }
       }
     });
@@ -275701,10 +275630,7 @@ class Fuse2 {
     const expression = parse3(query, this.options);
     const evaluate = (node, item, idx) => {
       if (!("children" in node)) {
-        const {
-          keyId,
-          searcher
-        } = node;
+        const { keyId, searcher } = node;
         let matches;
         if (keyId === null) {
           matches = [];
@@ -275715,45 +275641,36 @@ class Fuse2 {
               searcher
             }));
           });
-        } else {
+        } else
           matches = this._findMatches({
             key: this._keyStore.get(keyId),
             value: this._myIndex.getValueForItemAtKeyId(item, keyId),
             searcher
           });
-        }
-        if (matches && matches.length) {
+        if (matches && matches.length)
           return [{
             idx,
             item,
             matches
           }];
-        }
         return [];
       }
-      const {
-        children,
-        operator
-      } = node;
+      const { children, operator } = node;
       const res2 = [];
       for (let i2 = 0, len = children.length;i2 < len; i2 += 1) {
         const child = children[i2];
         const result = evaluate(child, item, idx);
-        if (result.length) {
+        if (result.length)
           res2.push(...result);
-        } else if (operator === LogicalOperator.AND) {
+        else if (operator === LogicalOperator.AND)
           return [];
-        }
       }
       return res2;
     };
     const records = this._myIndex.records;
-    const resultMap = new Map;
+    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) {
@@ -275765,9 +275682,7 @@ class Fuse2 {
             });
             results.push(resultMap.get(idx));
           }
-          expResults.forEach(({
-            matches
-          }) => {
+          expResults.forEach(({ matches }) => {
             resultMap.get(idx).matches.push(...matches);
           });
         }
@@ -275775,23 +275690,14 @@ class Fuse2 {
     });
     return results;
   }
-  _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 { keys, records } = this._myIndex;
     const results = heap ? null : [];
-    records.forEach(({
-      $: item,
-      i: idx
-    }) => {
-      if (!isDefined(item)) {
+    records.forEach(({ $: item, i: idx }) => {
+      if (!isDefined(item))
         return;
-      }
       const matches = [];
       let anyKeyFailed = false;
       let hasInverse = false;
@@ -275803,196 +275709,117 @@ class Fuse2 {
         });
         if (keyMatches.length) {
           matches.push(...keyMatches);
-          if (keyMatches[0].hasInverse) {
+          if (keyMatches[0].hasInverse)
             hasInverse = true;
-          }
-        } else {
+        } else
           anyKeyFailed = true;
-        }
       });
-      if (hasInverse && anyKeyFailed) {
+      if (hasInverse && anyKeyFailed)
         return;
-      }
-      if (matches.length) {
+      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)) {
+          result.score = computeScoreSingle(result.matches, { ignoreFieldNorm });
+          if (heap.shouldInsert(result.score))
             heap.insert(result);
-          }
-        } else {
+        } else
           results.push(result);
-        }
       }
     });
     return results;
   }
-  _findMatches({
-    key,
-    value,
-    searcher
-  }) {
-    if (!isDefined(value)) {
+  _findMatches({ key, value, searcher }) {
+    if (!isDefined(value))
       return [];
-    }
     const matches = [];
-    if (isArray(value)) {
-      value.forEach(({
-        v: text,
-        i: idx,
-        n: norm2
-      }) => {
-        if (!isDefined(text)) {
+    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,
+        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 !== undefined) {
+            match.matchedMask = searchResult.matchedMask;
+            match.matchedTerms = searchResult.matchedTerms;
+            match.termCount = searchResult.termCount;
+          }
+          matches.push(match);
         }
       });
-    } else {
-      const {
-        v: text,
-        n: norm2
-      } = value;
-      const {
-        isMatch,
-        score,
-        indices,
-        hasInverse
-      } = searcher.searchIn(text);
-      if (isMatch) {
-        matches.push({
-          score,
+    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,
-          hasInverse
-        });
+          indices: searchResult.indices,
+          hasInverse: searchResult.hasInverse
+        };
+        if (searchResult.termCount !== undefined) {
+          match.matchedMask = searchResult.matchedMask;
+          match.matchedTerms = searchResult.matchedTerms;
+          match.termCount = searchResult.termCount;
+        }
+        matches.push(match);
       }
     }
     return matches;
   }
-}
-
-class TokenSearch {
-  static condition(_4, 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: df3,
-      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 = df3.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 i2 = 0;i2 < this.termSearchers.length; i2++) {
-      const result = this.termSearchers[i2].searchIn(text);
-      const idf = this.idfWeights[i2];
-      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
-      };
+  _coversAllTokens(matches) {
+    const termCount = matches.length ? matches[0].termCount : undefined;
+    if (termCount === undefined)
+      return true;
+    if (termCount <= 31) {
+      let coverage2 = 0;
+      for (let i2 = 0;i2 < matches.length; i2++)
+        coverage2 |= matches[i2].matchedMask || 0;
+      return coverage2 === 2 ** termCount - 1;
     }
-    const normalized = maxPossibleScore > 0 ? 1 - weightedScore / maxPossibleScore : 0;
-    const searchResult = {
-      isMatch: true,
-      score: Math.max(0.001, normalized)
-    };
-    if (this.options.includeMatches && allIndices.length) {
-      searchResult.indices = mergeIndices(allIndices);
+    const coverage = /* @__PURE__ */ new Set;
+    for (let i2 = 0;i2 < matches.length; i2++) {
+      const terms = matches[i2].matchedTerms;
+      if (terms)
+        for (const t17 of terms)
+          coverage.add(t17);
     }
-    return searchResult;
+    return coverage.size === termCount;
   }
-}
-Fuse2.version = "7.3.0";
+};
+Fuse2.version = "7.4.2";
 Fuse2.createIndex = createIndex;
 Fuse2.parseIndex = parseIndex;
 Fuse2.config = Config;
 Fuse2.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);
 };
-{
-  Fuse2.parseQuery = parse3;
-}
-{
-  register2(ExtendedSearch);
-}
-{
-  register2(TokenSearch);
-}
+Fuse2.parseQuery = parse3;
+register2(ExtendedSearch);
+register2(TokenSearch);
 Fuse2.use = function(...plugins) {
   plugins.forEach((plugin) => register2(plugin));
 };
+var entry_default = Fuse2;
 
 // cli/search/register.ts
 var registerSearch = (program3) => {
@@ -276019,7 +275846,7 @@ var registerSearch = (program3) => {
       }
       if (searchKicad) {
         const kicadFiles = await fetch("https://kicad-mod-cache.tscircuit.com/kicad_files.json").then((r4) => r4.json());
-        const fuse = new Fuse2(kicadFiles);
+        const fuse = new entry_default(kicadFiles);
         kicadResults = fuse.search(query).slice(0, 10).map((r4) => r4.item);
       }
     } catch (error) {
@@ -279312,8 +279139,7 @@ var processSnapshotFile = async ({
 };
 
 // lib/shared/snapshot-project.ts
-var hasConfiguredIncludeBoardFiles = (projectDir) => {
-  const projectConfig2 = loadProjectConfig(projectDir);
+var hasConfiguredIncludeBoardFiles = (projectConfig2) => {
   const hasConfiguredPatterns = Boolean(projectConfig2?.includeBoardFiles?.some((pattern) => pattern.trim()));
   return hasConfiguredPatterns;
 };
@@ -279338,7 +279164,7 @@ var snapshotProject = async ({
     threeD = true;
   }
   const projectDir = process.cwd();
-  const projectConfig2 = loadProjectConfig(projectDir);
+  const projectConfig2 = await loadRuntimeProjectConfig(projectDir);
   const ignore = [
     ...DEFAULT_IGNORED_PATTERNS,
     ...ignored.map(normalizeIgnorePattern)
@@ -279350,7 +279176,7 @@ var snapshotProject = async ({
     }
     return fs66.statSync(resolvedPath).isDirectory();
   });
-  const boardFiles = findBoardFiles({
+  const boardFiles = await findBoardFilesAsync({
     projectDir,
     ignore,
     filePaths: resolvedPaths
@@ -279358,8 +279184,9 @@ var snapshotProject = async ({
   if (boardFiles.length === 0) {
     if (explicitDirectoryTarget) {
       const relativeDirectory = path70.relative(projectDir, explicitDirectoryTarget) || ".";
-      const includeBoardFilePatterns = getBoardFilePatterns(projectDir);
-      const patternSourceMessage = hasConfiguredIncludeBoardFiles(projectDir) ? "Searched using tscircuit.config.json includeBoardFiles" : "Searched using default includeBoardFiles";
+      const runtimeIncludeBoardFilePatterns = projectConfig2?.includeBoardFiles?.filter((pattern) => pattern.trim()) ?? [];
+      const includeBoardFilePatterns = runtimeIncludeBoardFilePatterns.length > 0 ? runtimeIncludeBoardFilePatterns : getBoardFilePatterns(projectDir);
+      const patternSourceMessage = hasConfiguredIncludeBoardFiles(projectConfig2) ? "Searched using tscircuit.config.json includeBoardFiles" : "Searched using default includeBoardFiles";
       onError([
         `No circuit files found to create snapshots in directory: "${relativeDirectory}"`,
         `${patternSourceMessage}: ${JSON.stringify(includeBoardFilePatterns)}`
@@ -279370,8 +279197,9 @@ var snapshotProject = async ({
     console.log("No entrypoint found. Run 'tsci init' to bootstrap a project or specify a file with 'tsci snapshot <file>'");
     return onExit2(0);
   }
-  const snapshotsDirName = getSnapshotsDir(projectDir);
+  const snapshotsDirName = projectConfig2?.snapshotsDir ?? getSnapshotsDir(projectDir);
   const pcbSnapshotSettings = pcbSnapshotSettingsOverride ? { ...projectConfig2?.pcbSnapshotSettings, ...pcbSnapshotSettingsOverride } : projectConfig2?.pcbSnapshotSettings;
+  const mergedPlatformConfig = mergePlatformConfigs(projectConfig2?.platformConfig, platformConfig2);
   const mismatches = [];
   let didUpdate = false;
   const concurrencyValue = Math.max(1, concurrency);
@@ -279439,7 +279267,7 @@ var snapshotProject = async ({
         pcbOnly,
         schematicOnly,
         forceUpdate,
-        platformConfig: platformConfig2,
+        platformConfig: mergedPlatformConfig,
         pcbSnapshotSettings,
         createDiff: createDiff2,
         cameraPreset