@delali/narsil 0.3.1-next.73 → 0.3.1-next.75

package/dist/{chunk-3YKWSO54.mjs → chunk-NAMGDK45.mjs}

@@ -1,462 +1,45 @@
-import { isWordIndexedBase, flattenSchema, MAX_LATITUDE_DEGREES, MAX_LONGITUDE_DEGREES, MIN_POLYGON_POINTS, parsedTypeOf, isStringValuedBase, withSortableOption, isGeopointOrVectorType, MAX_SORT_FIELDS, MAX_SORT_FIELD_NAME_LENGTH, MAX_CURSOR_LENGTH, MAX_CURSOR_ANCHOR_CODE_POINTS, RESULT_WINDOW, DEFAULT_FUZZY_PREFIX_LENGTH, EARTH_RADIUS_METERS, RADIUS_BOX_MARGIN_RATIO, RADIUS_BOX_MARGIN_RADIANS, FULL_TURN_DEGREES, ANTIMERIDIAN_SPAN_DEGREES, DEFAULT_PAGE_SIZE, PROTOTYPE_POLLUTION_KEYS, DEG_TO_RAD, LOCATION_CODE_BITS_PER_AXIS, isLatitude, isLongitude, isWordIndexedFieldType, PREFIX_MAX_EXPANSIONS, MAX_COVERING_CELLS } from './chunk-AK3BLGCI.mjs';
-import { DEFAULT_PATTERN_WORK_CAP, PATTERN_TEST_OPERATORS, bitsetIsEmpty, MAX_PATTERN_TEXT_CODE_POINTS, MAX_PATTERN_POSITIONS, createBitSet, bitsetSet, PATTERN_WORK_FLUSH_UNITS, MATCHER_STATE_BUDGET_BYTES } from './chunk-ZKRV5M2P.mjs';
-import { compareCodePoints, sortModeOf, defaultSortMode, SORT_VALUE_MAX_CODE_POINTS, toReducedSortValue, readSortField, compareComparableKeys, toComparableSortValue, exceedsCodePoints, holdsUnpairedSurrogate, isSortMode, SORT_MODES, compareSortValues, foldedCodePointCount } from './chunk-LJYTW7GT.mjs';
-import { createNarsilError, ErrorCodes, NarsilError } from './chunk-I64LXKO3.mjs';
+import { MAX_SORT_FIELDS, MAX_SORT_FIELD_NAME_LENGTH, MAX_CURSOR_LENGTH, MAX_CURSOR_ANCHOR_CODE_POINTS, RESULT_WINDOW, DEFAULT_FUZZY_PREFIX_LENGTH, MAX_FILTER_DEPTH, DEFAULT_PAGE_SIZE, MAX_FILTER_ARRAY_SIZE, GEO_UNIT_METRES, MAX_FILTER_TESTS, PREFIX_MAX_EXPANSIONS, PARTIAL_WORD_MIN_CODE_POINTS, PARTIAL_WORDS_ADDED_PER_QUERY } from './chunk-V3B24XR7.mjs';
+import { DEFAULT_PATTERN_WORK_CAP, patternSearchModule, PATTERN_TEST_OPERATORS, bitsetIsEmpty, PATTERN_EXPRESSION_OPERATORS, MAX_PATTERN_POSITIONS, createBitSet, bitsetSet, MAX_PATTERN_TEXT_CODE_POINTS, PATTERN_WORK_FLUSH_UNITS, MATCHER_STATE_BUDGET_BYTES } from './chunk-7ODNRREZ.mjs';
+import { getFlatSchema, tokenize, getFieldValueByInternalId, getFieldValueForDoc, fuzzyTermMatches } from './chunk-UOJIV2NG.mjs';
+import { schemaFieldsOf, MAX_LATITUDE_DEGREES, MAX_LONGITUDE_DEGREES, MIN_POLYGON_POINTS, flattenSchema, parsedTypeOf, isStringValuedBase, withSortableOption, isGeopointOrVectorType, EARTH_RADIUS_METERS, RADIUS_BOX_MARGIN_RATIO, RADIUS_BOX_MARGIN_RADIANS, FULL_TURN_DEGREES, ANTIMERIDIAN_SPAN_DEGREES, PROTOTYPE_POLLUTION_KEYS, DEG_TO_RAD, LOCATION_CODE_BITS_PER_AXIS, isLatitude, isLongitude, isWordIndexedFieldType, partialFieldsOf, MAX_COVERING_CELLS } from './chunk-356UOTK2.mjs';
+import { appendFoldedCodePoint, compareCodePoints, sortModeOf, defaultSortMode, SORT_VALUE_MAX_CODE_POINTS, toReducedSortValue, readSortField, compareComparableKeys, toComparableSortValue, exceedsCodePoints, singleFoldTable, holdsUnpairedSurrogate, isSortMode, SORT_MODES, compareSortValues, foldedCodePointCount, codePointCount } from './chunk-IBR6634K.mjs';
+import { NarsilError, ErrorCodes } from './chunk-I64LXKO3.mjs';
 
