cry-search 1.0.7 → 2.0.0

package/dist/string.js

@@ -1,898 +0,0 @@
-// 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_PURE_DECIMAL = /(?<![a-zčćšžđñ\d.])(\d+)\.(\d+)(?![a-zčćšžđñ.\d])/gi;
-var RE_DIGIT_DASH = /(\d)\s*-\s*(\d)/g;
-var RE_LETTER_DASH_DIGIT = /([a-zčćšžđñ])-(\d)/gi;
-var RE_DIGIT_DASH_LETTER = /(\d)-([a-zčćšžđñ])/gi;
-var RE_LETTER_DASH_LETTER = /(?<=[a-zčćšžđñ])-(?=[a-zčćšžđñ])/gi;
-var RE_LETTERS_DIGITS = /(^|\s)([a-zčćšžđñ]+)(\d+)(?=\s|$)/gi;
-var RE_DIGITS_LETTERS = /(^|\s)(\d+)([a-zčćšžđñ]+)(?=\s|$)/gi;
-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_PURE_DECIMAL, "$1$2");
-  result = result.replace(RE_DIGIT_DASH, "$1-$2");
-  result = result.replace(RE_LETTER_DASH_DIGIT, "$1 $2");
-  result = result.replace(RE_DIGIT_DASH_LETTER, "$1 $2");
-  result = result.replace(RE_LETTER_DASH_LETTER, " ");
-  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.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;
-    });
-  }
-  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/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 tokens = prepareStringForSearch(fieldText);
-      for (const token of tokens) {
-        allTokens.push(prefix + token);
-      }
-    }
-  }
-  return [...new Set(allTokens)].sort();
-}
-function createSearchArrayMetadata(data, spec) {
-  const metadata = new Map;
-  for (const [id, item] of data) {
-    const tokens = prepareObjectForSearch(item, spec);
-    if (tokens !== undefined) {
-      metadata.set(id, tokens);
-    }
-  }
-  return metadata;
-}
-function wrapMetadataLegacy(metadata) {
-  return { items: metadata };
-}
-function unwrapMetadataLegacy(legacy) {
-  return legacy.items;
-}
-// 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 tokens = obj != null ? prepareObjectForSearch(obj, spec) : undefined;
-  if (tokens === undefined) {
-    metadata.delete(objectId);
-    return false;
-  } else {
-    metadata.set(objectId, tokens);
-    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/types/index.ts
-var DEFAULT_SEARCH_OPTS = {
-  matchWords: "start",
-  matchNumbers: "startEnd",
-  matchNumbersShort: "start",
-  matchNumbersThreshold: 6
-};
-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/matchToken.ts
-var RE_NUMERIC = /^[\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_NUMERIC.test(searchToken);
-  return matchWithMode(searchToken, targetToken, isNumeric ? matchNumbers : matchWords);
-}
-function matchTokenInSortedList(searchToken, targetTokens, opts) {
-  const isNumeric = RE_NUMERIC.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);
-  const hasNegation = queryTokens.some((t) => t.startsWith("--") || t.startsWith("~") || t.length > 1 && t[0] === "-" && /^[a-zčćšžđñ]/i.test(t[1]));
-  if (queryTokens.length === 0) {
-    return { queryTokens, results: [], hasNegation: false };
-  }
-  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, hasNegation };
-}
-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 syncSearchArrayMetadataString(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 syncSearchArrayMetadataStringWithPrevious(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 tokens = prepareObjectForSearch(item, spec);
-      if (tokens !== undefined) {
-        metadata.set(id, tokens);
-        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 upsertPrimaryItemString(linked, item, spec) {
-  const id = item._id;
-  const wasAdded = !linked.primaryData.has(id);
-  linked.primaryData.set(id, item);
-  const tokens = prepareObjectForSearch(item, spec);
-  if (tokens !== undefined) {
-    linked.primaryMeta.set(id, tokens);
-  } else {
-    linked.primaryMeta.delete(id);
-  }
-  if (wasAdded && !linked.primaryToLinked.has(id)) {
-    linked.primaryToLinked.set(id, []);
-  }
-  return { added: wasAdded };
-}
-function removePrimaryItemString(linked, primaryId) {
-  if (!linked.primaryData.has(primaryId)) {
-    return false;
-  }
-  linked.primaryData.delete(primaryId);
-  linked.primaryMeta.delete(primaryId);
-  linked.primaryToLinked.delete(primaryId);
-  return true;
-}
-function upsertLinkedItemString(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 tokens = prepareObjectForSearch(item, spec);
-  if (tokens !== undefined) {
-    linked.linkedMeta.set(id, tokens);
-  } 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 removeLinkedItemString(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 syncLinkedItemsForPrimaryString(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 tokens = prepareObjectForSearch(item, spec);
-    if (currentLinkedIds.has(id)) {
-      const existingTokens = linked.linkedMeta.get(id);
-      if (tokens !== undefined) {
-        if (!existingTokens || !tokensEqual2(existingTokens, tokens)) {
-          linked.linkedMeta.set(id, tokens);
-          result.updated++;
-        }
-      }
-      linked.linkedData.set(id, item);
-    } else {
-      linked.linkedData.set(id, item);
-      if (tokens !== undefined) {
-        linked.linkedMeta.set(id, tokens);
-      }
-      result.added++;
-    }
-  }
-  linked.primaryToLinked.set(primaryId, Array.from(newLinkedIds));
-  return result;
-}
-export {
-  wrapMetadataLegacy,
-  upsertPrimaryItemString,
-  upsertLinkedItemString,
-  updateSearchMetadata as updateSearchMetadataString,
-  updateSearchMetadataBatch as updateSearchMetadataBatchString,
-  unwrapMetadataLegacy,
-  tokenize,
-  syncSearchArrayMetadataStringWithPrevious,
-  syncSearchArrayMetadataString,
-  syncLinkedItemsForPrimaryString,
-  searchableDataToArray,
-  sanitiseString,
-  removePrimaryItemString,
-  removeLinkedItemString,
-  removeFromSearchMetadata as removeFromSearchMetadataString,
-  removeFromSearchMetadataBatch as removeFromSearchMetadataBatchString,
-  preprocessString,
-  prepareStringForSearch,
-  prepareObjectForSearch as prepareObjectForSearchString,
-  normalizeDates,
-  matchTokenInSortedList,
-  matchToken,
-  isDeletedOrBlocked,
-  findInLinkedArraysSimple,
-  findInLinkedArrays,
-  findInArrayReturnIds,
-  findInArrayReturnDataAndMeta,
-  findInArray,
-  extractSearchableStringDefault,
-  createSearchLinkedMetadata as createSearchLinkedMetadataString,
-  createSearchArrayMetadata as createSearchArrayMetadataString,
-  arrayToSearchableData,
-  allTokensMatch,
-  PREFIX_TO_MATCH_MODE,
-  MATCH_MODE_PREFIXES,
-  DEFAULT_SEARCH_OPTS
-};