cry-search 1.0.0

package/dist/index.js

@@ -0,0 +1,1795 @@
+// src/types/index.ts
+var DEFAULT_SEARCH_OPTS = {
+  matchWords: "start",
+  matchNumbers: "startEnd"
+};
+function arrayToSearchableData(items) {
+  const map = new Map;
+  for (const item of items) {
+    map.set(item._id, item);
+  }
+  return map;
+}
+function searchableDataToArray(data) {
+  return Array.from(data.values());
+}
+// src/utils/normalizeDates.ts
+var MONTH_NAMES = {
+  jan: "01",
+  feb: "02",
+  mar: "03",
+  apr: "04",
+  maj: "05",
+  jun: "06",
+  jul: "07",
+  avg: "08",
+  sep: "09",
+  okt: "10",
+  nov: "11",
+  dec: "12",
+  januar: "01",
+  februar: "02",
+  marec: "03",
+  april: "04",
+  junij: "06",
+  julij: "07",
+  avgust: "08",
+  september: "09",
+  oktober: "10",
+  november: "11",
+  december: "12",
+  january: "01",
+  february: "02",
+  march: "03",
+  may: "05",
+  june: "06",
+  july: "07",
+  august: "08",
+  october: "10"
+};
+var RE_DATE_ISO = /\b(\d{4})-(\d{2})-(\d{2})(?:T[\d:.]+Z?)?\b/g;
+var RE_DATE_ISO_YM = /\b(\d{4})-(\d{2})\b/g;
+var RE_DATE_DMY = /\b(\d{1,2})\.(\d{1,2})\.(\d{4})\b/g;
+var RE_DATE_DMY_SHORT = /\b(\d{1,2})\.(\d{1,2})\.(\d{2})\b/g;
+var RE_DATE_MY = /\b(\d{1,2})\.(\d{4})\b/g;
+var RE_DATE_MY_SLASH_DASH = /\b(\d{1,2})[-/](\d{4})\b/g;
+var RE_DATE_MY_SLASH_SHORT = /\b(\d{1,2})\/(\d{2})\b/g;
+var RE_DATE_MMYYYY = /\b(0[1-9]|1[0-2])(20\d{2})\b/g;
+var RE_DATE_DDMMYYYY = /\b(0[1-9]|[12]\d|3[01])(0[1-9]|1[0-2])(20\d{2})\b/g;
+var RE_DATE_MONTH_YEAR = new RegExp(`\\b(${Object.keys(MONTH_NAMES).join("|")})\\s*(\\d{4})\\b`, "gi");
+function pad(num, length) {
+  return num.padStart(length, "0");
+}
+function normalizeDates(input) {
+  let result = input;
+  result = result.replace(RE_DATE_ISO, (_match, year, month, day) => {
+    return `${year}${month}${day}`;
+  });
+  result = result.replace(RE_DATE_ISO_YM, (_match, year, month) => {
+    return `${year}${month}`;
+  });
+  result = result.replace(RE_DATE_DMY, (_match, day, month, year) => {
+    return `${year}${pad(month, 2)}${pad(day, 2)}`;
+  });
+  result = result.replace(RE_DATE_DMY_SHORT, (_match, day, month, year) => {
+    return `20${year}${pad(month, 2)}${pad(day, 2)}`;
+  });
+  result = result.replace(RE_DATE_MY, (_match, month, year) => {
+    return `${year}${pad(month, 2)}`;
+  });
+  result = result.replace(RE_DATE_MY_SLASH_DASH, (_match, month, year) => {
+    const y = parseInt(year, 10);
+    if (y > 2000 && y < 2100) {
+      return `${year}${pad(month, 2)}`;
+    }
+    return _match;
+  });
+  result = result.replace(RE_DATE_MY_SLASH_SHORT, (_match, month, year) => {
+    const m = parseInt(month, 10);
+    if (m >= 1 && m <= 12) {
+      return `20${year}${pad(month, 2)}`;
+    }
+    return _match;
+  });
+  result = result.replace(RE_DATE_DDMMYYYY, (_match, day, month, year) => {
+    return `${year}${month}${day}`;
+  });
+  result = result.replace(RE_DATE_MMYYYY, (_match, month, year) => {
+    return `${year}${month}`;
+  });
+  result = result.replace(RE_DATE_MONTH_YEAR, (_match, monthName, year) => {
+    const monthNum = MONTH_NAMES[monthName.toLowerCase()];
+    if (monthNum) {
+      return `${year}${monthNum}`;
+    }
+    return _match;
+  });
+  return result;
+}
+
+// src/utils/preprocessString.ts
+var RE_LEADING_ZEROS = /\b0+(\d)/g;
+var RE_DECIMAL_COMMA = /(\d),(\d)/g;
+var RE_STANDALONE_COMMA = /(?<!\d),(\d)/g;
+var RE_ZERO_DECIMAL = /\b0+\./g;
+var RE_DIGIT_DASH = /(\d)\s*-\s*(\d)/g;
+var RE_LETTERS_DIGITS = /(^|\s)([a-zA-Z]+)(\d+)(?=\s|$)/g;
+var RE_DIGITS_LETTERS = /(^|\s)(\d+)([a-zA-Z]+)(?=\s|$)/g;
+function preprocessString(input) {
+  let result = input;
+  result = result.replace(RE_LEADING_ZEROS, "$1");
+  result = result.replace(RE_DECIMAL_COMMA, "$1.$2");
+  result = result.replace(RE_STANDALONE_COMMA, ".$1");
+  result = result.replace(RE_ZERO_DECIMAL, ".");
+  result = result.replace(RE_DIGIT_DASH, "$1-$2");
+  result = result.replace(RE_LETTERS_DIGITS, "$1$2 $3");
+  result = result.replace(RE_DIGITS_LETTERS, "$1$2 $3");
+  return result;
+}
+
+// src/utils/sanitiseString.ts
+var RE_DIACRITICS = /[\u0300-\u036f]/g;
+var RE_INVALID_CHARS = /[^a-z0-9.\- ]/g;
+function sanitiseString(input) {
+  let result = input;
+  result = result.toLowerCase();
+  result = result.normalize("NFD").replace(RE_DIACRITICS, "");
+  result = result.replace(RE_INVALID_CHARS, " ");
+  return result;
+}
+
+// src/utils/tokenize.ts
+var DEFAULT_REPLACE_TOKENS = new Map([
+  ["zdravilo", "zdr"],
+  ["izdelek", "izd"],
+  ["material", "mat"],
+  ["pes", "ps"],
+  ["psi", "ps"],
+  ["dog", "ps"],
+  ["cat", "mk"],
+  ["macka", "mk"],
+  ["macke", "mk"],
+  ["ulica", "ul"],
+  ["cesta", "ces"],
+  ["mesanec", "mes"],
+  ["nova", "nv"]
+]);
+var DEFAULT_REMOVE_TOKENS = new Set([
+  "s",
+  "z",
+  "-",
+  "in",
+  "na",
+  "v",
+  "po",
+  "za",
+  "se"
+]);
+var DEFAULT_TOKENIZE_CONFIG = {
+  replaceTokens: DEFAULT_REPLACE_TOKENS,
+  removeTokens: DEFAULT_REMOVE_TOKENS
+};
+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) {
+        const withoutPrefix = token.slice(2);
+        const replaced = config.replaceTokens.get(withoutPrefix);
+        return replaced ? "--" + replaced : token;
+      }
+      return config.replaceTokens.get(token) ?? token;
+    });
+  }
+  if (config?.removeTokens) {
+    tokens = tokens.filter((token) => !config.removeTokens.has(token));
+  }
+  return tokens;
+}
+
+// src/utils/prepareStringForSearch.ts
+function prepareStringForSearch(input) {
+  const datesNormalized = normalizeDates(input);
+  const preprocessed = preprocessString(datesNormalized);
+  const sanitised = sanitiseString(preprocessed);
+  const tokens = tokenize(sanitised, DEFAULT_TOKENIZE_CONFIG);
+  return tokens.sort();
+}
+// src/utils/tokenRegistry.ts
+var INITIAL_CAPACITY = 10 * 1000;
+var tokens = new Array(INITIAL_CAPACITY);
+var tokenCount = 0;
+function getTokenCount() {
+  return tokenCount;
+}
+function getTokenById(id) {
+  return tokens[id];
+}
+function findTokenId(token) {
+  for (let i = 0;i < tokenCount; i++) {
+    if (tokens[i] === token) {
+      return i;
+    }
+  }
+  return -1;
+}
+function registerToken(token) {
+  const id = tokenCount;
+  tokens[id] = token;
+  tokenCount++;
+  return id;
+}
+function getOrCreateTokenId(token, tokensMap) {
+  const existing = tokensMap.get(token);
+  if (existing !== undefined) {
+    return existing;
+  }
+  const id = registerToken(token);
+  tokensMap.set(token, id);
+  return id;
+}
+function createTokensMap() {
+  const map = new Map;
+  for (let i = 0;i < tokenCount; i++) {
+    map.set(tokens[i], i);
+  }
+  return map;
+}
+function clearTokensMap(tokensMap) {
+  tokensMap.clear();
+}
+function resetTokenRegistry() {
+  tokenCount = 0;
+  tokens.length = INITIAL_CAPACITY;
+  tokens.fill(undefined, 0, INITIAL_CAPACITY);
+}
+// src/utils/prepareStringForSearchNumeric.ts
+function prepareStringForSearchNumeric(input, tokensMap) {
+  const datesNormalized = normalizeDates(input);
+  const preprocessed = preprocessString(datesNormalized);
+  const sanitised = sanitiseString(preprocessed);
+  const stringTokens = tokenize(sanitised, DEFAULT_TOKENIZE_CONFIG);
+  const numericTokens = new Array(stringTokens.length);
+  for (let i = 0;i < stringTokens.length; i++) {
+    numericTokens[i] = getOrCreateTokenId(stringTokens[i], tokensMap);
+  }
+  numericTokens.sort((a, b) => a - b);
+  return new Uint32Array(numericTokens);
+}
+
+// src/common/string/createSearchArrayMetadata.ts
+var MATCH_MODE_PREFIXES = {
+  start: "<",
+  end: ">",
+  startEnd: "+",
+  anywhere: "*",
+  whole: "!"
+};
+var PREFIX_TO_MATCH_MODE = {
+  "<": "start",
+  ">": "end",
+  "+": "startEnd",
+  "*": "anywhere",
+  "!": "whole",
+  "=": "whole",
+  "?": "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 = {
+  start: 0,
+  end: 1,
+  startEnd: 2,
+  anywhere: 3,
+  whole: 4
+};
+var MODE_SHIFT = 29;
+var TOKEN_ID_MASK = (1 << MODE_SHIFT) - 1;
+function encodeTokenWithMode(tokenId, mode) {
+  return tokenId | MATCH_MODE_BITS[mode] << MODE_SHIFT;
+}
+function decodeTokenId(encoded) {
+  return encoded & TOKEN_ID_MASK;
+}
+function decodeMatchMode(encoded) {
+  const modeBits = encoded >>> MODE_SHIFT;
+  switch (modeBits) {
+    case 1:
+      return "end";
+    case 2:
+      return "startEnd";
+    case 3:
+      return "anywhere";
+    case 4:
+      return "whole";
+    default:
+      return "start";
+  }
+}
+var DEFAULT_EXCLUDED_FIELDS2 = new Set(["_id", "_deleted", "_blocked"]);
+function getValueByPath2(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 = getValueByPath2(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 isDotNotation2(field) {
+  return field.includes(".");
+}
+function extractStringsFromValue2(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) {
+      extractStringsFromValue2(item, results);
+    }
+  } else if (typeof value === "object") {
+    for (const v of Object.values(value)) {
+      extractStringsFromValue2(v, results);
+    }
+  }
+}
+function prepareObjectForSearchNumeric(obj, spec, tokensMap) {
+  if (isDeletedOrBlocked(obj)) {
+    return;
+  }
+  if (spec?.extractSearchableStringFn) {
+    const searchableString = spec.extractSearchableStringFn(obj);
+    if (searchableString === undefined) {
+      return;
+    }
+    return prepareStringForSearchNumeric(searchableString, tokensMap);
+  }
+  return prepareObjectFieldsForSearchNumeric(obj, spec, tokensMap);
+}
+function prepareObjectFieldsForSearchNumeric(obj, spec, tokensMap) {
+  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 ?? []);
+  for (const key of fieldsToSearch) {
+    const keyStr = key;
+    if (!spec?.searchInFields && DEFAULT_EXCLUDED_FIELDS2.has(keyStr))
+      continue;
+    if (fieldsToExclude.has(key))
+      continue;
+    const isDot = isDotNotation2(keyStr);
+    const value = isDot ? getValueByPath2(obj, keyStr) : obj[key];
+    if (value == null)
+      continue;
+    const matchMode = fieldMatchModes?.[key];
+    const fieldStrings = [];
+    extractStringsFromValue2(value, fieldStrings);
+    if (fieldStrings.length > 0) {
+      const fieldText = fieldStrings.join(" ");
+      const datesNormalized = normalizeDates(fieldText);
+      const preprocessed = preprocessString(datesNormalized);
+      const sanitised = sanitiseString(preprocessed);
+      const stringTokens = tokenize(sanitised, DEFAULT_TOKENIZE_CONFIG);
+      const effectiveMode = matchMode ?? (keyStr === "_id" ? "whole" : undefined);
+      for (const token of stringTokens) {
+        const tokenId = getOrCreateTokenId(token, tokensMap);
+        if (effectiveMode) {
+          allTokens.push(encodeTokenWithMode(tokenId, effectiveMode));
+        } else {
+          allTokens.push(tokenId);
+        }
+      }
+    }
+  }
+  const uniqueTokens = [...new Set(allTokens)].sort((a, b) => a - b);
+  return new Uint32Array(uniqueTokens);
+}
+function createSearchArrayMetadataNumeric(data, spec) {
+  const tokensMap = createTokensMap();
+  try {
+    const metadata = new Map;
+    for (const [id, item] of data) {
+      const tokens2 = prepareObjectForSearchNumeric(item, spec, tokensMap);
+      if (tokens2 !== undefined) {
+        metadata.set(id, tokens2);
+      }
+    }
+    return metadata;
+  } finally {
+    clearTokensMap(tokensMap);
+  }
+}
+// src/common/numeric/createSearchLinkedMetadata.ts
+function createSearchLinkedMetadataNumeric(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);
+    }
+  }
+  return {
+    primaryMeta: primaryMetadata,
+    linkedMeta: linkedMetadata,
+    primaryToLinked,
+    primaryData,
+    linkedData
+  };
+}
+// src/common/numeric/updateSearchMetadata.ts
+function updateSearchMetadataNumeric(metadata, objectId, obj, spec, tokensMap) {
+  const tokens2 = obj != null ? prepareObjectForSearchNumeric(obj, spec, tokensMap) : undefined;
+  if (tokens2 === undefined) {
+    metadata.delete(objectId);
+    return false;
+  } else {
+    metadata.set(objectId, tokens2);
+    return true;
+  }
+}
+function updateSearchMetadataBatchNumeric(metadata, batch, spec) {
+  if (batch.length === 0) {
+    return { updated: 0, removed: 0 };
+  }
+  const tokensMap = createTokensMap();
+  try {
+    let updated = 0;
+    let removed = 0;
+    for (const { objectId, obj } of batch) {
+      const wasUpdated = updateSearchMetadataNumeric(metadata, objectId, obj, spec, tokensMap);
+      if (wasUpdated) {
+        updated++;
+      } else {
+        removed++;
+      }
+    }
+    return { updated, removed };
+  } finally {
+    clearTokensMap(tokensMap);
+  }
+}
+function removeFromSearchMetadataNumeric(metadata, objectId) {
+  return metadata.delete(objectId);
+}
+function removeFromSearchMetadataBatchNumeric(metadata, objectIds) {
+  if (objectIds.length === 0) {
+    return 0;
+  }
+  let removed = 0;
+  for (const id of objectIds) {
+    if (metadata.delete(id)) {
+      removed++;
+    }
+  }
+  return removed;
+}
+// src/utils/matchTokenNumeric.ts
+var RE_NUMERIC = /^[\d.\-]+$/;
+function prepareQueryTokens(queryTokenStrs) {
+  return queryTokenStrs.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.startsWith("~")) {
+      negated = true;
+      cleanStr = str.slice(1);
+    } else if (str.length > 3 && str.startsWith("...")) {
+      overrideMode = "end";
+      cleanStr = str.slice(3);
+    } else if (str.length > 2 && str.startsWith("..")) {
+      overrideMode = "end";
+      cleanStr = str.slice(2);
+    } else if (str.length > 3 && str.endsWith("...")) {
+      overrideMode = "start";
+      cleanStr = str.slice(0, -3);
+    } else if (str.length > 2 && str.endsWith("..")) {
+      overrideMode = "start";
+      cleanStr = str.slice(0, -2);
+    } else if (str.length > 1) {
+      const firstChar = str[0];
+      if (firstChar && PREFIX_TO_MATCH_MODE[firstChar]) {
+        overrideMode = PREFIX_TO_MATCH_MODE[firstChar];
+        cleanStr = str.slice(1);
+      }
+    }
+    return {
+      str: cleanStr,
+      id: findTokenId(cleanStr),
+      isNumeric: RE_NUMERIC.test(cleanStr),
+      overrideMode,
+      negated: negated || undefined
+    };
+  });
+}
+function matchWithModeNumeric(searchTokenId, searchTokenStr, targetTokenEncoded, opts, overrideMode) {
+  const targetTokenId = decodeTokenId(targetTokenEncoded);
+  const targetTokenStr = tokens[targetTokenId];
+  if (!targetTokenStr)
+    return false;
+  const hasExplicitMode = targetTokenEncoded !== targetTokenId;
+  let mode;
+  if (overrideMode) {
+    mode = overrideMode;
+  } 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;
+  }
+  switch (mode) {
+    case "start":
+      return targetTokenStr.startsWith(searchTokenStr);
+    case "end":
+      return targetTokenStr.endsWith(searchTokenStr);
+    case "startEnd":
+      return targetTokenStr.startsWith(searchTokenStr) || targetTokenStr.endsWith(searchTokenStr);
+    case "anywhere":
+      return targetTokenStr.includes(searchTokenStr);
+    case "whole":
+      if (!hasExplicitMode && !overrideMode) {
+        return searchTokenId === targetTokenId;
+      }
+      return targetTokenStr === searchTokenStr;
+  }
+}
+function binarySearchUint32(arr, target) {
+  let left = 0;
+  let right = arr.length - 1;
+  while (left <= right) {
+    const mid = left + right >>> 1;
+    const val = arr[mid];
+    if (val === target)
+      return true;
+    if (val < target) {
+      left = mid + 1;
+    } else {
+      right = mid - 1;
+    }
+  }
+  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) {
+    let hasEncodedTokens = false;
+    for (let i = 0;i < targetTokens.length; i++) {
+      if (targetTokens[i] > TOKEN_ID_MASK) {
+        hasEncodedTokens = true;
+        break;
+      }
+    }
+    if (!hasEncodedTokens) {
+      return binarySearchUint32(targetTokens, searchTokenId);
+    }
+  }
+  for (let i = 0;i < targetTokens.length; i++) {
+    const targetEncoded = targetTokens[i];
+    if (matchWithModeNumeric(searchTokenId, searchTokenStr, targetEncoded, opts, overrideMode)) {
+      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 matches = matchPreparedTokenInSortedList(preparedToken, targetTokens, opts);
+  return negated ? !matches : matches;
+}
+function allPreparedTokensMatch(preparedTokens, targetTokens, opts) {
+  for (const preparedToken of preparedTokens) {
+    const matches = matchPreparedTokenInSortedList(preparedToken, targetTokens, opts);
+    if (preparedToken.negated) {
+      if (matches)
+        return false;
+    } else {
+      if (!matches)
+        return false;
+    }
+  }
+  return true;
+}
+function allTokensMatchNumeric(searchTokenStrs, targetTokens, opts) {
+  const preparedTokens = prepareQueryTokens(searchTokenStrs);
+  return allPreparedTokensMatch(preparedTokens, 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;
+}
+function searchInDataReturnObjectsNumeric(query, metadata, data, opts) {
+  const ids = searchInDataReturnIdsNumeric(query, metadata, opts);
+  const results = new Map;
+  for (const id of ids) {
+    const obj = data.get(id);
+    if (obj) {
+      results.set(id, obj);
+    }
+  }
+  return results;
+}
+function searchInDataReturnIdsWithLimitNumeric(query, metadata, limit, 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);
+      if (results.length >= limit) {
+        break;
+      }
+    }
+  }
+  return results;
+}
+// src/common/numeric/findInLinkedArrays.ts
+function findInLinkedArraysNumeric(query, linked, limit = 10, opts) {
+  const queryTokenStrs = prepareStringForSearch(query);
+  if (queryTokenStrs.length === 0) {
+    return { queryTokens: queryTokenStrs, results: [] };
+  }
+  const preparedTokens = prepareQueryTokens(queryTokenStrs);
+  const positiveTokens = preparedTokens.filter((t) => !t.negated);
+  const negatedTokens = preparedTokens.filter((t) => t.negated);
+  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) || [];
+    let negatedMatchesInPrimary = false;
+    for (const negatedToken of negatedTokens) {
+      if (matchPreparedTokenInSortedList(negatedToken, primaryTokens, opts)) {
+        negatedMatchesInPrimary = true;
+        break;
+      }
+    }
+    if (negatedMatchesInPrimary) {
+      continue;
+    }
+    let totalLength = primaryTokens.length;
+    for (const linkedId of linkedIds) {
+      const linkedTokens = linked.linkedMeta.get(linkedId);
+      if (linkedTokens) {
+        totalLength += linkedTokens.length;
+      }
+    }
+    const allTokens = new Uint32Array(totalLength);
+    let offset = 0;
+    allTokens.set(primaryTokens, offset);
+    offset += primaryTokens.length;
+    for (const linkedId of linkedIds) {
+      const linkedTokens = linked.linkedMeta.get(linkedId);
+      if (linkedTokens) {
+        allTokens.set(linkedTokens, offset);
+        offset += linkedTokens.length;
+      }
+    }
+    allTokens.sort();
+    let allPositiveMatch = true;
+    for (const token of positiveTokens) {
+      if (!matchPreparedTokenInSortedList(token, allTokens, opts)) {
+        allPositiveMatch = false;
+        break;
+      }
+    }
+    if (allPositiveMatch) {
+      let anyMatchInPrimary = false;
+      let anyMatchInLinked = false;
+      const matchingLinkedIds = new Set;
+      const tokensMatchingPrimary = new Set;
+      for (const preparedToken of positiveTokens) {
+        if (matchPreparedTokenInSortedList(preparedToken, primaryTokens, opts)) {
+          anyMatchInPrimary = true;
+          tokensMatchingPrimary.add(preparedToken);
+        }
+      }
+      const tokensForLinkedMatching = positiveTokens.filter((t) => !tokensMatchingPrimary.has(t));
+      if (tokensForLinkedMatching.length > 0 || negatedTokens.length > 0) {
+        for (const linkedId of linkedIds) {
+          const linkedTokens = linked.linkedMeta.get(linkedId);
+          if (linkedTokens) {
+            let matchesNegatedToken = false;
+            for (const negatedToken of negatedTokens) {
+              if (matchPreparedTokenInSortedList(negatedToken, linkedTokens, opts)) {
+                matchesNegatedToken = true;
+                break;
+              }
+            }
+            if (matchesNegatedToken) {
+              continue;
+            }
+            if (tokensForLinkedMatching.length > 0) {
+              const matchesAllNonPrimaryTokens = tokensForLinkedMatching.every((preparedToken) => matchPreparedTokenInSortedList(preparedToken, linkedTokens, opts));
+              if (matchesAllNonPrimaryTokens) {
+                anyMatchInLinked = true;
+                matchingLinkedIds.add(linkedId);
+              }
+            } else {
+              matchingLinkedIds.add(linkedId);
+            }
+          }
+        }
+      }
+      if (tokensForLinkedMatching.length > 0 && matchingLinkedIds.size === 0) {
+        continue;
+      }
+      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"
+      });
+    }
+  }
+  return { queryTokens: queryTokenStrs, results };
+}
+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);
+    }
+  }
+  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++;
+    } 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++;
+    }
+  }
+  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;
+      }
+    } else {
+      if (canEarlyExit) {
+        if (targetToken.startsWith(searchToken)) {
+          return true;
+        }
+        if (targetToken > searchToken && targetToken[0] !== searchToken[0]) {
+          return false;
+        }
+      } else {
+        if (matchToken(searchToken, targetToken, opts)) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function allTokensMatch(searchTokens, targetTokens, opts) {
+  for (const searchToken of searchTokens) {
+    if (!matchTokenInSortedList(searchToken, targetTokens, opts)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/common/findInArrayReturnDataAndMeta.ts
+function findInArrayReturnDataAndMeta(query, data, metadata, limit = 10, opts) {
+  const queryTokens = prepareStringForSearch(query);
+  if (queryTokens.length === 0) {
+    return {
+      queryTokens,
+      results: []
+    };
+  }
+  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
+        });
+      }
+    }
+  }
+  return {
+    queryTokens,
+    results
+  };
+}
+function findInArrayReturnIds(query, metadata, limit = 10, opts) {
+  const queryTokens = prepareStringForSearch(query);
+  if (queryTokens.length === 0) {
+    return [];
+  }
+  const results = [];
+  for (const [id, itemTokens] of metadata) {
+    if (results.length >= limit) {
+      break;
+    }
+    if (allTokensMatch(queryTokens, itemTokens, opts)) {
+      results.push(id);
+    }
+  }
+  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: [] };
+  }
+  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);
+        }
+      }
+      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);
+            }
+          }
+        }
+      }
+      if (tokensForLinkedMatching.length > 0 && matchingLinkedIds.size === 0) {
+        continue;
+      }
+      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"
+      });
+    }
+  }
+  return { queryTokens, results };
+}
+function findInLinkedArraysSimple(query, linked, limit = 10, opts) {
+  return findInLinkedArrays(query, linked, limit, opts).results;
+}
+// src/common/syncSearchArrayMetadata.ts
+function tokensEqual(a, b) {
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0;i < a.length; i++) {
+    if (a[i] !== b[i])
+      return false;
+  }
+  return true;
+}
+function syncSearchArrayMetadata(metadata, newData, spec) {
+  const result = {
+    added: 0,
+    updated: 0,
+    removed: 0,
+    addedIds: [],
+    updatedIds: [],
+    removedIds: []
+  };
+  for (const id of metadata.keys()) {
+    if (!newData.has(id)) {
+      metadata.delete(id);
+      result.removed++;
+      result.removedIds.push(id);
+    }
+  }
+  for (const [id, item] of newData) {
+    const newTokens = prepareObjectForSearch(item, spec);
+    if (newTokens === undefined) {
+      if (metadata.has(id)) {
+        metadata.delete(id);
+        result.removed++;
+        result.removedIds.push(id);
+      }
+      continue;
+    }
+    const existingTokens = metadata.get(id);
+    if (existingTokens === undefined) {
+      metadata.set(id, newTokens);
+      result.added++;
+      result.addedIds.push(id);
+    } else if (!tokensEqual(existingTokens, newTokens)) {
+      metadata.set(id, newTokens);
+      result.updated++;
+      result.updatedIds.push(id);
+    }
+  }
+  return result;
+}
+function syncSearchArrayMetadataWithPrevious(metadata, previousData, newData, options, spec) {
+  const result = {
+    added: 0,
+    updated: 0,
+    removed: 0,
+    addedIds: [],
+    updatedIds: [],
+    removedIds: []
+  };
+  for (const id of previousData.keys()) {
+    if (!newData.has(id)) {
+      metadata.delete(id);
+      result.removed++;
+      result.removedIds.push(id);
+    }
+  }
+  for (const [id, item] of newData) {
+    const wasInPrevious = previousData.has(id);
+    if (!wasInPrevious) {
+      const tokens2 = prepareObjectForSearch(item, spec);
+      if (tokens2 !== undefined) {
+        metadata.set(id, tokens2);
+        result.added++;
+        result.addedIds.push(id);
+      }
+    } else if (!options?.skipUpdateCheck) {
+      const newTokens = prepareObjectForSearch(item, spec);
+      if (newTokens === undefined) {
+        metadata.delete(id);
+        result.removed++;
+        result.removedIds.push(id);
+      } else {
+        const existingTokens = metadata.get(id);
+        if (existingTokens && !tokensEqual(existingTokens, newTokens)) {
+          metadata.set(id, newTokens);
+          result.updated++;
+          result.updatedIds.push(id);
+        }
+      }
+    }
+  }
+  return result;
+}
+// src/common/updateSearchLinkedMetadata.ts
+function tokensEqual2(a, b) {
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0;i < a.length; i++) {
+    if (a[i] !== b[i])
+      return false;
+  }
+  return true;
+}
+function upsertPrimaryItem(linked, item, spec) {
+  const id = item._id;
+  const wasAdded = !linked.primaryData.has(id);
+  linked.primaryData.set(id, item);
+  const tokens2 = prepareObjectForSearch(item, spec);
+  if (tokens2 !== undefined) {
+    linked.primaryMeta.set(id, tokens2);
+  } else {
+    linked.primaryMeta.delete(id);
+  }
+  if (wasAdded && !linked.primaryToLinked.has(id)) {
+    linked.primaryToLinked.set(id, []);
+  }
+  return { added: wasAdded };
+}
+function removePrimaryItem(linked, primaryId) {
+  if (!linked.primaryData.has(primaryId)) {
+    return false;
+  }
+  linked.primaryData.delete(primaryId);
+  linked.primaryMeta.delete(primaryId);
+  linked.primaryToLinked.delete(primaryId);
+  return true;
+}
+function upsertLinkedItem(linked, item, foreignKeyGetter, spec) {
+  const id = item._id;
+  const newPrimaryId = foreignKeyGetter(item);
+  let previousPrimaryId;
+  const existingItem = linked.linkedData.get(id);
+  if (existingItem) {
+    previousPrimaryId = foreignKeyGetter(existingItem);
+  }
+  const wasAdded = !existingItem;
+  linked.linkedData.set(id, item);
+  const tokens2 = prepareObjectForSearch(item, spec);
+  if (tokens2 !== undefined) {
+    linked.linkedMeta.set(id, tokens2);
+  } else {
+    linked.linkedMeta.delete(id);
+  }
+  if (previousPrimaryId !== newPrimaryId) {
+    if (previousPrimaryId) {
+      const oldList = linked.primaryToLinked.get(previousPrimaryId);
+      if (oldList) {
+        const index = oldList.indexOf(id);
+        if (index !== -1) {
+          oldList.splice(index, 1);
+        }
+      }
+    }
+    if (newPrimaryId) {
+      const newList = linked.primaryToLinked.get(newPrimaryId);
+      if (newList) {
+        if (!newList.includes(id)) {
+          newList.push(id);
+        }
+      } else {
+        linked.primaryToLinked.set(newPrimaryId, [id]);
+      }
+    }
+  }
+  return {
+    added: wasAdded,
+    previousPrimaryId: wasAdded ? undefined : previousPrimaryId
+  };
+}
+function removeLinkedItem(linked, linkedId, foreignKeyGetter) {
+  const existingItem = linked.linkedData.get(linkedId);
+  if (!existingItem) {
+    return false;
+  }
+  const primaryId = foreignKeyGetter(existingItem);
+  linked.linkedData.delete(linkedId);
+  linked.linkedMeta.delete(linkedId);
+  if (primaryId) {
+    const list = linked.primaryToLinked.get(primaryId);
+    if (list) {
+      const index = list.indexOf(linkedId);
+      if (index !== -1) {
+        list.splice(index, 1);
+      }
+    }
+  }
+  return true;
+}
+function syncLinkedItemsForPrimary(linked, primaryId, newLinkedItems, foreignKeyGetter, spec) {
+  const result = {
+    added: 0,
+    updated: 0,
+    removed: 0
+  };
+  const currentLinkedIds = new Set(linked.primaryToLinked.get(primaryId) || []);
+  const newLinkedIds = new Set;
+  for (const [id, item] of newLinkedItems) {
+    if (foreignKeyGetter(item) === primaryId) {
+      newLinkedIds.add(id);
+    }
+  }
+  for (const id of currentLinkedIds) {
+    if (!newLinkedIds.has(id)) {
+      const item = linked.linkedData.get(id);
+      if (item) {
+        linked.linkedData.delete(id);
+        linked.linkedMeta.delete(id);
+        result.removed++;
+      }
+    }
+  }
+  for (const id of newLinkedIds) {
+    const item = newLinkedItems.get(id);
+    const tokens2 = prepareObjectForSearch(item, spec);
+    if (currentLinkedIds.has(id)) {
+      const existingTokens = linked.linkedMeta.get(id);
+      if (tokens2 !== undefined) {
+        if (!existingTokens || !tokensEqual2(existingTokens, tokens2)) {
+          linked.linkedMeta.set(id, tokens2);
+          result.updated++;
+        }
+      }
+      linked.linkedData.set(id, item);
+    } else {
+      linked.linkedData.set(id, item);
+      if (tokens2 !== undefined) {
+        linked.linkedMeta.set(id, tokens2);
+      }
+      result.added++;
+    }
+  }
+  linked.primaryToLinked.set(primaryId, Array.from(newLinkedIds));
+  return result;
+}
+// src/common/SearchUniverse.ts
+class SearchUniverse {
+  collections = new Map;
+  registerCollection(name, config = {}) {
+    if (this.collections.has(name)) {
+      throw new Error(`Collection already registered: ${name}`);
+    }
+    const collection = {
+      data: new Map,
+      metadata: new Map,
+      config
+    };
+    if (config.linkedTo) {
+      collection.primaryToLinked = new Map;
+    }
+    this.collections.set(name, collection);
+  }
+  hasCollection(name) {
+    return this.collections.has(name);
+  }
+  getCollectionNames() {
+    return Array.from(this.collections.keys());
+  }
+  loadCollection(name, items) {
+    const collection = this.getCollectionOrThrow(name);
+    collection.data.clear();
+    collection.metadata.clear();
+    if (collection.primaryToLinked) {
+      collection.primaryToLinked.clear();
+    }
+    for (const item of items) {
+      collection.data.set(item._id, item);
+    }
+    const newMetadata = createSearchArrayMetadataNumeric(collection.data, collection.config.spec);
+    for (const [id, tokens2] of newMetadata) {
+      collection.metadata.set(id, tokens2);
+    }
+    if (collection.config.linkedTo && collection.primaryToLinked) {
+      const { foreignKeyGetter } = collection.config.linkedTo;
+      for (const [id, item] of collection.data) {
+        const primaryId = foreignKeyGetter(item);
+        if (primaryId) {
+          const list = collection.primaryToLinked.get(primaryId) || [];
+          list.push(id);
+          collection.primaryToLinked.set(primaryId, list);
+        }
+      }
+    }
+  }
+  getItem(collectionName, id) {
+    const collection = this.getCollectionOrThrow(collectionName);
+    return collection.data.get(id);
+  }
+  getItems(collectionName) {
+    const collection = this.getCollectionOrThrow(collectionName);
+    return Array.from(collection.data.values());
+  }
+  getCollectionSize(collectionName) {
+    const collection = this.getCollectionOrThrow(collectionName);
+    return collection.data.size;
+  }
+  getMetadata(collectionName) {
+    const collection = this.getCollectionOrThrow(collectionName);
+    return collection.metadata;
+  }
+  getData(collectionName) {
+    const collection = this.getCollectionOrThrow(collectionName);
+    return collection.data;
+  }
+  getLinkedIds(linkedCollectionName, primaryId) {
+    const collection = this.getCollectionOrThrow(linkedCollectionName);
+    if (!collection.primaryToLinked) {
+      throw new Error(`Collection ${linkedCollectionName} is not a linked collection`);
+    }
+    return collection.primaryToLinked.get(primaryId) || [];
+  }
+  getLinkedItems(linkedCollectionName, primaryId) {
+    const collection = this.getCollectionOrThrow(linkedCollectionName);
+    const ids = this.getLinkedIds(linkedCollectionName, primaryId);
+    return ids.map((id) => collection.data.get(id)).filter(Boolean);
+  }
+  updateSearchMetadata(collectionName, id, item) {
+    const collection = this.getCollectionOrThrow(collectionName);
+    const existingItem = collection.data.get(id);
+    const wasAdded = !existingItem;
+    let previousPrimaryId;
+    if (collection.config.linkedTo && collection.primaryToLinked) {
+      const { foreignKeyGetter } = collection.config.linkedTo;
+      const fkGetter = foreignKeyGetter;
+      if (existingItem) {
+        previousPrimaryId = fkGetter(existingItem);
+      }
+      const newPrimaryId = fkGetter(item);
+      if (previousPrimaryId !== newPrimaryId) {
+        if (previousPrimaryId) {
+          const oldList = collection.primaryToLinked.get(previousPrimaryId);
+          if (oldList) {
+            const index = oldList.indexOf(id);
+            if (index !== -1) {
+              oldList.splice(index, 1);
+              if (oldList.length === 0) {
+                collection.primaryToLinked.delete(previousPrimaryId);
+              }
+            }
+          }
+        }
+        if (newPrimaryId && !item._deleted && !item._blocked) {
+          const newList = collection.primaryToLinked.get(newPrimaryId) || [];
+          if (!newList.includes(id)) {
+            newList.push(id);
+          }
+          collection.primaryToLinked.set(newPrimaryId, newList);
+        }
+      } else if (item._deleted || item._blocked) {
+        if (previousPrimaryId) {
+          const list = collection.primaryToLinked.get(previousPrimaryId);
+          if (list) {
+            const index = list.indexOf(id);
+            if (index !== -1) {
+              list.splice(index, 1);
+              if (list.length === 0) {
+                collection.primaryToLinked.delete(previousPrimaryId);
+              }
+            }
+          }
+        }
+      }
+    }
+    collection.data.set(id, item);
+    const tokensMap = createTokensMap();
+    try {
+      const tokens2 = prepareObjectForSearchNumeric(item, collection.config.spec, tokensMap);
+      if (tokens2 !== undefined) {
+        collection.metadata.set(id, tokens2);
+      } else {
+        collection.metadata.delete(id);
+      }
+    } finally {
+      clearTokensMap(tokensMap);
+    }
+    return {
+      added: wasAdded,
+      previousPrimaryId: wasAdded ? undefined : previousPrimaryId
+    };
+  }
+  updateSearchMetadataBatch(collectionName, items) {
+    if (items.length === 0) {
+      return { added: 0, updated: 0, removed: 0 };
+    }
+    const result = {
+      added: 0,
+      updated: 0,
+      removed: 0
+    };
+    for (const item of items) {
+      const updateResult = this.updateSearchMetadata(collectionName, item._id, item);
+      if (item._deleted || item._blocked) {
+        result.removed++;
+      } else if (updateResult.added) {
+        result.added++;
+      } else {
+        result.updated++;
+      }
+    }
+    return result;
+  }
+  removeFromSearchMetadata(collectionName, id) {
+    const collection = this.getCollectionOrThrow(collectionName);
+    const existingItem = collection.data.get(id);
+    if (!existingItem) {
+      return false;
+    }
+    if (collection.config.linkedTo && collection.primaryToLinked) {
+      const { foreignKeyGetter } = collection.config.linkedTo;
+      const primaryId = foreignKeyGetter(existingItem);
+      if (primaryId) {
+        const list = collection.primaryToLinked.get(primaryId);
+        if (list) {
+          const index = list.indexOf(id);
+          if (index !== -1) {
+            list.splice(index, 1);
+            if (list.length === 0) {
+              collection.primaryToLinked.delete(primaryId);
+            }
+          }
+        }
+      }
+    }
+    collection.data.delete(id);
+    collection.metadata.delete(id);
+    return true;
+  }
+  removeFromSearchMetadataBatch(collectionName, ids) {
+    if (ids.length === 0) {
+      return 0;
+    }
+    let removed = 0;
+    for (const id of ids) {
+      if (this.removeFromSearchMetadata(collectionName, id)) {
+        removed++;
+      }
+    }
+    return removed;
+  }
+  getCollectionOrThrow(name) {
+    const collection = this.collections.get(name);
+    if (!collection) {
+      throw new Error(`Collection not found: ${name}`);
+    }
+    return collection;
+  }
+  searchUniversally(query, limit = 10, opts) {
+    const results = {};
+    const { inCollections, ...searchOpts } = opts || {};
+    for (const [name, collection] of this.collections) {
+      if (collection.config.linkedTo) {
+        const linkedKey = `${name}-${collection.config.linkedTo.collectionName}`;
+        if (inCollections && !inCollections.includes(name) && !inCollections.includes(linkedKey)) {
+          continue;
+        }
+        const primaryCollectionName = collection.config.linkedTo.collectionName;
+        const primaryCollection = this.collections.get(primaryCollectionName);
+        if (!primaryCollection)
+          continue;
+        const linkedMetadata = {
+          primaryMeta: primaryCollection.metadata,
+          linkedMeta: collection.metadata,
+          primaryToLinked: collection.primaryToLinked || new Map,
+          primaryData: primaryCollection.data,
+          linkedData: collection.data
+        };
+        const linkedSearchResults = findInLinkedArraysNumeric(query, linkedMetadata, limit, searchOpts);
+        if (linkedSearchResults.results.length > 0) {
+          const combinedResults = [];
+          const hasNegation = query.includes("--");
+          for (const result of linkedSearchResults.results) {
+            let linkedItems = result.linked;
+            if (result.matchedIn === "primary" && !hasNegation) {
+              const primaryId = result.primary._id;
+              const allLinkedIds = collection.primaryToLinked?.get(primaryId) || [];
+              linkedItems = allLinkedIds.map((id) => collection.data.get(id)).filter((item) => item !== undefined);
+            }
+            combinedResults.push({
+              primary: result.primary,
+              linked: linkedItems,
+              matchedIn: result.matchedIn
+            });
+          }
+          results[name] = combinedResults;
+        }
+      } else {
+        if (inCollections && !inCollections.includes(name)) {
+          continue;
+        }
+        const matchingIds = searchInDataReturnIdsWithLimitNumeric(query, collection.metadata, limit, searchOpts);
+        if (matchingIds.length > 0) {
+          const collectionResults = [];
+          for (const id of matchingIds) {
+            const item = collection.data.get(id);
+            if (item) {
+              collectionResults.push(item);
+            }
+          }
+          results[name] = collectionResults;
+        }
+      }
+    }
+    return results;
+  }
+  clear() {
+    for (const collection of this.collections.values()) {
+      collection.data.clear();
+      collection.metadata.clear();
+      if (collection.primaryToLinked) {
+        collection.primaryToLinked.clear();
+      }
+    }
+    this.collections.clear();
+  }
+}
+export {
+  wrapMetadataLegacy,
+  upsertPrimaryItem,
+  upsertLinkedItem,
+  updateSearchMetadata as updateSearchMetadataString,
+  updateSearchMetadataBatch as updateSearchMetadataBatchString,
+  updateSearchMetadataBatchNumeric as updateSearchMetadataBatch,
+  updateSearchMetadataNumeric as updateSearchMetadata,
+  unwrapMetadataLegacy,
+  tokens,
+  tokenize,
+  syncSearchArrayMetadataWithPrevious,
+  syncSearchArrayMetadata,
+  syncLinkedItemsForPrimary,
+  searchableDataToArray,
+  searchInDataReturnIdsWithLimitNumeric as searchInDataWithLimit,
+  searchInDataReturnObjectsNumeric as searchInDataReturnObjects,
+  searchInDataReturnIdsNumeric as searchInDataReturnIds,
+  searchInDataReturnIdsNumeric as searchInData,
+  sanitiseString,
+  resetTokenRegistry,
+  removePrimaryItem,
+  removeLinkedItem,
+  removeFromSearchMetadata as removeFromSearchMetadataString,
+  removeFromSearchMetadataBatch as removeFromSearchMetadataBatchString,
+  removeFromSearchMetadataBatchNumeric as removeFromSearchMetadataBatch,
+  removeFromSearchMetadataNumeric as removeFromSearchMetadata,
+  registerToken,
+  preprocessString,
+  prepareStringForSearch,
+  prepareQueryTokens,
+  prepareObjectForSearch as prepareObjectForSearchString,
+  prepareObjectForSearchNumeric as prepareObjectForSearch,
+  normalizeDates,
+  matchTokenInSortedListNumeric,
+  matchTokenInSortedList,
+  matchToken,
+  matchPreparedTokenInSortedList,
+  isDeletedOrBlocked,
+  getTokenCount,
+  getTokenById,
+  getOrCreateTokenId,
+  findTokenId,
+  findInLinkedArraysSimpleNumeric,
+  findInLinkedArraysSimple,
+  findInLinkedArraysNumeric,
+  findInLinkedArrays,
+  findInArrayReturnIds,
+  findInArrayReturnDataAndMeta,
+  findInArray,
+  extractSearchableStringDefault,
+  encodeTokenWithMode,
+  decodeTokenId,
+  decodeMatchMode,
+  createTokensMap,
+  createSearchLinkedMetadata as createSearchLinkedMetadataString,
+  createSearchLinkedMetadataNumeric as createSearchLinkedMetadata,
+  createSearchArrayMetadata as createSearchArrayMetadataString,
+  createSearchArrayMetadataNumeric as createSearchArrayMetadata,
+  clearTokensMap,
+  binarySearchUint32,
+  arrayToSearchableData,
+  allTokensMatchNumeric,
+  allTokensMatch,
+  allPreparedTokensMatch,
+  TOKEN_ID_MASK,
+  SearchUniverse,
+  PREFIX_TO_MATCH_MODE,
+  MATCH_MODE_PREFIXES,
+  MATCH_MODE_BITS,
+  DEFAULT_SEARCH_OPTS
+};