-// src/core/tokenizer/constants.ts
-var TOKEN_CACHE_SIZE_FLOOR = 5e4;
-var TOKEN_CACHE_SIZE_CEILING = 2e6;
-var TOKEN_CACHE_BYTES_PER_ENTRY = 200;
-var NODE_TOKEN_CACHE_ENTRIES = 1e6;
-var UNKNOWN_MEMORY_TOKEN_CACHE_ENTRIES = 2e5;
-var CONSTRAINED_MEMORY_TOKEN_CACHE_FRACTION = 0.05;
-var SMALL_DEVICE_MEMORY_GB = 1;
-var MEDIUM_DEVICE_MEMORY_GB = 4;
-var SMALL_DEVICE_TOKEN_CACHE_ENTRIES = 1e5;
-var MEDIUM_DEVICE_TOKEN_CACHE_ENTRIES = 25e4;
-var LARGE_DEVICE_TOKEN_CACHE_ENTRIES = 5e5;
-var DEFAULT_MIN_TOKEN_LENGTH = 1;
-
-// src/core/tokenizer/normalize.ts
-var DOTTED_CAPITAL_I = "\u0130";
-var COMBINING_DOT_ABOVE = "\u0307";
-var ARMENIAN_MARKS = /[\u055B-\u055F]/;
-var FOLDED_FORMS = /\u0307|[\u0130\u055B-\u055F\u2018\u2019\u02BC\u02BB]/g;
-var WIDTH_FORMS = /[\uFF01-\uFF5E\uFF61-\uFF9F]/;
-var WIDTH_FORMS_GLOBAL = /[\uFF01-\uFF5E\uFF61-\uFF9F]/g;
-var FULLWIDTH_ASCII_END = 65374;
-var FULLWIDTH_ASCII_OFFSET = 65248;
-var HALFWIDTH_KANA_START = 65377;
-var HALFWIDTH_VOICED_MARK = 65438;
-var HALFWIDTH_SEMI_VOICED_MARK = 65439;
-var COMBINING_VOICED_MARK = "\u3099";
-var COMBINING_SEMI_VOICED_MARK = "\u309A";
-var HALFWIDTH_KANA_TARGETS = "\u3002\u300C\u300D\u3001\u30FB\u30F2\u30A1\u30A3\u30A5\u30A7\u30A9\u30E3\u30E5\u30E7\u30C3\u30FC\u30A2\u30A4\u30A6\u30A8\u30AA\u30AB\u30AD\u30AF\u30B1\u30B3\u30B5\u30B7\u30B9\u30BB\u30BD\u30BF\u30C1\u30C4\u30C6\u30C8\u30CA\u30CB\u30CC\u30CD\u30CE\u30CF\u30D2\u30D5\u30D8\u30DB\u30DE\u30DF\u30E0\u30E1\u30E2\u30E4\u30E6\u30E8\u30E9\u30EA\u30EB\u30EC\u30ED\u30EF\u30F3";
-function foldForm(match) {
-  if (match === DOTTED_CAPITAL_I) return "i";
-  if (match === COMBINING_DOT_ABOVE || ARMENIAN_MARKS.test(match)) return "";
-  return "'";
-}
-function foldWidth(match) {
-  const codePoint = match.charCodeAt(0);
-  if (codePoint <= FULLWIDTH_ASCII_END) return String.fromCharCode(codePoint - FULLWIDTH_ASCII_OFFSET);
-  if (codePoint === HALFWIDTH_VOICED_MARK) return COMBINING_VOICED_MARK;
-  if (codePoint === HALFWIDTH_SEMI_VOICED_MARK) return COMBINING_SEMI_VOICED_MARK;
-  return HALFWIDTH_KANA_TARGETS[codePoint - HALFWIDTH_KANA_START];
-}
-function isAscii(text) {
-  for (let i = 0; i < text.length; i++) {
-    if (text.charCodeAt(i) > 127) return false;
-  }
-  return true;
-}
-function foldWidthForms(text) {
-  if (!WIDTH_FORMS.test(text)) return text;
-  return text.replace(WIDTH_FORMS_GLOBAL, foldWidth);
-}
-function normalizeForSplitting(text) {
-  if (isAscii(text)) return text.toLowerCase();
-  return foldWidthForms(text).normalize("NFC").replace(FOLDED_FORMS, foldForm).toLowerCase();
-}
-function stripDiacritics(text) {
-  return text.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+// src/core/pattern-index/platform.ts
+function platformPatternSearch() {
+  return patternSearchModule;
 }
 
-// src/core/tokenizer/cache.ts
-function clampCacheSize(entries) {
-  return Math.max(TOKEN_CACHE_SIZE_FLOOR, Math.min(entries, TOKEN_CACHE_SIZE_CEILING));
+// src/core/pattern-index/registry.ts
+var registered = null;
+function isPatternSearchModule(value) {
+  return value !== null && typeof value === "object" && value.name === "pattern" && "createIndex" in value && typeof value.createIndex === "function" && "readArrays" in value && typeof value.readArrays === "function" && "mergeArrays" in value && typeof value.mergeArrays === "function" && "matchInto" in value && typeof value.matchInto === "function" && "checkExpression" in value && typeof value.checkExpression === "function" && "expressionFootprint" in value && typeof value.expressionFootprint === "function";
 }
-function computeDefaultCacheSize() {
-  try {
-    if (typeof process !== "undefined" && typeof process.versions?.node === "string" && typeof window === "undefined") {
-      const constrainedMemory = typeof process.constrainedMemory === "function" ? process.constrainedMemory() : 0;
-      if (constrainedMemory > 0 && constrainedMemory < Number.MAX_SAFE_INTEGER) {
-        const budget = constrainedMemory * CONSTRAINED_MEMORY_TOKEN_CACHE_FRACTION;
-        return clampCacheSize(Math.floor(budget / TOKEN_CACHE_BYTES_PER_ENTRY));
-      }
-      return clampCacheSize(NODE_TOKEN_CACHE_ENTRIES);
-    }
-    if (typeof navigator !== "undefined") {
-      const mem = navigator.deviceMemory;
-      if (typeof mem === "number" && mem > 0) {
-        let entries;
-        if (mem <= SMALL_DEVICE_MEMORY_GB) entries = SMALL_DEVICE_TOKEN_CACHE_ENTRIES;
-        else if (mem <= MEDIUM_DEVICE_MEMORY_GB) entries = MEDIUM_DEVICE_TOKEN_CACHE_ENTRIES;
-        else entries = LARGE_DEVICE_TOKEN_CACHE_ENTRIES;
-        return clampCacheSize(entries);
-      }
-    }
-  } catch {
-    return clampCacheSize(UNKNOWN_MEMORY_TOKEN_CACHE_ENTRIES);
-  }
-  return clampCacheSize(UNKNOWN_MEMORY_TOKEN_CACHE_ENTRIES);
-}
-var normalizationCache = /* @__PURE__ */ new Map();
-var normalizationCacheSize = 0;
-var maxCacheSize = computeDefaultCacheSize();
-var cachedLangName = "";
-var cachedFlags = "";
-var cachedBucket = null;
-function configureNormalizationCache(maxSize) {
-  if (!Number.isFinite(maxSize)) {
-    throw createNarsilError(ErrorCodes.CONFIG_INVALID, "tokenizerCacheSize must be a finite number", {
-      received: maxSize
-    });
-  }
-  if (maxSize < 0) {
-    throw createNarsilError(ErrorCodes.CONFIG_INVALID, "tokenizerCacheSize must not be negative", {
-      received: maxSize
-    });
-  }
-  if (maxSize === 0) {
-    throw createNarsilError(
+function registerPatternSearch(module) {
+  if (!isPatternSearchModule(module)) {
+    throw new NarsilError(
       ErrorCodes.CONFIG_INVALID,
-      "tokenizerCacheSize must be greater than zero; the normalization cache cannot be disabled",
-      {
-        received: maxSize
-      }
+      'registerPatternSearch takes the patternSearch object that "@delali/narsil/pattern" exports'
     );
   }
-  maxCacheSize = Math.max(TOKEN_CACHE_SIZE_FLOOR, Math.min(Math.floor(maxSize), TOKEN_CACHE_SIZE_CEILING));
-  if (normalizationCacheSize > maxCacheSize) {
-    evictOldestEntries(normalizationCacheSize - maxCacheSize);
-  }
-}
-function getCacheBucket(language, flags) {
-  const langKey = `${language.name}@${language.revision}`;
-  if (cachedBucket && langKey === cachedLangName && flags === cachedFlags) return cachedBucket;
-  const key = `${langKey}:${flags}`;
-  let bucket = normalizationCache.get(key);
-  if (!bucket) {
-    bucket = /* @__PURE__ */ new Map();
-    normalizationCache.set(key, bucket);
-  }
-  cachedLangName = langKey;
-  cachedFlags = flags;
-  cachedBucket = bucket;
-  return bucket;
-}
-function evictOldestEntries(count) {
-  let remaining = count;
-  for (const [key, bucket] of normalizationCache) {
-    if (remaining <= 0) break;
-    if (bucket.size <= remaining) {
-      remaining -= bucket.size;
-      normalizationCacheSize -= bucket.size;
-      normalizationCache.delete(key);
-      if (bucket === cachedBucket) cachedBucket = null;
-    } else {
-      let deleted = 0;
-      for (const raw of bucket.keys()) {
-        if (deleted >= remaining) break;
-        bucket.delete(raw);
-        deleted++;
-      }
-      normalizationCacheSize -= deleted;
-      remaining = 0;
-    }
-  }
-}
-function transformToken(raw, language, stem, removeDiacritics) {
-  const flags = (stem ? "s" : "") + (removeDiacritics ? "d" : "");
-  let bucket = getCacheBucket(language, flags);
-  const cached = bucket.get(raw);
-  if (cached !== void 0) return cached;
-  let normalized = raw;
-  if (language.normalizer) {
-    normalized = language.normalizer(normalized);
-  }
-  if (removeDiacritics) {
-    normalized = stripDiacritics(normalized);
-  }
-  if (stem && language.stemmer) {
-    normalized = language.stemmer(normalized);
-  }
-  if (normalizationCacheSize >= maxCacheSize) {
-    evictOldestEntries(Math.max(1, maxCacheSize >>> 2));
-    bucket = getCacheBucket(language, flags);
-  }
-  bucket.set(raw, normalized);
-  normalizationCacheSize++;
-  return normalized;
+  registered = module;
 }
-function clearNormalizationCache() {
-  normalizationCache.clear();
-  normalizationCacheSize = 0;
-  cachedBucket = null;
+function availablePatternSearch() {
+  return registered ?? platformPatternSearch();
 }
-function resetNormalizationCache() {
-  clearNormalizationCache();
-  maxCacheSize = computeDefaultCacheSize();
-}
-function getNormalizationCacheSize() {
-  return normalizationCacheSize;
-}
-
-// src/core/tokenizer/ngrams.ts
-var OTHER_SCRIPT = 0;
-var HAN_SCRIPT = 1;
-var HIRAGANA_SCRIPT = 2;
-var KATAKANA_SCRIPT = 3;
-var HANGUL_SCRIPT = 4;
-var THAI_SCRIPT = 5;
-var LAO_SCRIPT = 6;
-var KHMER_SCRIPT = 7;
-var MYANMAR_SCRIPT = 8;
-var PROLONGED_SOUND_MARK = 12540;
-var IDEOGRAPHIC_ITERATION_MARK = 12293;
-var LOWEST_NGRAM_CODE_POINT = 3584;
-var LOWEST_MARK_CODE_POINT = 768;
-var THAI_BLOCK_END = 3711;
-var LAO_BLOCK_END = 3839;
-var MYANMAR_BLOCK_START = 4096;
-var MYANMAR_BLOCK_END = 4255;
-var KHMER_BLOCK_START = 6016;
-var KHMER_BLOCK_END = 6655;
-var SOUTHEAST_ASIAN_BLOCKS_END = 6656;
-var HIRAGANA_BLOCK_START = 12352;
-var HIRAGANA_BLOCK_END = 12447;
-var COMBINING_VOICED_MARK2 = 12441;
-var COMBINING_SEMI_VOICED_MARK2 = 12442;
-var KATAKANA_BLOCK_START = 12448;
-var KATAKANA_BLOCK_END = 12543;
-var HAN_EXTENSION_A_START = 13312;
-var HAN_EXTENSION_A_END = 19903;
-var HAN_UNIFIED_START = 19968;
-var HAN_UNIFIED_END = 40959;
-var HANGUL_SYLLABLE_START = 44032;
-var HANGUL_SYLLABLE_END = 55203;
-var HAN_COMPATIBILITY_START = 63744;
-var HAN_COMPATIBILITY_END = 64255;
-var SUPPLEMENTARY_PLANE_START = 65536;
-var MARK = /\p{M}/uy;
-var HAN = /\p{Script=Han}/uy;
-var HIRAGANA = /\p{Script=Hiragana}/uy;
-var KATAKANA = /\p{Script=Katakana}/uy;
-var HANGUL = /\p{Script=Hangul}/uy;
-var THAI = /\p{Script=Thai}/uy;
-var LAO = /\p{Script=Lao}/uy;
-var KHMER = /\p{Script=Khmer}/uy;
-var MYANMAR = /\p{Script=Myanmar}/uy;
-function matchesAt(pattern, part, index) {
-  pattern.lastIndex = index;
-  return pattern.test(part);
-}
-function isMark(part, index, codePoint) {
-  if (codePoint < LOWEST_MARK_CODE_POINT) return false;
-  if (codePoint >= HAN_UNIFIED_START && codePoint <= HAN_UNIFIED_END) return false;
-  if (codePoint >= HIRAGANA_BLOCK_START && codePoint <= KATAKANA_BLOCK_END) {
-    return codePoint === COMBINING_VOICED_MARK2 || codePoint === COMBINING_SEMI_VOICED_MARK2;
-  }
-  if (codePoint >= HANGUL_SYLLABLE_START && codePoint <= HANGUL_SYLLABLE_END) return false;
-  if (codePoint >= HAN_EXTENSION_A_START && codePoint <= HAN_EXTENSION_A_END) return false;
-  return matchesAt(MARK, part, index);
-}
-function classifyOutsideCommonBlocks(part, index) {
-  if (matchesAt(HAN, part, index)) return HAN_SCRIPT;
-  if (matchesAt(HIRAGANA, part, index)) return HIRAGANA_SCRIPT;
-  if (matchesAt(KATAKANA, part, index)) return KATAKANA_SCRIPT;
-  if (matchesAt(HANGUL, part, index)) return HANGUL_SCRIPT;
-  if (matchesAt(THAI, part, index)) return THAI_SCRIPT;
-  if (matchesAt(LAO, part, index)) return LAO_SCRIPT;
-  if (matchesAt(KHMER, part, index)) return KHMER_SCRIPT;
-  if (matchesAt(MYANMAR, part, index)) return MYANMAR_SCRIPT;
-  return OTHER_SCRIPT;
-}
-function classifySoutheastAsian(part, index, codePoint) {
-  if (codePoint <= THAI_BLOCK_END) return matchesAt(THAI, part, index) ? THAI_SCRIPT : OTHER_SCRIPT;
-  if (codePoint <= LAO_BLOCK_END) return matchesAt(LAO, part, index) ? LAO_SCRIPT : OTHER_SCRIPT;
-  if (codePoint >= MYANMAR_BLOCK_START && codePoint <= MYANMAR_BLOCK_END) {
-    return matchesAt(MYANMAR, part, index) ? MYANMAR_SCRIPT : OTHER_SCRIPT;
-  }
-  if (codePoint >= KHMER_BLOCK_START && codePoint <= KHMER_BLOCK_END) {
-    return matchesAt(KHMER, part, index) ? KHMER_SCRIPT : OTHER_SCRIPT;
-  }
-  return classifyOutsideCommonBlocks(part, index);
-}
-function classify(part, index, codePoint, current) {
-  if (codePoint < LOWEST_NGRAM_CODE_POINT) return OTHER_SCRIPT;
-  if (codePoint < SOUTHEAST_ASIAN_BLOCKS_END) return classifySoutheastAsian(part, index, codePoint);
-  if (codePoint === PROLONGED_SOUND_MARK) {
-    return current === HIRAGANA_SCRIPT ? HIRAGANA_SCRIPT : KATAKANA_SCRIPT;
-  }
-  if (codePoint >= HIRAGANA_BLOCK_START && codePoint <= HIRAGANA_BLOCK_END) return HIRAGANA_SCRIPT;
-  if (codePoint >= KATAKANA_BLOCK_START && codePoint <= KATAKANA_BLOCK_END) return KATAKANA_SCRIPT;
-  if (codePoint >= HAN_UNIFIED_START && codePoint <= HAN_UNIFIED_END) return HAN_SCRIPT;
-  if (codePoint >= HAN_EXTENSION_A_START && codePoint <= HAN_EXTENSION_A_END) return HAN_SCRIPT;
-  if (codePoint >= HANGUL_SYLLABLE_START && codePoint <= HANGUL_SYLLABLE_END) return HANGUL_SCRIPT;
-  if (codePoint >= HAN_COMPATIBILITY_START && codePoint <= HAN_COMPATIBILITY_END) return HAN_SCRIPT;
-  if (codePoint === IDEOGRAPHIC_ITERATION_MARK) return HAN_SCRIPT;
-  return classifyOutsideCommonBlocks(part, index);
-}
-function emitRun(part, offsets, kind, size, out) {
-  const count = offsets.length - 1;
-  if (count < 1) return;
-  if (kind === OTHER_SCRIPT || count <= size) {
-    out.push(part.slice(offsets[0], offsets[count]));
-    return;
+function requirePatternSearchFor(schema) {
+  for (const { path, pattern } of schemaFieldsOf(schema)) {
+    if (pattern) requirePatternSearch(path);
   }
-  for (let start = 0; start + size <= count; start++) {
-    out.push(part.slice(offsets[start], offsets[start + size]));
-  }
-}
-function expandNgrams(part, size, out) {
-  const length = part.length;
-  if (length === 0) return;
-  const offsets = [];
-  let kind = OTHER_SCRIPT;
-  let index = 0;
-  while (index < length) {
-    const codePoint = part.codePointAt(index);
-    if (codePoint === void 0) break;
-    const width = codePoint >= SUPPLEMENTARY_PLANE_START ? 2 : 1;
-    if (offsets.length > 0 && isMark(part, index, codePoint)) {
-      index += width;
-      continue;
-    }
-    const next = classify(part, index, codePoint, kind);
-    if (offsets.length > 0 && next !== kind) {
-      offsets.push(index);
-      emitRun(part, offsets, kind, size, out);
-      offsets.length = 0;
-    }
-    kind = next;
-    offsets.push(index);
-    index += width;
-  }
-  offsets.push(length);
-  emitRun(part, offsets, kind, size, out);
 }
-
-// src/core/tokenizer/tokenize.ts
-function producesSurfaceForms(language, options) {
-  if (!options?.collectSurfaces || options.customTokenizer) return false;
-  return (options.stem ?? true) && language.stemmer !== null;
-}
-var DEFAULT_SPLIT_PATTERN = /[^\p{L}\p{M}\p{N}_'-]+/u;
-function resolveStopWords(language, override) {
-  if (!override) return language.stopWords;
-  if (override instanceof Set) return override;
-  return override(language.stopWords);
-}
-function splitText(text, language) {
-  const pattern = language.tokenizer?.splitPattern ?? DEFAULT_SPLIT_PATTERN;
-  const parts = text.split(pattern);
-  const ngramSize = language.tokenizer?.ngramSize;
-  if (ngramSize === void 0 || ngramSize < 1) return parts;
-  const size = Math.floor(ngramSize);
-  const expanded = [];
-  for (const part of parts) {
-    expandNgrams(part, size, expanded);
-  }
-  return expanded;
-}
-var CHAR_APOSTROPHE = 39;
-var CHAR_S = 115;
-function stripPossessive(token) {
-  const len = token.length;
-  if (len >= 2 && token.charCodeAt(len - 1) === CHAR_S && token.charCodeAt(len - 2) === CHAR_APOSTROPHE) {
-    return token.slice(0, -2);
-  }
-  if (len >= 1 && token.charCodeAt(len - 1) === CHAR_APOSTROPHE) {
-    return token.slice(0, -1);
-  }
-  return token;
-}
-function visitTokens(text, language, options, visit) {
-  const {
-    stem = true,
-    removeStopWords = true,
-    removeDiacritics = false,
-    collectSurfaces = false,
-    customTokenizer,
-    stopWordOverride
-  } = options ?? {};
-  if (customTokenizer) {
-    for (const entry of customTokenizer.tokenize(text)) visit(entry.token, entry.position, void 0, entry.token);
-    return;
-  }
-  const rawParts = splitText(normalizeForSplitting(text), language);
-  const minLength = language.tokenizer?.minTokenLength ?? DEFAULT_MIN_TOKEN_LENGTH;
-  const effectiveDiacritics = removeDiacritics || (language.tokenizer?.normalizeDiacritics ?? false);
-  const wantSurfaces = collectSurfaces && stem && language.stemmer !== null;
-  const stopWords = removeStopWords ? resolveStopWords(language, stopWordOverride) : null;
-  const stripPossessives = language.tokenizer?.stripPossessive ?? false;
-  for (let position = 0; position < rawParts.length; position++) {
-    const part = rawParts[position];
-    const candidate = stripPossessives ? stripPossessive(part) : part;
-    if (candidate.length < minLength || stopWords?.has(candidate)) continue;
-    const processed = transformToken(candidate, language, stem, effectiveDiacritics);
-    if (processed.length === 0) continue;
-    if (!wantSurfaces) {
-      visit(processed, position, void 0, part);
-      continue;
-    }
-    const surface = effectiveDiacritics ? transformToken(candidate, language, false, true) : candidate;
-    visit(processed, position, surface === processed ? void 0 : surface, part);
-  }
-}
-function tokenize(text, language, options) {
-  if (options?.customTokenizer) {
-    const customResult = options.customTokenizer.tokenize(text);
-    return { tokens: customResult, originalTokens: customResult.map((entry) => entry.token) };
-  }
-  const tokens = [];
-  const originalTokens = [];
-  const surfaces = producesSurfaceForms(language, options) ? [] : void 0;
-  visitTokens(text, language, options, (token, position, surface, original) => {
-    tokens.push({ token, position });
-    originalTokens.push(original);
-    surfaces?.push(surface);
-  });
-  return { tokens, originalTokens, surfaces };
-}
-function* tokenizeIterator(text, language, options) {
-  const {
-    stem = true,
-    removeStopWords = true,
-    removeDiacritics = false,
-    collectSurfaces = false,
-    customTokenizer,
-    stopWordOverride
-  } = options ?? {};
-  if (customTokenizer) {
-    const customResult = customTokenizer.tokenize(text);
-    for (const entry of customResult) {
-      yield entry;
-    }
-    return;
-  }
-  const normalized = normalizeForSplitting(text);
-  const rawParts = splitText(normalized, language);
-  const minLength = language.tokenizer?.minTokenLength ?? DEFAULT_MIN_TOKEN_LENGTH;
-  const effectiveDiacritics = removeDiacritics || (language.tokenizer?.normalizeDiacritics ?? false);
-  const stemsTokens = stem && language.stemmer !== null;
-  const wantSurfaces = collectSurfaces && stemsTokens;
-  const stopWords = removeStopWords ? resolveStopWords(language, stopWordOverride) : /* @__PURE__ */ new Set();
-  const stripPossessives = language.tokenizer?.stripPossessive ?? false;
-  let position = 0;
-  for (const part of rawParts) {
-    const candidate = stripPossessives ? stripPossessive(part) : part;
-    if (candidate.length < minLength) {
-      position++;
-      continue;
-    }
-    if (stopWords.has(candidate)) {
-      position++;
-      continue;
-    }
-    const processed = transformToken(candidate, language, stem, effectiveDiacritics);
-    if (processed.length > 0) {
-      if (wantSurfaces) {
-        const surface = effectiveDiacritics ? transformToken(candidate, language, false, true) : candidate;
-        yield { token: processed, position, surface: surface === processed ? void 0 : surface };
-      } else {
-        yield { token: processed, position };
-      }
-    }
-    position++;
-  }
+function requirePatternSearch(fieldPath) {
+  const module = availablePatternSearch();
+  if (module !== null) return module;
+  throw new NarsilError(
+    ErrorCodes.CONFIG_INVALID,
+    `Field "${fieldPath}" is a pattern field, but this bundle contains no pattern search code. Add import { patternSearch } from '@delali/narsil/pattern', then call registerPatternSearch(patternSearch) before you create or load the index`,
+    { field: fieldPath }
+  );
 }
 
 // src/core/pattern-index/work-meter.ts
@@ -768,78 +351,6 @@ function heapPop(heap) {
   return top;
 }
 
-// src/core/partition/utils.ts
-function getOrCreateFieldNameIndex(table, fieldName) {
-  const existing = table.indexMap.get(fieldName);
-  if (existing !== void 0) return existing;
-  const idx = table.names.length;
-  table.names.push(fieldName);
-  table.indexMap.set(fieldName, idx);
-  return idx;
-}
-var VECTOR_PATTERN = /^vector\[(\d+)]$/;
-function getNestedValue(obj, path) {
-  const parts = path.split(".");
-  let current = obj;
-  for (let i = 0; i < parts.length; i++) {
-    if (current === null || current === void 0 || typeof current !== "object") return void 0;
-    if (!Object.hasOwn(current, parts[i])) return void 0;
-    current = current[parts[i]];
-  }
-  return current;
-}
-function stringArraysEqual(a, b) {
-  if (a === b) return true;
-  if (!a || !b) return false;
-  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 textFieldsChanged(oldDoc, newDoc, fields) {
-  for (const { path, base } of fields) {
-    if (!isWordIndexedBase(base)) continue;
-    const oldVal = getNestedValue(oldDoc, path);
-    const newVal = getNestedValue(newDoc, path);
-    if (base === "string") {
-      if (oldVal !== newVal) return true;
-    } else {
-      if (!stringArraysEqual(oldVal, newVal)) return true;
-    }
-  }
-  return false;
-}
-function parseVectorDimension(fieldType) {
-  const match = VECTOR_PATTERN.exec(fieldType);
-  return match ? Number.parseInt(match[1], 10) : null;
-}
-function tokenizeOptions(options) {
-  return {
-    stem: true,
-    removeStopWords: true,
-    collectSurfaces: options?.collectSurfaces === true,
-    stopWordOverride: options?.stopWordOverride,
-    customTokenizer: options?.customTokenizer
-  };
-}
-function getFlatSchema(state, schema) {
-  if (state.lastSchemaRef === schema && state.flatSchemaCache) return state.flatSchemaCache;
-  state.flatSchemaCache = flattenSchema(schema);
-  state.lastSchemaRef = schema;
-  return state.flatSchemaCache;
-}
-function getFieldValueForDoc(docStore, docId, fieldPath) {
-  const stored = docStore.get(docId);
-  if (!stored) return void 0;
-  return getNestedValue(stored.fields, fieldPath);
-}
-function getFieldValueByInternalId(docStore, internalId, fieldPath) {
-  const externalId = docStore.getExternalId(internalId);
-  if (externalId === void 0) return void 0;
-  return getFieldValueForDoc(docStore, externalId, fieldPath);
-}
-
 // src/core/partition/facets.ts
 var UNDECLARED_FIELD_TYPE = "";
 function keptFacetValues(limit) {
@@ -1039,67 +550,6 @@ function mergeFacets(partitionFacets, config) {
   return result;
 }
 
-// src/core/fuzzy.ts
-var FIRST_SURROGATE = 55296;
-var LAST_SURROGATE = 57343;
-var LAST_BASIC_PLANE_CODE_POINT = 65535;
-function hasSurrogate(text) {
-  for (let index = 0; index < text.length; index++) {
-    const unit = text.charCodeAt(index);
-    if (unit >= FIRST_SURROGATE && unit <= LAST_SURROGATE) return true;
-  }
-  return false;
-}
-function fuzzyPrefixOf(queryTerm, prefixLength) {
-  let end = 0;
-  for (let counted = 0; counted < prefixLength && end < queryTerm.length; counted++) {
-    const codePoint = queryTerm.codePointAt(end);
-    end += codePoint !== void 0 && codePoint > LAST_BASIC_PLANE_CODE_POINT ? 2 : 1;
-  }
-  return queryTerm.slice(0, end);
-}
-function fuzzyTermMatches(queryTerm, indexTerm, tolerance, prefixLength) {
-  if (queryTerm === indexTerm) return true;
-  if (tolerance <= 0) return false;
-  if (!indexTerm.startsWith(fuzzyPrefixOf(queryTerm, prefixLength))) return false;
-  return boundedLevenshtein(queryTerm, indexTerm, tolerance).withinTolerance;
-}
-function boundedLevenshtein(a, b, tolerance) {
-  if (tolerance < 0) return { distance: -1, withinTolerance: false };
-  if (a === b) return { distance: 0, withinTolerance: true };
-  if (hasSurrogate(a) || hasSurrogate(b)) return bandedDistance(Array.from(a), Array.from(b), tolerance);
-  return bandedDistance(a, b, tolerance);
-}
-function bandedDistance(a, b, tolerance) {
-  const m = a.length;
-  const n = b.length;
-  const beyond = tolerance + 1;
-  if (Math.abs(m - n) > tolerance) return { distance: beyond, withinTolerance: false };
-  let previous = new Uint32Array(n + 1).fill(beyond);
-  let current = new Uint32Array(n + 1).fill(beyond);
-  const firstRowEnd = Math.min(n, tolerance);
-  for (let j = 0; j <= firstRowEnd; j++) previous[j] = j;
-  for (let i = 1; i <= m; i++) {
-    const low = Math.max(1, i - tolerance);
-    const high = Math.min(n, i + tolerance);
-    current[low - 1] = low === 1 ? i : beyond;
-    let rowMin = current[low - 1];
-    const character = a[i - 1];
-    for (let j = low; j <= high; j++) {
-      const substitution = previous[j - 1] + (character === b[j - 1] ? 0 : 1);
-      const cell = Math.min(previous[j] + 1, current[j - 1] + 1, substitution, beyond);
-      current[j] = cell;
-      if (cell < rowMin) rowMin = cell;
-    }
-    if (rowMin > tolerance) return { distance: beyond, withinTolerance: false };
-    const finished = previous;
-    previous = current;
-    current = finished;
-  }
-  const distance = previous[n];
-  return { distance, withinTolerance: distance <= tolerance };
-}
-
 // src/search/cursor-codec.ts
 function encodeCursorText(text) {
   if (typeof Buffer !== "undefined") return Buffer.from(text, "utf-8").toString("base64");
@@ -1116,12 +566,6 @@ function decodeCursorText(encoded) {
   return new TextDecoder().decode(bytes);
 }
 
-// src/filters/constants.ts
-var MAX_FILTER_DEPTH = 30;
-var MAX_FILTER_TESTS = 1024;
-var MAX_FILTER_ARRAY_SIZE = 65536;
-var GEO_UNIT_METRES = { km: 1e3, mi: 1609.344, m: 1 };
-
 // src/filters/operands/checks.ts
 function operandKindOf(type) {
   if (type === void 0) return void 0;
@@ -1542,6 +986,34 @@ function requireSizeOperands(fieldPath, filter, type) {
   }
 }
 
+// src/core/pattern-index/host.ts
+var NO_SOURCES = [];
+var foldSources = null;
+function sourcesByFold() {
+  if (foldSources !== null) return foldSources;
+  const sources = /* @__PURE__ */ new Map();
+  const add = (source, folded) => {
+    const known = sources.get(folded);
+    if (known === void 0) sources.set(folded, [source]);
+    else known.push(source);
+  };
+  for (const [source, folded] of singleFoldTable()) add(source, folded);
+  foldSources = sources;
+  return sources;
+}
+function singleFoldSources(folded) {
+  return sourcesByFold().get(folded) ?? NO_SOURCES;
+}
+var PATTERN_HOST = { appendFoldedCodePoint, singleFoldSources };
+function patternIndexOf(indexes, fieldPath) {
+  let index = indexes.get(fieldPath);
+  if (index === void 0) {
+    index = requirePatternSearch(fieldPath).createIndex(PATTERN_HOST);
+    indexes.set(fieldPath, index);
+  }
+  return index;
+}
+
 // src/filters/operands/pattern.ts
 function requirePatternField(fieldPath, operator, type) {
   if (parsedTypeOf(type)?.pattern === true) return;
@@ -1552,14 +1024,16 @@ function requirePatternField(fieldPath, operator, type) {
     operator
   );
 }
+function requireTextLength(fieldPath, operator, text) {
+  if (!exceedsCodePoints(text, MAX_PATTERN_TEXT_CODE_POINTS)) return;
+  invalid(
+    `The text of "${operator}" on pattern field "${fieldPath}" holds more than ${MAX_PATTERN_TEXT_CODE_POINTS} code points`,
+    fieldPath,
+    operator
+  );
+}
 function requirePatternText(fieldPath, operator, text, caseFold) {
-  if (exceedsCodePoints(text, MAX_PATTERN_TEXT_CODE_POINTS)) {
-    invalid(
-      `The text of "${operator}" on pattern field "${fieldPath}" holds more than ${MAX_PATTERN_TEXT_CODE_POINTS} code points`,
-      fieldPath,
-      operator
-    );
-  }
+  requireTextLength(fieldPath, operator, text);
   if (caseFold && foldedCodePointCount(text) > MAX_PATTERN_POSITIONS) {
     invalid(
       `The text of "${operator}" on pattern field "${fieldPath}" has a case fold of more than ${MAX_PATTERN_POSITIONS} code points, while a pattern holds at most ${MAX_PATTERN_POSITIONS} positions`,
@@ -1569,6 +1043,23 @@ function requirePatternText(fieldPath, operator, text, caseFold) {
   }
 }
 var ELEMENT_OPERATORS2 = ["matchesAny", "containsAll"];
+function requireExpressions(fieldPath, filter, type) {
+  for (const operator of PATTERN_EXPRESSION_OPERATORS) {
+    const pattern = filter[operator];
+    if (pattern === void 0) continue;
+    if (typeof pattern !== "string")
+      invalid(`"${operator}" on field "${fieldPath}" must be a string`, fieldPath, operator);
+    requirePatternField(fieldPath, operator, type);
+    requireTextLength(fieldPath, operator, pattern);
+    requirePatternSearch(fieldPath).checkExpression(
+      operator,
+      pattern,
+      filter.caseFold === true,
+      fieldPath,
+      PATTERN_HOST
+    );
+  }
+}
 function requirePatternOperands(fieldPath, filter, type) {
   if (filter.contains !== void 0) {
     if (typeof filter.contains !== "string") {
@@ -1582,6 +1073,7 @@ function requirePatternOperands(fieldPath, filter, type) {
     }
     requirePatternField(fieldPath, "caseFold", type);
   }
+  requireExpressions(fieldPath, filter, type);
   if (parsedTypeOf(type)?.pattern !== true) return;
   const caseFold = filter.caseFold === true;
   for (const operator of PATTERN_TEST_OPERATORS) {
@@ -2064,36 +1556,120 @@ function applyPagination(results, limit, offset, binding, cursor, sort, pinnedId
   return { paginated: sliced, nextCursor };
 }
 
-// src/search/fulltext.ts
-function resolvePrefixExpansion(partition, params, language, options, queryTokens, lastToken) {
-  const term = params.term;
-  if (term === void 0) return void 0;
+// src/search/term-groups.ts
+function writtenWordsByPosition(term, language, analysis) {
   const unstemmed = tokenize(term, language, {
     stem: false,
     removeStopWords: true,
-    customTokenizer: options?.customTokenizer,
-    stopWordOverride: options?.stopWords
+    customTokenizer: analysis?.customTokenizer,
+    stopWordOverride: analysis?.stopWords
   });
-  let surfacePrefix;
-  for (const t of unstemmed.tokens) {
-    if (t.position === lastToken.position) {
-      surfacePrefix = t.token;
-      break;
+  const written = /* @__PURE__ */ new Map();
+  for (const token of unstemmed.tokens) {
+    if (!written.has(token.position)) written.set(token.position, token.token);
+  }
+  return written;
+}
+function groupFor(groups, token, typoMatches) {
+  let group = groups.get(token);
+  if (group === void 0) {
+    group = { token, members: [{ token, factor: 1, partialFactor: 1 }], typoMatches };
+    groups.set(token, group);
+  }
+  return group;
+}
+function addCompletions(groups, partition, lastToken, typedPrefix) {
+  if (typedPrefix === void 0 || typedPrefix.length === 0) return;
+  const group = groupFor(groups, lastToken.token, false);
+  const ownLength = codePointCount(lastToken.token);
+  for (const completion of partition.expandTermPrefix(typedPrefix, lastToken.token, PREFIX_MAX_EXPANSIONS)) {
+    if (completion === lastToken.token) continue;
+    const factor = Math.min(1, ownLength / codePointCount(completion));
+    group.members.push({ token: completion, factor, partialFactor: factor });
+  }
+}
+function addPartialWords(group, added) {
+  const membersByToken = /* @__PURE__ */ new Map();
+  for (const member of group.members) membersByToken.set(member.token, member);
+  for (const word of added) {
+    const member = membersByToken.get(word.token);
+    if (member === void 0) {
+      group.members.push({ token: word.token, factor: 0, partialFactor: word.factor });
+    } else if (word.factor > member.partialFactor) {
+      member.partialFactor = word.factor;
     }
   }
-  if (surfacePrefix === void 0 || surfacePrefix.length === 0) return void 0;
-  const expansions = partition.expandTermPrefix(surfacePrefix, lastToken.token, PREFIX_MAX_EXPANSIONS);
-  const terms = [];
-  for (const expanded of expansions) {
-    if (expanded !== lastToken.token) terms.push(expanded);
+}
+function partialWordAnalysisOf(fields, language, analysis) {
+  return {
+    fields,
+    language,
+    options: {
+      stopWordOverride: analysis?.stopWords,
+      customTokenizer: analysis?.customTokenizer,
+      collectSurfaces: true
+    }
+  };
+}
+function searchesAPartialField(params, partialFields) {
+  if (params.fields === void 0) return true;
+  for (const field of params.fields) {
+    if (partialFields.includes(field)) return true;
   }
-  for (const qt of queryTokens) {
-    if (qt.token === lastToken.token) {
-      return { token: qt.token, terms };
+  return false;
+}
+function partialWordRequests(params, queryTokens, written, prefixToken) {
+  const eligible = [];
+  for (const queryToken of queryTokens) {
+    const word = written.get(queryToken.position);
+    if (word === void 0 || codePointCount(word) < PARTIAL_WORD_MIN_CODE_POINTS) continue;
+    eligible.push({ token: queryToken.token, written: word });
+    if (eligible.length === PARTIAL_WORDS_ADDED_PER_QUERY) break;
+  }
+  const count = eligible.length;
+  if (count === 0) return [];
+  const evenShare = Math.floor(PARTIAL_WORDS_ADDED_PER_QUERY / count);
+  const remainder = PARTIAL_WORDS_ADDED_PER_QUERY % count;
+  return eligible.map((entry, order) => ({
+    token: entry.token,
+    request: {
+      written: entry.written,
+      ownToken: entry.token,
+      share: evenShare + (order < remainder ? 1 : 0),
+      tolerance: entry.token === prefixToken ? 0 : params.tolerance ?? 0,
+      prefixLength: params.prefixLength ?? DEFAULT_FUZZY_PREFIX_LENGTH
+    }
+  }));
+}
+function resolveTermGroups(partition, params, language, schema, queryTokens, lastToken, analysis) {
+  const term = params.term;
+  if (term === void 0 || params.exact === true) return {};
+  const usesPrefix = params.prefix === true;
+  const partialFields = params.partialWords === true ? partialFieldsOf(schema) : [];
+  const usesPartialWords = partialFields.length > 0 && searchesAPartialField(params, partialFields);
+  if (!usesPrefix && !usesPartialWords) return {};
+  const written = writtenWordsByPosition(term, language, analysis);
+  const groups = /* @__PURE__ */ new Map();
+  if (usesPrefix) addCompletions(groups, partition, lastToken, written.get(lastToken.position));
+  const prefixToken = groups.has(lastToken.token) ? lastToken.token : void 0;
+  if (usesPartialWords) {
+    const requests = partialWordRequests(params, queryTokens, written, prefixToken);
+    const added = partition.expandPartialWords(
+      partialWordAnalysisOf(partialFields, language, analysis),
+      requests.map((entry) => entry.request)
+    );
+    for (let at = 0; at < requests.length; at++) {
+      if (added[at].length === 0) continue;
+      const token = requests[at].token;
+      addPartialWords(groupFor(groups, token, token !== prefixToken), added[at]);
     }
   }
-  return void 0;
+  const termGroups = [...groups.values()];
+  if (termGroups.length === 0) return {};
+  return usesPartialWords ? { termGroups, partialFields: [...partialFields] } : { termGroups };
 }
+
+// src/search/fulltext.ts
 function prepareFulltextQuery(partition, params, language, schema, options) {
   if (!params.term || params.term.trim().length === 0) return null;
   if (params.fields && params.fields.length === 0) return null;
@@ -2109,11 +1685,6 @@ function prepareFulltextQuery(partition, params, language, schema, options) {
   });
   if (queryTokenResult.tokens.length === 0) return null;
   const queryTokens = deduplicateTokens(queryTokenResult.tokens);
-  let prefixExpansion;
-  if (params.prefix === true && params.exact !== true) {
-    const lastToken = queryTokenResult.tokens[queryTokenResult.tokens.length - 1];
-    prefixExpansion = resolvePrefixExpansion(partition, params, language, options, queryTokens, lastToken);
-  }
   let filterBitset;
   if (params.filters) {
     filterBitset = partition.applyFiltersBitset(
@@ -2123,14 +1694,17 @@ function prepareFulltextQuery(partition, params, language, schema, options) {
     );
     if (bitsetIsEmpty(filterBitset)) return null;
   }
-  return { queryTokens, prefixExpansion, filterBitset };
+  const lastToken = queryTokenResult.tokens[queryTokenResult.tokens.length - 1];
+  const groups = resolveTermGroups(partition, params, language, schema, queryTokens, lastToken, options);
+  return { queryTokens, ...groups, filterBitset };
 }
 function fulltextMatches(partition, params, language, schema, options) {
   const prepared = prepareFulltextQuery(partition, params, language, schema, options);
   if (prepared === null) return null;
   return partition.searchFulltextMatches({
     queryTokens: prepared.queryTokens,
-    prefixExpansion: prepared.prefixExpansion,
+    termGroups: prepared.termGroups,
+    partialFields: prepared.partialFields,
     fields: params.fields,
     tolerance: params.tolerance ?? 0,
     prefixLength: params.prefixLength ?? DEFAULT_FUZZY_PREFIX_LENGTH,
@@ -2143,14 +1717,15 @@ function fulltextSearch(partition, params, language, schema, options) {
   if (prepared === null) {
     return { scored: [], totalMatched: 0 };
   }
-  const { queryTokens, prefixExpansion, filterBitset } = prepared;
+  const { queryTokens, termGroups, partialFields, filterBitset } = prepared;
   const needsAllResults = params.minScore !== void 0 || params.termMatch !== void 0 && params.termMatch !== "any" || params.sort !== void 0 || params.group !== void 0 || params.pinned !== void 0 || params.searchAfter !== void 0;
   const maxResults = needsAllResults ? void 0 : clampRowCount(params.limit, DEFAULT_PAGE_SIZE) + clampRowCount(params.offset, 0) + 1;
   const collectMatchedSet = params.facets !== void 0 && !needsAllResults ? "ordinals" : void 0;
   const collectComponents = params.includeScoreComponents === true || params.termMatch !== void 0 && params.termMatch !== "any";
   const rawResult = partition.searchFulltext({
     queryTokens,
-    prefixExpansion,
+    termGroups,
+    partialFields,
     fields: params.fields,
     boost: params.boost,
     tolerance: params.tolerance ?? 0,
@@ -2174,7 +1749,8 @@ function fulltextSearch(partition, params, language, schema, options) {
       params.tolerance ?? 0,
       params.prefixLength ?? DEFAULT_FUZZY_PREFIX_LENGTH,
       params.exact ?? false,
-      prefixExpansion
+      termGroups,
+      partialFields ?? []
     );
   }
   if (params.minScore !== void 0 && params.minScore > 0) {
@@ -2216,45 +1792,48 @@ function deduplicateTokens(tokens) {
   }
   return result;
 }
-function filterByTermCoverage(scored, queryTokens, policy, tolerance, prefixLength, exact, prefixExpansion) {
+function filterByTermCoverage(scored, queryTokens, policy, tolerance, prefixLength, exact, termGroups, partialFields) {
   const requiredCount = policy === "all" ? queryTokens.length : policy;
   if (requiredCount <= 0) return scored;
   if (requiredCount > queryTokens.length) return [];
-  const expansionTerms = prefixExpansion ? new Set(prefixExpansion.terms) : void 0;
+  const groups = /* @__PURE__ */ new Map();
+  for (const group of termGroups ?? []) {
+    const partialOnly = /* @__PURE__ */ new Set();
+    for (const member of group.members) {
+      if (member.factor === 0) partialOnly.add(member.token);
+    }
+    groups.set(group.token, {
+      members: new Set(group.members.map((member) => member.token)),
+      partialOnly,
+      typoMatches: group.typoMatches
+    });
+  }
   return scored.filter((doc) => {
-    const matched = countDocTermMatches(
-      doc,
-      queryTokens,
-      tolerance,
-      prefixLength,
-      exact,
-      prefixExpansion?.token,
-      expansionTerms
-    );
+    const matched = countDocTermMatches(doc, queryTokens, tolerance, prefixLength, exact, groups, partialFields);
     return matched >= requiredCount;
   });
 }
-function countDocTermMatches(doc, queryTokens, tolerance, prefixLength, exact, prefixToken, expansionTerms) {
+function countDocTermMatches(doc, queryTokens, tolerance, prefixLength, exact, groups, partialFields) {
   const indexTokens = Object.keys(doc.idf);
   if (indexTokens.length === 0) return 0;
   let count = 0;
   for (const qt of queryTokens) {
-    if (prefixToken !== void 0 && qt.token === prefixToken) {
-      if (prefixTokenSatisfied(qt.token, indexTokens, expansionTerms)) {
-        count++;
-      }
-      continue;
-    }
-    if (queryTermSatisfied(qt.token, indexTokens, tolerance, prefixLength, exact)) {
-      count++;
-    }
+    const group = groups.get(qt.token);
+    const satisfied = group === void 0 ? queryTermSatisfied(qt.token, indexTokens, tolerance, prefixLength, exact) : groupSatisfied(group, doc, indexTokens, partialFields) || group.typoMatches && queryTermSatisfied(qt.token, indexTokens, tolerance, prefixLength, exact);
+    if (satisfied) count++;
   }
   return count;
 }
-function prefixTokenSatisfied(prefixToken, indexTokens, expansionTerms) {
+function matchedInPartialField(doc, token, partialFields) {
+  for (const field of partialFields) {
+    if (doc.termFrequencies[`${field}:${token}`] !== void 0) return true;
+  }
+  return false;
+}
+function groupSatisfied(group, doc, indexTokens, partialFields) {
   for (const indexToken of indexTokens) {
-    if (indexToken === prefixToken) return true;
-    if (expansionTerms?.has(indexToken)) return true;
+    if (!group.members.has(indexToken)) continue;
+    if (!group.partialOnly.has(indexToken) || matchedInPartialField(doc, indexToken, partialFields)) return true;
   }
   return false;
 }
@@ -2578,4 +2157,4 @@ function setNestedValue(obj, path, value) {
   current[segments[segments.length - 1]] = value;
 }
 
-export { GEO_UNIT_METRES, MAX_FILTER_ARRAY_SIZE, MAX_FILTER_DEPTH, MAX_FILTER_TESTS, applyPagination, applyProjection, applySorting, boundedLevenshtein, clampRowCount, clearNormalizationCache, cloneProjected, collectQueryTermStats, computeFacets, configureNormalizationCache, countsWithoutScores, coveringRanges, createPatternWorkMeter, decodePageCursor, encodePageCursor, everyValueFacetConfig, fanOutMatchCount, fanOutQuery, filterTestCount, fnv1a, fnv1aBytes, fnv1aUint32s, fulltextMatches, fuzzyPrefixOf, fuzzyTermMatches, getFieldValueByInternalId, getFlatSchema, getNestedValue, getNormalizationCacheSize, getOrCreateFieldNameIndex, joinPatternWorkMeter, kWayMerge, locationCode, mergeFacets, mergePartitionStats, normalizeSort, oversampledFacetConfig, oversampledShardSize, parseVectorDimension, partitionsIn, polygonBoxes, polygonContainment, projectionKeepsField, pruneStatsToQueryTerms, radiusBoxes, readSortValues, requireMatchingCursor, requireSortableFields, requireValidFilter, requireValidOperands, requireWithinResultWindow, resetNormalizationCache, resolveProjection, sanitizeGlobalStats, setNestedValue, sortModesOf, sortSignatureEntry, sortSignatureOf, textFieldsChanged, tokenize, tokenizeIterator, tokenizeOptions, undeclaredFieldOnStrictIndex, undeclaredFilterField, visitTokens };
+export { PATTERN_HOST, applyPagination, applyProjection, applySorting, availablePatternSearch, clampRowCount, cloneProjected, collectQueryTermStats, computeFacets, countsWithoutScores, coveringRanges, createPatternWorkMeter, decodePageCursor, encodePageCursor, everyValueFacetConfig, fanOutMatchCount, fanOutQuery, filterTestCount, fnv1a, fnv1aBytes, fnv1aUint32s, fulltextMatches, joinPatternWorkMeter, kWayMerge, locationCode, mergeFacets, mergePartitionStats, normalizeSort, oversampledFacetConfig, oversampledShardSize, partitionsIn, patternIndexOf, polygonBoxes, polygonContainment, projectionKeepsField, pruneStatsToQueryTerms, radiusBoxes, readSortValues, registerPatternSearch, requireMatchingCursor, requirePatternSearch, requirePatternSearchFor, requireSortableFields, requireValidFilter, requireValidOperands, requireWithinResultWindow, resolveProjection, sanitizeGlobalStats, setNestedValue, sortModesOf, sortSignatureEntry, sortSignatureOf, undeclaredFieldOnStrictIndex, undeclaredFilterField };