cry-search 1.0.0 → 1.0.3

package/dist/index.cjs

@@ -29,19 +29,15 @@ var __export = (target, all) => {
 // src/index.ts
 var exports_src = {};
 __export(exports_src, {
-  wrapMetadataLegacy: () => wrapMetadataLegacy,
-  upsertPrimaryItem: () => upsertPrimaryItem,
-  upsertLinkedItem: () => upsertLinkedItem,
-  updateSearchMetadataString: () => updateSearchMetadata,
-  updateSearchMetadataBatchString: () => updateSearchMetadataBatch,
+  upsertPrimaryItem: () => upsertPrimaryItemNumeric,
+  upsertLinkedItem: () => upsertLinkedItemNumeric,
   updateSearchMetadataBatch: () => updateSearchMetadataBatchNumeric,
   updateSearchMetadata: () => updateSearchMetadataNumeric,
-  unwrapMetadataLegacy: () => unwrapMetadataLegacy,
   tokens: () => tokens,
   tokenize: () => tokenize,
-  syncSearchArrayMetadataWithPrevious: () => syncSearchArrayMetadataWithPrevious,
-  syncSearchArrayMetadata: () => syncSearchArrayMetadata,
-  syncLinkedItemsForPrimary: () => syncLinkedItemsForPrimary,
+  syncSearchArrayMetadataWithPrevious: () => syncSearchArrayMetadataNumericWithPrevious,
+  syncSearchArrayMetadata: () => syncSearchArrayMetadataNumeric,
+  syncLinkedItemsForPrimary: () => syncLinkedItemsForPrimaryNumeric,
   searchableDataToArray: () => searchableDataToArray,
   searchInDataWithLimit: () => searchInDataReturnIdsWithLimitNumeric,
   searchInDataReturnObjects: () => searchInDataReturnObjectsNumeric,
@@ -49,22 +45,17 @@ __export(exports_src, {
   searchInData: () => searchInDataReturnIdsNumeric,
   sanitiseString: () => sanitiseString,
   resetTokenRegistry: () => resetTokenRegistry,
-  removePrimaryItem: () => removePrimaryItem,
-  removeLinkedItem: () => removeLinkedItem,
-  removeFromSearchMetadataString: () => removeFromSearchMetadata,
-  removeFromSearchMetadataBatchString: () => removeFromSearchMetadataBatch,
+  removePrimaryItem: () => removePrimaryItemNumeric,
+  removeLinkedItem: () => removeLinkedItemNumeric,
   removeFromSearchMetadataBatch: () => removeFromSearchMetadataBatchNumeric,
   removeFromSearchMetadata: () => removeFromSearchMetadataNumeric,
   registerToken: () => registerToken,
   preprocessString: () => preprocessString,
   prepareStringForSearch: () => prepareStringForSearch,
   prepareQueryTokens: () => prepareQueryTokens,
-  prepareObjectForSearchString: () => prepareObjectForSearch,
   prepareObjectForSearch: () => prepareObjectForSearchNumeric,
   normalizeDates: () => normalizeDates,
   matchTokenInSortedListNumeric: () => matchTokenInSortedListNumeric,
-  matchTokenInSortedList: () => matchTokenInSortedList,
-  matchToken: () => matchToken,
   matchPreparedTokenInSortedList: () => matchPreparedTokenInSortedList,
   isDeletedOrBlocked: () => isDeletedOrBlocked,
   getTokenCount: () => getTokenCount,
@@ -72,40 +63,32 @@ __export(exports_src, {
   getOrCreateTokenId: () => getOrCreateTokenId,
   findTokenId: () => findTokenId,
   findInLinkedArraysSimpleNumeric: () => findInLinkedArraysSimpleNumeric,
-  findInLinkedArraysSimple: () => findInLinkedArraysSimple,
   findInLinkedArraysNumeric: () => findInLinkedArraysNumeric,
-  findInLinkedArrays: () => findInLinkedArrays,
-  findInArrayReturnIds: () => findInArrayReturnIds,
-  findInArrayReturnDataAndMeta: () => findInArrayReturnDataAndMeta,
-  findInArray: () => findInArray,
-  extractSearchableStringDefault: () => extractSearchableStringDefault,
   encodeTokenWithMode: () => encodeTokenWithMode,
   decodeTokenId: () => decodeTokenId,
   decodeMatchMode: () => decodeMatchMode,
   createTokensMap: () => createTokensMap,
-  createSearchLinkedMetadataString: () => createSearchLinkedMetadata,
   createSearchLinkedMetadata: () => createSearchLinkedMetadataNumeric,
-  createSearchArrayMetadataString: () => createSearchArrayMetadata,
   createSearchArrayMetadata: () => createSearchArrayMetadataNumeric,
   clearTokensMap: () => clearTokensMap,
   binarySearchUint32: () => binarySearchUint32,
   arrayToSearchableData: () => arrayToSearchableData,
   allTokensMatchNumeric: () => allTokensMatchNumeric,
-  allTokensMatch: () => allTokensMatch,
   allPreparedTokensMatch: () => allPreparedTokensMatch,
   TOKEN_ID_MASK: () => TOKEN_ID_MASK,
   SearchUniverse: () => SearchUniverse,
-  PREFIX_TO_MATCH_MODE: () => PREFIX_TO_MATCH_MODE,
-  MATCH_MODE_PREFIXES: () => MATCH_MODE_PREFIXES,
   MATCH_MODE_BITS: () => MATCH_MODE_BITS,
-  DEFAULT_SEARCH_OPTS: () => DEFAULT_SEARCH_OPTS
+  DEFAULT_SEARCH_OPTS: () => DEFAULT_SEARCH_OPTS,
+  AugmentedMetadata: () => AugmentedMetadata
 });
 module.exports = __toCommonJS(exports_src);
 
 // src/types/index.ts
 var DEFAULT_SEARCH_OPTS = {
   matchWords: "start",
-  matchNumbers: "startEnd"
+  matchNumbers: "startEnd",
+  matchNumbersShort: "whole",
+  matchNumbersThreshold: 6
 };
 function arrayToSearchableData(items) {
   const map = new Map;
@@ -233,7 +216,7 @@ function preprocessString(input) {
 
 // src/utils/sanitiseString.ts
 var RE_DIACRITICS = /[\u0300-\u036f]/g;
-var RE_INVALID_CHARS = /[^a-z0-9.\- ]/g;
+var RE_INVALID_CHARS = /[^a-z0-9.\-~<>+*!=? ]/g;
 function sanitiseString(input) {
   let result = input;
   result = result.toLowerCase();
@@ -277,11 +260,16 @@ function tokenize(input, config) {
   let tokens = input.split(" ").map((token) => token.trim()).filter((token) => token.length > 0);
   if (config?.replaceTokens) {
     tokens = tokens.map((token) => {
-      if (token.startsWith("--") && token.length > 2) {
+      if (token.length > 2 && token.startsWith("--")) {
         const withoutPrefix = token.slice(2);
         const replaced = config.replaceTokens.get(withoutPrefix);
         return replaced ? "--" + replaced : token;
       }
+      if (token.length > 1 && token[0] === "-" && /^[a-z]/i.test(token[1])) {
+        const withoutPrefix = token.slice(1);
+        const replaced = config.replaceTokens.get(withoutPrefix);
+        return replaced ? "-" + replaced : token;
+      }
       return config.replaceTokens.get(token) ?? token;
     });
   }
@@ -362,13 +350,6 @@ function prepareStringForSearchNumeric(input, tokensMap) {
 }
 
 // src/common/string/createSearchArrayMetadata.ts
-var MATCH_MODE_PREFIXES = {
-  start: "<",
-  end: ">",
-  startEnd: "+",
-  anywhere: "*",
-  whole: "!"
-};
 var PREFIX_TO_MATCH_MODE = {
   "<": "start",
   ">": "end",
@@ -379,155 +360,9 @@ var PREFIX_TO_MATCH_MODE = {
   "?": "anywhere"
 };
 var DEFAULT_EXCLUDED_FIELDS = new Set(["_id", "_deleted", "_blocked"]);
-function getValueByPath(obj, path) {
-  const parts = path.split(".");
-  let current = obj;
-  for (let i = 0;i < parts.length; i++) {
-    if (current == null)
-      return;
-    const part = parts[i];
-    if (Array.isArray(current)) {
-      const remainingPath = parts.slice(i).join(".");
-      const results = [];
-      for (const item of current) {
-        const value = getValueByPath(item, remainingPath);
-        if (value !== undefined) {
-          if (Array.isArray(value)) {
-            results.push(...value);
-          } else {
-            results.push(value);
-          }
-        }
-      }
-      return results.length > 0 ? results : undefined;
-    }
-    if (typeof current === "object") {
-      current = current[part];
-    } else {
-      return;
-    }
-  }
-  return current;
-}
-function isDotNotation(field) {
-  return field.includes(".");
-}
-function getRootField(field) {
-  const dotIndex = field.indexOf(".");
-  return dotIndex === -1 ? field : field.slice(0, dotIndex);
-}
-function extractStringsFromValue(value, results) {
-  if (value == null)
-    return;
-  if (typeof value === "string") {
-    results.push(value);
-  } else if (typeof value === "number") {
-    results.push(String(value));
-  } else if (value instanceof Date) {
-    results.push(value.toISOString());
-  } else if (Array.isArray(value)) {
-    for (const item of value) {
-      extractStringsFromValue(item, results);
-    }
-  } else if (typeof value === "object") {
-    for (const v of Object.values(value)) {
-      extractStringsFromValue(v, results);
-    }
-  }
-}
 function isDeletedOrBlocked(obj) {
   return obj._deleted != null || obj._blocked != null;
 }
-function extractSearchableStringDefault(obj, spec) {
-  if (isDeletedOrBlocked(obj)) {
-    return;
-  }
-  if (spec?.enrichSearchObjectFn) {
-    spec.enrichSearchObjectFn(obj, spec.searchContext);
-  }
-  const parts = [];
-  const fieldsToSearch = spec?.searchInFields ?? Object.keys(obj);
-  const fieldsToExclude = new Set(spec?.dontSearchInFields ?? []);
-  for (const key of fieldsToSearch) {
-    const keyStr = key;
-    if (!spec?.searchInFields && DEFAULT_EXCLUDED_FIELDS.has(keyStr))
-      continue;
-    if (fieldsToExclude.has(key))
-      continue;
-    const value = isDotNotation(keyStr) ? getValueByPath(obj, keyStr) : obj[key];
-    extractStringsFromValue(value, parts);
-  }
-  return parts.join(" ");
-}
-function prepareObjectForSearch(obj, spec) {
-  if (isDeletedOrBlocked(obj)) {
-    return;
-  }
-  if (spec?.extractSearchableStringFn) {
-    const searchableString = spec.extractSearchableStringFn(obj);
-    if (searchableString === undefined) {
-      return;
-    }
-    return prepareStringForSearch(searchableString);
-  }
-  return prepareObjectFieldsForSearch(obj, spec);
-}
-function prepareObjectFieldsForSearch(obj, spec) {
-  if (spec?.enrichSearchObjectFn) {
-    spec.enrichSearchObjectFn(obj, spec.searchContext);
-  }
-  const allTokens = [];
-  const fieldMatchModes = spec?.fieldMatchModes;
-  const fieldsToSearch = spec?.searchInFields ?? Object.keys(obj);
-  const fieldsToExclude = new Set(spec?.dontSearchInFields ?? []);
-  const processedRootFields = new Set;
-  for (const key of fieldsToSearch) {
-    const keyStr = key;
-    if (!spec?.searchInFields && DEFAULT_EXCLUDED_FIELDS.has(keyStr))
-      continue;
-    if (fieldsToExclude.has(key))
-      continue;
-    const isDot = isDotNotation(keyStr);
-    const rootField = getRootField(keyStr);
-    let value;
-    if (isDot) {
-      value = getValueByPath(obj, keyStr);
-    } else {
-      value = obj[key];
-      processedRootFields.add(rootField);
-    }
-    if (value == null)
-      continue;
-    const matchMode = fieldMatchModes?.[key];
-    const prefix = matchMode ? MATCH_MODE_PREFIXES[matchMode] : "";
-    const fieldStrings = [];
-    extractStringsFromValue(value, fieldStrings);
-    if (fieldStrings.length > 0) {
-      const fieldText = fieldStrings.join(" ");
-      const tokens2 = prepareStringForSearch(fieldText);
-      for (const token of tokens2) {
-        allTokens.push(prefix + token);
-      }
-    }
-  }
-  return [...new Set(allTokens)].sort();
-}
-function createSearchArrayMetadata(data, spec) {
-  const metadata = new Map;
-  for (const [id, item] of data) {
-    const tokens2 = prepareObjectForSearch(item, spec);
-    if (tokens2 !== undefined) {
-      metadata.set(id, tokens2);
-    }
-  }
-  return metadata;
-}
-function wrapMetadataLegacy(metadata) {
-  return { items: metadata };
-}
-function unwrapMetadataLegacy(legacy) {
-  return legacy.items;
-}
 
 // src/common/numeric/createSearchArrayMetadata.ts
 var MATCH_MODE_BITS = {
@@ -561,7 +396,7 @@ function decodeMatchMode(encoded) {
   }
 }
 var DEFAULT_EXCLUDED_FIELDS2 = new Set(["_id", "_deleted", "_blocked"]);
-function getValueByPath2(obj, path) {
+function getValueByPath(obj, path) {
   const parts = path.split(".");
   let current = obj;
   for (let i = 0;i < parts.length; i++) {
@@ -572,7 +407,7 @@ function getValueByPath2(obj, path) {
       const remainingPath = parts.slice(i).join(".");
       const results = [];
       for (const item of current) {
-        const value = getValueByPath2(item, remainingPath);
+        const value = getValueByPath(item, remainingPath);
         if (value !== undefined) {
           if (Array.isArray(value)) {
             results.push(...value);
@@ -591,10 +426,10 @@ function getValueByPath2(obj, path) {
   }
   return current;
 }
-function isDotNotation2(field) {
+function isDotNotation(field) {
   return field.includes(".");
 }
-function extractStringsFromValue2(value, results) {
+function extractStringsFromValue(value, results) {
   if (value == null)
     return;
   if (typeof value === "string") {
@@ -605,11 +440,11 @@ function extractStringsFromValue2(value, results) {
     results.push(value.toISOString());
   } else if (Array.isArray(value)) {
     for (const item of value) {
-      extractStringsFromValue2(item, results);
+      extractStringsFromValue(item, results);
     }
   } else if (typeof value === "object") {
     for (const v of Object.values(value)) {
-      extractStringsFromValue2(v, results);
+      extractStringsFromValue(v, results);
     }
   }
 }
@@ -640,13 +475,13 @@ function prepareObjectFieldsForSearchNumeric(obj, spec, tokensMap) {
       continue;
     if (fieldsToExclude.has(key))
       continue;
-    const isDot = isDotNotation2(keyStr);
-    const value = isDot ? getValueByPath2(obj, keyStr) : obj[key];
+    const isDot = isDotNotation(keyStr);
+    const value = isDot ? getValueByPath(obj, keyStr) : obj[key];
     if (value == null)
       continue;
     const matchMode = fieldMatchModes?.[key];
     const fieldStrings = [];
-    extractStringsFromValue2(value, fieldStrings);
+    extractStringsFromValue(value, fieldStrings);
     if (fieldStrings.length > 0) {
       const fieldText = fieldStrings.join(" ");
       const datesNormalized = normalizeDates(fieldText);
@@ -750,14 +585,38 @@ function removeFromSearchMetadataBatchNumeric(metadata, objectIds) {
 }
 // src/utils/matchTokenNumeric.ts
 var RE_NUMERIC = /^[\d.\-]+$/;
+function countDigits(str) {
+  let count = 0;
+  for (let i = 0;i < str.length; i++) {
+    const c = str[i];
+    if (c !== "." && c !== "-")
+      count++;
+  }
+  return count;
+}
+function getNumericMatchMode(str, opts) {
+  const threshold = opts?.matchNumbersThreshold ?? DEFAULT_SEARCH_OPTS.matchNumbersThreshold;
+  const digitCount = countDigits(str);
+  if (digitCount <= threshold) {
+    return opts?.matchNumbersShort ?? DEFAULT_SEARCH_OPTS.matchNumbersShort;
+  }
+  return opts?.matchNumbers ?? DEFAULT_SEARCH_OPTS.matchNumbers;
+}
 function prepareQueryTokens(queryTokenStrs) {
-  return queryTokenStrs.map((str) => {
+  return queryTokenStrs.filter((str) => {
+    if (str === "-" || str === "--" || str === "~")
+      return false;
+    return true;
+  }).map((str) => {
     let overrideMode;
     let negated = false;
     let cleanStr = str;
     if (str.length > 2 && str.startsWith("--")) {
       negated = true;
       cleanStr = str.slice(2);
+    } else if (str.length > 1 && str[0] === "-" && /^[a-z]/i.test(str[1])) {
+      negated = true;
+      cleanStr = str.slice(1);
     } else if (str.length > 1 && str.startsWith("~")) {
       negated = true;
       cleanStr = str.slice(1);
@@ -780,13 +639,16 @@ function prepareQueryTokens(queryTokenStrs) {
         cleanStr = str.slice(1);
       }
     }
-    return {
+    const result = {
       str: cleanStr,
       id: findTokenId(cleanStr),
-      isNumeric: RE_NUMERIC.test(cleanStr),
-      overrideMode,
-      negated: negated || undefined
+      isNumeric: RE_NUMERIC.test(cleanStr)
     };
+    if (overrideMode)
+      result.overrideMode = overrideMode;
+    if (negated)
+      result.negated = true;
+    return result;
   });
 }
 function matchWithModeNumeric(searchTokenId, searchTokenStr, targetTokenEncoded, opts, overrideMode) {
@@ -801,8 +663,8 @@ function matchWithModeNumeric(searchTokenId, searchTokenStr, targetTokenEncoded,
   } else if (hasExplicitMode) {
     mode = decodeMatchMode(targetTokenEncoded);
   } else {
-    const isNumeric = RE_NUMERIC.test(searchTokenStr);
-    mode = isNumeric ? opts?.matchNumbers ?? DEFAULT_SEARCH_OPTS.matchNumbers : opts?.matchWords ?? DEFAULT_SEARCH_OPTS.matchWords;
+    const isTargetNumeric = RE_NUMERIC.test(targetTokenStr);
+    mode = isTargetNumeric ? getNumericMatchMode(targetTokenStr, opts) : opts?.matchWords ?? DEFAULT_SEARCH_OPTS.matchWords;
   }
   switch (mode) {
     case "start":
@@ -837,9 +699,8 @@ function binarySearchUint32(arr, target) {
   return false;
 }
 function matchPreparedTokenInSortedList(preparedToken, targetTokens, opts) {
-  const { str: searchTokenStr, id: searchTokenId, isNumeric, overrideMode } = preparedToken;
-  const effectiveMode = overrideMode ?? (isNumeric ? opts?.matchNumbers ?? DEFAULT_SEARCH_OPTS.matchNumbers : opts?.matchWords ?? DEFAULT_SEARCH_OPTS.matchWords);
-  if (effectiveMode === "whole" && searchTokenId !== -1) {
+  const { str: searchTokenStr, id: searchTokenId, overrideMode, negated } = preparedToken;
+  if (overrideMode === "whole" && searchTokenId !== -1) {
     let hasEncodedTokens = false;
     for (let i = 0;i < targetTokens.length; i++) {
       if (targetTokens[i] > TOKEN_ID_MASK) {
@@ -856,47 +717,36 @@ function matchPreparedTokenInSortedList(preparedToken, targetTokens, opts) {
     if (matchWithModeNumeric(searchTokenId, searchTokenStr, targetEncoded, opts, overrideMode)) {
       return true;
     }
+    if (negated) {
+      const targetTokenId = decodeTokenId(targetEncoded);
+      const targetTokenStr = tokens[targetTokenId];
+      if (targetTokenStr) {
+        const hasExplicitMode = targetEncoded !== targetTokenId;
+        let targetMode;
+        if (overrideMode) {
+          targetMode = overrideMode;
+        } else if (hasExplicitMode) {
+          targetMode = decodeMatchMode(targetEncoded);
+        } else {
+          const isTargetNumeric = RE_NUMERIC.test(targetTokenStr);
+          targetMode = isTargetNumeric ? getNumericMatchMode(targetTokenStr, opts) : opts?.matchWords ?? DEFAULT_SEARCH_OPTS.matchWords;
+        }
+        if ((targetMode === "start" || targetMode === "startEnd") && searchTokenStr.startsWith(targetTokenStr)) {
+          return true;
+        }
+      }
+    }
   }
   return false;
 }
 function matchTokenInSortedListNumeric(searchTokenStr, targetTokens, opts) {
-  let overrideMode;
-  let negated = false;
-  let cleanStr = searchTokenStr;
-  if (searchTokenStr.length > 2 && searchTokenStr.startsWith("--")) {
-    negated = true;
-    cleanStr = searchTokenStr.slice(2);
-  } else if (searchTokenStr.length > 1 && searchTokenStr.startsWith("~")) {
-    negated = true;
-    cleanStr = searchTokenStr.slice(1);
-  } else if (searchTokenStr.length > 3 && searchTokenStr.startsWith("...")) {
-    overrideMode = "end";
-    cleanStr = searchTokenStr.slice(3);
-  } else if (searchTokenStr.length > 2 && searchTokenStr.startsWith("..")) {
-    overrideMode = "end";
-    cleanStr = searchTokenStr.slice(2);
-  } else if (searchTokenStr.length > 3 && searchTokenStr.endsWith("...")) {
-    overrideMode = "start";
-    cleanStr = searchTokenStr.slice(0, -3);
-  } else if (searchTokenStr.length > 2 && searchTokenStr.endsWith("..")) {
-    overrideMode = "start";
-    cleanStr = searchTokenStr.slice(0, -2);
-  } else if (searchTokenStr.length > 1) {
-    const firstChar = searchTokenStr[0];
-    if (firstChar && PREFIX_TO_MATCH_MODE[firstChar]) {
-      overrideMode = PREFIX_TO_MATCH_MODE[firstChar];
-      cleanStr = searchTokenStr.slice(1);
-    }
-  }
-  const preparedToken = {
-    str: cleanStr,
-    id: findTokenId(cleanStr),
-    isNumeric: RE_NUMERIC.test(cleanStr),
-    overrideMode,
-    negated: negated || undefined
-  };
+  const preparedTokens = prepareQueryTokens([searchTokenStr]);
+  if (preparedTokens.length === 0) {
+    return true;
+  }
+  const preparedToken = preparedTokens[0];
   const matches = matchPreparedTokenInSortedList(preparedToken, targetTokens, opts);
-  return negated ? !matches : matches;
+  return preparedToken.negated ? !matches : matches;
 }
 function allPreparedTokensMatch(preparedTokens, targetTokens, opts) {
   for (const preparedToken of preparedTokens) {
@@ -918,18 +768,7 @@ function allTokensMatchNumeric(searchTokenStrs, targetTokens, opts) {
 
 // src/common/numeric/searchInData.ts
 function searchInDataReturnIdsNumeric(query, metadata, opts) {
-  const queryTokenStrs = prepareStringForSearch(query);
-  if (queryTokenStrs.length === 0) {
-    return [];
-  }
-  const preparedTokens = prepareQueryTokens(queryTokenStrs);
-  const results = [];
-  for (const [id, targetTokens] of metadata) {
-    if (allPreparedTokensMatch(preparedTokens, targetTokens, opts)) {
-      results.push(id);
-    }
-  }
-  return results;
+  return searchInDataReturnIdsWithLimitNumeric(query, metadata, Infinity, opts);
 }
 function searchInDataReturnObjectsNumeric(query, metadata, data, opts) {
   const ids = searchInDataReturnIdsNumeric(query, metadata, opts);
@@ -963,7 +802,7 @@ function searchInDataReturnIdsWithLimitNumeric(query, metadata, limit, opts) {
 function findInLinkedArraysNumeric(query, linked, limit = 10, opts) {
   const queryTokenStrs = prepareStringForSearch(query);
   if (queryTokenStrs.length === 0) {
-    return { queryTokens: queryTokenStrs, results: [] };
+    return { queryTokens: queryTokenStrs, results: [], hasNegation: false };
   }
   const preparedTokens = prepareQueryTokens(queryTokenStrs);
   const positiveTokens = preparedTokens.filter((t) => !t.negated);
@@ -1061,258 +900,184 @@ function findInLinkedArraysNumeric(query, linked, limit = 10, opts) {
       });
     }
   }
-  return { queryTokens: queryTokenStrs, results };
+  return { queryTokens: queryTokenStrs, results, hasNegation: negatedTokens.length > 0 };
 }
 function findInLinkedArraysSimpleNumeric(query, linked, limit = 10, opts) {
   return findInLinkedArraysNumeric(query, linked, limit, opts).results;
 }
-// src/common/string/createSearchLinkedMetadata.ts
-function createSearchLinkedMetadata(primaryData, primaryMetadata, linkedData, linkedMetadata, foreignKeyGetter) {
-  const primaryToLinked = new Map;
-  for (const [linkedId, linkedItem] of linkedData) {
-    const primaryId = foreignKeyGetter(linkedItem);
-    if (primaryId) {
-      const list = primaryToLinked.get(primaryId) || [];
-      list.push(linkedId);
-      primaryToLinked.set(primaryId, list);
+// src/common/numeric/AugmentedMetadata.ts
+class AugmentedMetadata {
+  baseMetadata;
+  augmentedTokens;
+  spec;
+  constructor(baseMetadata, spec, augmentedDataMap) {
+    this.baseMetadata = baseMetadata;
+    this.augmentedTokens = new Map;
+    this.spec = spec;
+    if (augmentedDataMap && augmentedDataMap.size > 0) {
+      this.updateAugmentedBatch(augmentedDataMap);
+    }
+  }
+  updateAugmented(id, augmentedData) {
+    if (!augmentedData) {
+      this.augmentedTokens.delete(id);
+      return;
     }
-  }
-  return {
-    primaryMeta: primaryMetadata,
-    linkedMeta: linkedMetadata,
-    primaryToLinked,
-    primaryData,
-    linkedData
-  };
-}
-// src/common/string/updateSearchMetadata.ts
-function updateSearchMetadata(metadata, objectId, obj, spec) {
-  const tokens2 = obj != null ? prepareObjectForSearch(obj, spec) : undefined;
-  if (tokens2 === undefined) {
-    metadata.delete(objectId);
-    return false;
-  } else {
-    metadata.set(objectId, tokens2);
-    return true;
-  }
-}
-function updateSearchMetadataBatch(metadata, batch, spec) {
-  if (batch.length === 0) {
-    return { updated: 0, removed: 0 };
-  }
-  let updated = 0;
-  let removed = 0;
-  for (const { objectId, obj } of batch) {
-    const wasUpdated = updateSearchMetadata(metadata, objectId, obj, spec);
-    if (wasUpdated) {
-      updated++;
+    const tokensMap = createTokensMap();
+    const tokens2 = prepareObjectForSearchNumeric(augmentedData, this.spec, tokensMap);
+    if (tokens2 && tokens2.length > 0) {
+      this.augmentedTokens.set(id, tokens2);
     } else {
-      removed++;
-    }
-  }
-  return { updated, removed };
-}
-function removeFromSearchMetadata(metadata, objectId) {
-  return metadata.delete(objectId);
-}
-function removeFromSearchMetadataBatch(metadata, objectIds) {
-  if (objectIds.length === 0) {
-    return 0;
-  }
-  let removed = 0;
-  for (const id of objectIds) {
-    if (metadata.delete(id)) {
-      removed++;
+      this.augmentedTokens.delete(id);
     }
+    clearTokensMap(tokensMap);
   }
-  return removed;
-}
-// src/utils/matchToken.ts
-var RE_NUMERIC2 = /^[\d.\-]+$/;
-var PREFIX_TO_MODE = {
-  "<": "start",
-  ">": "end",
-  "+": "startEnd",
-  "*": "anywhere",
-  "!": "whole"
-};
-function matchWithMode(searchToken, targetToken, mode) {
-  switch (mode) {
-    case "start":
-      return targetToken.startsWith(searchToken);
-    case "end":
-      return targetToken.endsWith(searchToken);
-    case "startEnd":
-      return targetToken.startsWith(searchToken) || targetToken.endsWith(searchToken);
-    case "anywhere":
-      return targetToken.includes(searchToken);
-    case "whole":
-      return targetToken === searchToken;
-  }
-}
-function matchToken(searchToken, targetToken, opts) {
-  const firstChar = targetToken[0];
-  const prefixMode = firstChar ? PREFIX_TO_MODE[firstChar] : undefined;
-  if (prefixMode) {
-    const actualTarget = targetToken.slice(1);
-    return matchWithMode(searchToken, actualTarget, prefixMode);
-  }
-  const matchWords = opts?.matchWords ?? DEFAULT_SEARCH_OPTS.matchWords;
-  const matchNumbers = opts?.matchNumbers ?? DEFAULT_SEARCH_OPTS.matchNumbers;
-  const isNumeric = RE_NUMERIC2.test(searchToken);
-  return matchWithMode(searchToken, targetToken, isNumeric ? matchNumbers : matchWords);
-}
-function matchTokenInSortedList(searchToken, targetTokens, opts) {
-  const isNumeric = RE_NUMERIC2.test(searchToken);
-  const effectiveMode = isNumeric ? opts?.matchNumbers ?? DEFAULT_SEARCH_OPTS.matchNumbers : opts?.matchWords ?? DEFAULT_SEARCH_OPTS.matchWords;
-  const canEarlyExit = effectiveMode === "start";
-  for (const targetToken of targetTokens) {
-    const firstChar = targetToken[0];
-    const hasPrefix = firstChar ? PREFIX_TO_MODE[firstChar] !== undefined : false;
-    if (hasPrefix) {
-      if (matchToken(searchToken, targetToken, opts)) {
-        return true;
+  updateAugmentedBatch(augmentedDataMap) {
+    const tokensMap = createTokensMap();
+    for (const [id, augmentedData] of augmentedDataMap) {
+      if (!augmentedData) {
+        this.augmentedTokens.delete(id);
+        continue;
       }
-    } else {
-      if (canEarlyExit) {
-        if (targetToken.startsWith(searchToken)) {
-          return true;
-        }
-        if (targetToken > searchToken && targetToken[0] !== searchToken[0]) {
-          return false;
-        }
+      const tokens2 = prepareObjectForSearchNumeric(augmentedData, this.spec, tokensMap);
+      if (tokens2 && tokens2.length > 0) {
+        this.augmentedTokens.set(id, tokens2);
       } else {
-        if (matchToken(searchToken, targetToken, opts)) {
-          return true;
-        }
+        this.augmentedTokens.delete(id);
       }
     }
+    clearTokensMap(tokensMap);
   }
-  return false;
-}
-function allTokensMatch(searchTokens, targetTokens, opts) {
-  for (const searchToken of searchTokens) {
-    if (!matchTokenInSortedList(searchToken, targetTokens, opts)) {
-      return false;
-    }
+  clearAugmented(id) {
+    this.augmentedTokens.delete(id);
   }
-  return true;
-}
-
-// src/common/findInArrayReturnDataAndMeta.ts
-function findInArrayReturnDataAndMeta(query, data, metadata, limit = 10, opts) {
-  const queryTokens = prepareStringForSearch(query);
-  if (queryTokens.length === 0) {
+  clearAllAugmented() {
+    this.augmentedTokens.clear();
+  }
+  get(id) {
+    const baseTokens = this.baseMetadata.get(id);
+    if (!baseTokens)
+      return;
+    const augTokens = this.augmentedTokens.get(id);
+    if (!augTokens)
+      return baseTokens;
+    return this.mergeSortedTokenArrays(baseTokens, augTokens);
+  }
+  has(id) {
+    return this.baseMetadata.has(id);
+  }
+  get size() {
+    return this.baseMetadata.size;
+  }
+  [Symbol.iterator]() {
+    const self = this;
+    const baseIterator = this.baseMetadata[Symbol.iterator]();
     return {
-      queryTokens,
-      results: []
+      next() {
+        const baseResult = baseIterator.next();
+        if (baseResult.done) {
+          return { done: true, value: undefined };
+        }
+        const [id, baseTokens] = baseResult.value;
+        const augTokens = self.augmentedTokens.get(id);
+        const tokens2 = augTokens ? self.mergeSortedTokenArrays(baseTokens, augTokens) : baseTokens;
+        return { done: false, value: [id, tokens2] };
+      },
+      [Symbol.iterator]() {
+        return this;
+      },
+      [Symbol.dispose]() {}
     };
   }
-  const results = [];
-  for (const [id, itemTokens] of metadata) {
-    if (results.length >= limit) {
-      break;
-    }
-    if (allTokensMatch(queryTokens, itemTokens, opts)) {
-      const item = data.get(id);
-      if (item) {
-        results.push({
-          item,
-          tokens: itemTokens
-        });
-      }
-    }
+  keys() {
+    return this.baseMetadata.keys();
   }
-  return {
-    queryTokens,
-    results
-  };
-}
-function findInArrayReturnIds(query, metadata, limit = 10, opts) {
-  const queryTokens = prepareStringForSearch(query);
-  if (queryTokens.length === 0) {
-    return [];
+  values() {
+    const self = this;
+    const keysIterator = this.baseMetadata.keys();
+    return {
+      next() {
+        const keyResult = keysIterator.next();
+        if (keyResult.done) {
+          return { done: true, value: undefined };
+        }
+        const tokens2 = self.get(keyResult.value);
+        return tokens2 ? { done: false, value: tokens2 } : { done: true, value: undefined };
+      },
+      [Symbol.iterator]() {
+        return this;
+      },
+      [Symbol.dispose]() {}
+    };
   }
-  const results = [];
-  for (const [id, itemTokens] of metadata) {
-    if (results.length >= limit) {
-      break;
-    }
-    if (allTokensMatch(queryTokens, itemTokens, opts)) {
-      results.push(id);
+  entries() {
+    return this[Symbol.iterator]();
+  }
+  forEach(callbackfn) {
+    for (const [id, tokens2] of this) {
+      callbackfn(tokens2, id, this);
     }
   }
-  return results;
-}
-
-// src/common/findInArray.ts
-function findInArray(query, data, metadata, limit = 10, opts) {
-  const result = findInArrayReturnDataAndMeta(query, data, metadata, limit, opts);
-  return result.results.map((r) => r.item);
-}
-// src/common/findInLinkedArrays.ts
-function findInLinkedArrays(query, linked, limit = 10, opts) {
-  const queryTokens = prepareStringForSearch(query);
-  if (queryTokens.length === 0) {
-    return { queryTokens, results: [] };
+  set(_key, _value) {
+    throw new Error("AugmentedMetadata.set() is not supported. Use updateAugmented() instead.");
   }
-  const results = [];
-  for (const [primaryId, primary] of linked.primaryData) {
-    if (results.length >= limit)
-      break;
-    const primaryTokens = linked.primaryMeta.get(primaryId);
-    if (!primaryTokens)
-      continue;
-    const linkedIds = linked.primaryToLinked.get(primaryId) || [];
-    const allTokens = [...primaryTokens];
-    for (const linkedId of linkedIds) {
-      const linkedTokens = linked.linkedMeta.get(linkedId);
-      if (linkedTokens) {
-        allTokens.push(...linkedTokens);
-      }
-    }
-    allTokens.sort();
-    if (allTokensMatch(queryTokens, allTokens, opts)) {
-      let anyMatchInPrimary = false;
-      let anyMatchInLinked = false;
-      const matchingLinkedIds = new Set;
-      const tokensMatchingPrimary = new Set;
-      for (const queryToken of queryTokens) {
-        if (matchTokenInSortedList(queryToken, primaryTokens, opts)) {
-          anyMatchInPrimary = true;
-          tokensMatchingPrimary.add(queryToken);
+  delete(_key) {
+    throw new Error("AugmentedMetadata.delete() is not supported. Use clearAugmented() instead.");
+  }
+  clear() {
+    throw new Error("AugmentedMetadata.clear() is not supported. Use clearAllAugmented() instead.");
+  }
+  get [Symbol.toStringTag]() {
+    return "AugmentedMetadata";
+  }
+  mergeSortedTokenArrays(a, b) {
+    const merged = new Uint32Array(a.length + b.length);
+    let i = 0, j = 0, k = 0;
+    let lastToken = -1;
+    while (i < a.length && j < b.length) {
+      const tokenA = a[i];
+      const tokenB = b[j];
+      if (tokenA < tokenB) {
+        if (tokenA !== lastToken) {
+          merged[k++] = tokenA;
+          lastToken = tokenA;
         }
-      }
-      const tokensForLinkedMatching = queryTokens.filter((t) => !tokensMatchingPrimary.has(t));
-      if (tokensForLinkedMatching.length > 0) {
-        for (const linkedId of linkedIds) {
-          const linkedTokens = linked.linkedMeta.get(linkedId);
-          if (linkedTokens) {
-            const matchesAllNonPrimaryTokens = tokensForLinkedMatching.every((queryToken) => matchTokenInSortedList(queryToken, linkedTokens, opts));
-            if (matchesAllNonPrimaryTokens) {
-              anyMatchInLinked = true;
-              matchingLinkedIds.add(linkedId);
-            }
-          }
+        i++;
+      } else if (tokenA > tokenB) {
+        if (tokenB !== lastToken) {
+          merged[k++] = tokenB;
+          lastToken = tokenB;
+        }
+        j++;
+      } else {
+        if (tokenA !== lastToken) {
+          merged[k++] = tokenA;
+          lastToken = tokenA;
         }
+        i++;
+        j++;
       }
-      if (tokensForLinkedMatching.length > 0 && matchingLinkedIds.size === 0) {
-        continue;
+    }
+    while (i < a.length) {
+      const tokenA = a[i];
+      if (tokenA !== lastToken) {
+        merged[k++] = tokenA;
+        lastToken = tokenA;
       }
-      const matchedLinked = Array.from(matchingLinkedIds).map((id) => linked.linkedData.get(id)).filter((item) => item !== undefined);
-      results.push({
-        primary,
-        linked: matchedLinked,
-        matchedIn: anyMatchInPrimary && anyMatchInLinked ? "both" : anyMatchInPrimary ? "primary" : "linked"
-      });
+      i++;
     }
+    while (j < b.length) {
+      const tokenB = b[j];
+      if (tokenB !== lastToken) {
+        merged[k++] = tokenB;
+        lastToken = tokenB;
+      }
+      j++;
+    }
+    return merged.slice(0, k);
   }
-  return { queryTokens, results };
-}
-function findInLinkedArraysSimple(query, linked, limit = 10, opts) {
-  return findInLinkedArrays(query, linked, limit, opts).results;
 }
-// src/common/syncSearchArrayMetadata.ts
+// src/common/numeric/syncSearchArrayMetadata.ts
 function tokensEqual(a, b) {
   if (a.length !== b.length)
     return false;
@@ -1322,7 +1087,7 @@ function tokensEqual(a, b) {
   }
   return true;
 }
-function syncSearchArrayMetadata(metadata, newData, spec) {
+function syncSearchArrayMetadataNumeric(metadata, newData, spec) {
   const result = {
     added: 0,
     updated: 0,
@@ -1331,6 +1096,7 @@ function syncSearchArrayMetadata(metadata, newData, spec) {
     updatedIds: [],
     removedIds: []
   };
+  const tokensMap = createTokensMap();
   for (const id of metadata.keys()) {
     if (!newData.has(id)) {
       metadata.delete(id);
@@ -1339,7 +1105,7 @@ function syncSearchArrayMetadata(metadata, newData, spec) {
     }
   }
   for (const [id, item] of newData) {
-    const newTokens = prepareObjectForSearch(item, spec);
+    const newTokens = prepareObjectForSearchNumeric(item, spec, tokensMap);
     if (newTokens === undefined) {
       if (metadata.has(id)) {
         metadata.delete(id);
@@ -1359,9 +1125,10 @@ function syncSearchArrayMetadata(metadata, newData, spec) {
       result.updatedIds.push(id);
     }
   }
+  clearTokensMap(tokensMap);
   return result;
 }
-function syncSearchArrayMetadataWithPrevious(metadata, previousData, newData, options, spec) {
+function syncSearchArrayMetadataNumericWithPrevious(metadata, previousData, newData, options, spec) {
   const result = {
     added: 0,
     updated: 0,
@@ -1370,6 +1137,7 @@ function syncSearchArrayMetadataWithPrevious(metadata, previousData, newData, op
     updatedIds: [],
     removedIds: []
   };
+  const tokensMap = createTokensMap();
   for (const id of previousData.keys()) {
     if (!newData.has(id)) {
       metadata.delete(id);
@@ -1380,14 +1148,14 @@ function syncSearchArrayMetadataWithPrevious(metadata, previousData, newData, op
   for (const [id, item] of newData) {
     const wasInPrevious = previousData.has(id);
     if (!wasInPrevious) {
-      const tokens2 = prepareObjectForSearch(item, spec);
+      const tokens2 = prepareObjectForSearchNumeric(item, spec, tokensMap);
       if (tokens2 !== undefined) {
         metadata.set(id, tokens2);
         result.added++;
         result.addedIds.push(id);
       }
     } else if (!options?.skipUpdateCheck) {
-      const newTokens = prepareObjectForSearch(item, spec);
+      const newTokens = prepareObjectForSearchNumeric(item, spec, tokensMap);
       if (newTokens === undefined) {
         metadata.delete(id);
         result.removed++;
@@ -1402,9 +1170,10 @@ function syncSearchArrayMetadataWithPrevious(metadata, previousData, newData, op
       }
     }
   }
+  clearTokensMap(tokensMap);
   return result;
 }
-// src/common/updateSearchLinkedMetadata.ts
+// src/common/numeric/updateSearchLinkedMetadata.ts
 function tokensEqual2(a, b) {
   if (a.length !== b.length)
     return false;
@@ -1414,11 +1183,13 @@ function tokensEqual2(a, b) {
   }
   return true;
 }
-function upsertPrimaryItem(linked, item, spec) {
+function upsertPrimaryItemNumeric(linked, item, spec) {
   const id = item._id;
   const wasAdded = !linked.primaryData.has(id);
   linked.primaryData.set(id, item);
-  const tokens2 = prepareObjectForSearch(item, spec);
+  const tokensMap = createTokensMap();
+  const tokens2 = prepareObjectForSearchNumeric(item, spec, tokensMap);
+  clearTokensMap(tokensMap);
   if (tokens2 !== undefined) {
     linked.primaryMeta.set(id, tokens2);
   } else {
@@ -1429,7 +1200,7 @@ function upsertPrimaryItem(linked, item, spec) {
   }
   return { added: wasAdded };
 }
-function removePrimaryItem(linked, primaryId) {
+function removePrimaryItemNumeric(linked, primaryId) {
   if (!linked.primaryData.has(primaryId)) {
     return false;
   }
@@ -1438,7 +1209,7 @@ function removePrimaryItem(linked, primaryId) {
   linked.primaryToLinked.delete(primaryId);
   return true;
 }
-function upsertLinkedItem(linked, item, foreignKeyGetter, spec) {
+function upsertLinkedItemNumeric(linked, item, foreignKeyGetter, spec) {
   const id = item._id;
   const newPrimaryId = foreignKeyGetter(item);
   let previousPrimaryId;
@@ -1448,7 +1219,9 @@ function upsertLinkedItem(linked, item, foreignKeyGetter, spec) {
   }
   const wasAdded = !existingItem;
   linked.linkedData.set(id, item);
-  const tokens2 = prepareObjectForSearch(item, spec);
+  const tokensMap = createTokensMap();
+  const tokens2 = prepareObjectForSearchNumeric(item, spec, tokensMap);
+  clearTokensMap(tokensMap);
   if (tokens2 !== undefined) {
     linked.linkedMeta.set(id, tokens2);
   } else {
@@ -1480,7 +1253,7 @@ function upsertLinkedItem(linked, item, foreignKeyGetter, spec) {
     previousPrimaryId: wasAdded ? undefined : previousPrimaryId
   };
 }
-function removeLinkedItem(linked, linkedId, foreignKeyGetter) {
+function removeLinkedItemNumeric(linked, linkedId, foreignKeyGetter) {
   const existingItem = linked.linkedData.get(linkedId);
   if (!existingItem) {
     return false;
@@ -1499,12 +1272,13 @@ function removeLinkedItem(linked, linkedId, foreignKeyGetter) {
   }
   return true;
 }
-function syncLinkedItemsForPrimary(linked, primaryId, newLinkedItems, foreignKeyGetter, spec) {
+function syncLinkedItemsForPrimaryNumeric(linked, primaryId, newLinkedItems, foreignKeyGetter, spec) {
   const result = {
     added: 0,
     updated: 0,
     removed: 0
   };
+  const tokensMap = createTokensMap();
   const currentLinkedIds = new Set(linked.primaryToLinked.get(primaryId) || []);
   const newLinkedIds = new Set;
   for (const [id, item] of newLinkedItems) {
@@ -1524,7 +1298,7 @@ function syncLinkedItemsForPrimary(linked, primaryId, newLinkedItems, foreignKey
   }
   for (const id of newLinkedIds) {
     const item = newLinkedItems.get(id);
-    const tokens2 = prepareObjectForSearch(item, spec);
+    const tokens2 = prepareObjectForSearchNumeric(item, spec, tokensMap);
     if (currentLinkedIds.has(id)) {
       const existingTokens = linked.linkedMeta.get(id);
       if (tokens2 !== undefined) {
@@ -1543,6 +1317,7 @@ function syncLinkedItemsForPrimary(linked, primaryId, newLinkedItems, foreignKey
     }
   }
   linked.primaryToLinked.set(primaryId, Array.from(newLinkedIds));
+  clearTokensMap(tokensMap);
   return result;
 }
 // src/common/SearchUniverse.ts
@@ -1779,7 +1554,7 @@ class SearchUniverse {
         const linkedSearchResults = findInLinkedArraysNumeric(query, linkedMetadata, limit, searchOpts);
         if (linkedSearchResults.results.length > 0) {
           const combinedResults = [];
-          const hasNegation = query.includes("--");
+          const hasNegation = linkedSearchResults.hasNegation;
           for (const result of linkedSearchResults.results) {
             let linkedItems = result.linked;
             if (result.matchedIn === "primary" && !hasNegation) {