@delali/narsil 0.3.1-next.74 → 0.3.1-next.76

package/dist/{chunk-PO53FV4Q.mjs → chunk-AMGDG4ZJ.mjs}

@@ -1,7 +1,7 @@
 import { OSQ_STEPS, OSQ_GRID, OSQ_REFINE_ROUNDS, OSQ_REFINE_TOLERANCE, OSQ4_NARROW_DIMENSION_LIMIT, DEFAULT_OSQ4_NARROW_OVERSAMPLE, DEFAULT_OVERSAMPLE_BY_BITS, OSQ_QUERY_BITS, OSQ_LAMBDA } from './chunk-ZJ4CSAB2.mjs';
 import { nativeSearchCoreIsEnabled, loadNativeCore, stopUsingTheNativeSearchCore, noteFallback } from './chunk-2E35UM3G.mjs';
 import { COMPACTION_TOMBSTONE_RATIO, COMPACTION_ABSOLUTE_THRESHOLD, MAX_LAYER_CAP, PLACEMENT_ROOM_REQUESTS, INITIAL_LIST_CAPACITY, DEFAULT_EF_SEARCH, INITIAL_UPPER_SLOTS } from './chunk-KEHK2O6P.mjs';
-import { compareCodePoints } from './chunk-LJYTW7GT.mjs';
+import { compareCodePoints } from './chunk-IBR6634K.mjs';
 import { NarsilError, ErrorCodes } from './chunk-I64LXKO3.mjs';
 import { readSync, closeSync, openSync } from 'fs';
 

package/dist/{chunk-LX4JERXI.mjs → chunk-BT62MUM5.mjs}

@@ -1,4 +1,4 @@
-import { requireDocumentWithinSizeLimit, validateRequiredFields } from './chunk-Z3DQPOJQ.mjs';
+import { requireDocumentWithinSizeLimit, validateRequiredFields } from './chunk-356UOTK2.mjs';
 import { ErrorCodes, NarsilError } from './chunk-I64LXKO3.mjs';
 
 // src/narsil/internals.ts

package/dist/{chunk-NOZUQM7J.mjs → chunk-BT6BI4GV.mjs}

@@ -1,4 +1,4 @@
-import { MAX_SORT_FIELDS } from './chunk-3DDUNI6N.mjs';
+import { MAX_FILTER_DEPTH, MAX_SORT_FIELDS } from './chunk-V3B24XR7.mjs';
 import { nativeSearchCoreIsEnabled, loadNativeCore } from './chunk-2E35UM3G.mjs';
 import { NarsilError, ServerErrorCodes, ErrorCodes } from './chunk-I64LXKO3.mjs';
 import { mkdtemp, open, rm } from 'fs/promises';
@@ -423,6 +423,43 @@ function serializeBatchResult(result) {
   };
 }
 
+// src/server/regex-policy.ts
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function regexFieldIn(expression, depth) {
+  if (!isRecord(expression) || depth > MAX_FILTER_DEPTH) return null;
+  if (isRecord(expression.fields)) {
+    for (const [fieldPath, filter] of Object.entries(expression.fields)) {
+      if (isRecord(filter) && Object.hasOwn(filter, "regex")) return fieldPath;
+    }
+  }
+  for (const nested of [expression.and, expression.or]) {
+    if (!Array.isArray(nested)) continue;
+    for (const child of nested) {
+      const found = regexFieldIn(child, depth + 1);
+      if (found !== null) return found;
+    }
+  }
+  return regexFieldIn(expression.not, depth + 1);
+}
+function refusedRegex(filters, allowRegex) {
+  if (allowRegex) return null;
+  const fieldPath = regexFieldIn(filters, 0);
+  if (fieldPath === null) return null;
+  return new NarsilError(
+    ErrorCodes.SEARCH_INVALID_FILTER,
+    `This server refuses every "regex" test, because its operator set the allowRegex server option to false. Test field "${fieldPath}" with "contains" or "wildcard"`,
+    { fieldPath, operator: "regex", option: "allowRegex" }
+  );
+}
+function refuseRegex(ctx, filters, allowRegex) {
+  const refused = refusedRegex(filters, allowRegex);
+  if (refused === null) return false;
+  respondError(ctx, refused);
+  return true;
+}
+
 // src/server/validation.ts
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -616,7 +653,7 @@ function parseTaskListQuery(params, maxPageSize) {
 
 // src/server/handlers/document-reads.ts
 function createDocumentReadHandlers(deps) {
-  const { engine, limits } = deps;
+  const { engine, limits, allowRegex } = deps;
   async function get(ctx) {
     try {
       const document = await engine.get(ctx.params[0], ctx.params[1]);
@@ -668,6 +705,7 @@ function createDocumentReadHandlers(deps) {
       rejectInvalid(ctx, failure);
       return;
     }
+    if (refuseRegex(ctx, params.filters, allowRegex)) return;
     try {
       respondJson(ctx, await engine.listDocuments(ctx.params[0], params));
     } catch (err) {
@@ -1155,4 +1193,4 @@ function childAppOf(app) {
   return candidate;
 }
 
-export { ASYNC_IMPORT_CAPABILITY, DEFAULT_IMPORT_BATCH_SIZE, DEFAULT_MAX_BODY_BYTES, DEFAULT_MAX_CONCURRENT_REQUESTS, DEFAULT_MAX_CONCURRENT_TASKS, DEFAULT_MAX_FETCH_DOCUMENTS, DEFAULT_MAX_IMPORT_BYTES, DEFAULT_MAX_IMPORT_ERRORS, DEFAULT_MAX_LINE_BYTES, DEFAULT_MAX_RESTORE_BYTES, DEFAULT_MAX_RESULT_WINDOW, DEFAULT_MAX_RETAINED_TASKS, DEFAULT_MAX_TASK_PAGE_SIZE, DEFAULT_TASK_PAGE_SIZE, DOCUMENT_EXPORT_CAPABILITY, DOCUMENT_EXPORT_CONTENT_TYPE, IMPORT_FLUSHES_IN_FLIGHT, INDEX_LIFECYCLE_CAPABILITY, INDEX_TOUCH_INTERVALS_PER_IDLE_TIMEOUT, MAIN_THREAD_GATE_SLOT, MAX_INDEX_TOUCH_INTERVAL_MS, MIN_COUNTED_SERVER_LIMIT, MIN_UNBOUNDED_SERVER_LIMIT, REBUILD_ANALYSIS_CAPABILITY, RELAY_STREAM_CHUNKS_IN_FLIGHT, RUNNING_TASK_TTL_MS, SERVER_CAPABILITIES, SNAPSHOT_ARCHIVE_CONTENT_TYPE, TASK_CANCEL_CAPABILITY, TASK_FILTER_CAPABILITY, TASK_PROGRESS_WRITE_INTERVAL_MS, TERMINAL_TASK_TTL_MS, acceptorOf, authorizerFor, badRequest, childAppOf, clearGateSlot, corsHeaderReader, createDocumentReadHandlers, createRouteRunner, createSharedGateBuffer, createSharedRequestGate, createVersionHandler, gateSlotOfWorker, httpStatusForNarsilError, loadUWebSockets, parseJson, parseJsonOptional, parseTaskListQuery, registerServerRoutes, rejectInvalid, resolveCors, respondError, respondJson, sendError, sendRelayed, sendStream, serializeBatchResult, serializeNarsilError, serverRoutes, statusLine, toHttpError, validateBatch, validateCreateIndex, validateDocumentBody, validateQuery, validateRebalance, validateSuggest, versionReport };
+export { ASYNC_IMPORT_CAPABILITY, DEFAULT_IMPORT_BATCH_SIZE, DEFAULT_MAX_BODY_BYTES, DEFAULT_MAX_CONCURRENT_REQUESTS, DEFAULT_MAX_CONCURRENT_TASKS, DEFAULT_MAX_FETCH_DOCUMENTS, DEFAULT_MAX_IMPORT_BYTES, DEFAULT_MAX_IMPORT_ERRORS, DEFAULT_MAX_LINE_BYTES, DEFAULT_MAX_RESTORE_BYTES, DEFAULT_MAX_RESULT_WINDOW, DEFAULT_MAX_RETAINED_TASKS, DEFAULT_MAX_TASK_PAGE_SIZE, DEFAULT_TASK_PAGE_SIZE, DOCUMENT_EXPORT_CAPABILITY, DOCUMENT_EXPORT_CONTENT_TYPE, IMPORT_FLUSHES_IN_FLIGHT, INDEX_LIFECYCLE_CAPABILITY, INDEX_TOUCH_INTERVALS_PER_IDLE_TIMEOUT, MAIN_THREAD_GATE_SLOT, MAX_INDEX_TOUCH_INTERVAL_MS, MIN_COUNTED_SERVER_LIMIT, MIN_UNBOUNDED_SERVER_LIMIT, REBUILD_ANALYSIS_CAPABILITY, RELAY_STREAM_CHUNKS_IN_FLIGHT, RUNNING_TASK_TTL_MS, SERVER_CAPABILITIES, SNAPSHOT_ARCHIVE_CONTENT_TYPE, TASK_CANCEL_CAPABILITY, TASK_FILTER_CAPABILITY, TASK_PROGRESS_WRITE_INTERVAL_MS, TERMINAL_TASK_TTL_MS, acceptorOf, authorizerFor, badRequest, childAppOf, clearGateSlot, corsHeaderReader, createDocumentReadHandlers, createRouteRunner, createSharedGateBuffer, createSharedRequestGate, createVersionHandler, gateSlotOfWorker, httpStatusForNarsilError, loadUWebSockets, parseJson, parseJsonOptional, parseTaskListQuery, refuseRegex, registerServerRoutes, rejectInvalid, resolveCors, respondError, respondJson, sendError, sendRelayed, sendStream, serializeBatchResult, serializeNarsilError, serverRoutes, statusLine, toHttpError, validateBatch, validateCreateIndex, validateDocumentBody, validateQuery, validateRebalance, validateSuggest, versionReport };

package/dist/{chunk-VKX2BPXD.mjs → chunk-D4EF7J3I.mjs}

@@ -1,10 +1,48 @@
-import { MAX_SORT_FIELDS, MAX_SORT_FIELD_NAME_LENGTH, MAX_CURSOR_LENGTH, MAX_CURSOR_ANCHOR_CODE_POINTS, RESULT_WINDOW, DEFAULT_FUZZY_PREFIX_LENGTH, DEFAULT_PAGE_SIZE, PREFIX_MAX_EXPANSIONS, PARTIAL_WORD_MIN_CODE_POINTS, PARTIAL_WORDS_ADDED_PER_QUERY } from './chunk-3DDUNI6N.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 { getFlatSchema, tokenize, getFieldValueByInternalId, getFieldValueForDoc, fuzzyTermMatches } from './chunk-I23G3IZC.mjs';
-import { 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-Z3DQPOJQ.mjs';
-import { compareCodePoints, sortModeOf, defaultSortMode, SORT_VALUE_MAX_CODE_POINTS, toReducedSortValue, readSortField, compareComparableKeys, toComparableSortValue, exceedsCodePoints, holdsUnpairedSurrogate, isSortMode, SORT_MODES, compareSortValues, foldedCodePointCount, codePointCount } from './chunk-LJYTW7GT.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, isPatternTolerance, foldTypoText, typoRunsNeeded, distinctTypoRunCount, createBitSet, bitsetSet, MAX_PATTERN_TEXT_CODE_POINTS, PATTERN_WORK_FLUSH_UNITS, MATCHER_STATE_BUDGET_BYTES } from './chunk-4344I4MR.mjs';
+import { getFlatSchema, tokenize, getFieldValueByInternalId, getFieldValueForDoc } from './chunk-NO3ABFLE.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 { fuzzyTermMatches } from './chunk-GES7U2PM.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/pattern-index/platform.ts
+function platformPatternSearch() {
+  return patternSearchModule;
+}
+
+// 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 registerPatternSearch(module) {
+  if (!isPatternSearchModule(module)) {
+    throw new NarsilError(
+      ErrorCodes.CONFIG_INVALID,
+      'registerPatternSearch takes the patternSearch object that "@delali/narsil/pattern" exports'
+    );
+  }
+  registered = module;
+}
+function availablePatternSearch() {
+  return registered ?? platformPatternSearch();
+}
+function requirePatternSearchFor(schema) {
+  for (const { path, pattern } of schemaFieldsOf(schema)) {
+    if (pattern) requirePatternSearch(path);
+  }
+}
+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
 var COUNTER_BYTES = 8;
 function capExceeded(cap) {
@@ -529,12 +567,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;
@@ -955,6 +987,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;
@@ -965,14 +1025,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`,
@@ -982,6 +1044,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") {
@@ -995,6 +1074,8 @@ function requirePatternOperands(fieldPath, filter, type) {
     }
     requirePatternField(fieldPath, "caseFold", type);
   }
+  requireExpressions(fieldPath, filter, type);
+  if (filter.tolerance !== void 0) requirePatternField(fieldPath, "tolerance", type);
   if (parsedTypeOf(type)?.pattern !== true) return;
   const caseFold = filter.caseFold === true;
   for (const operator of PATTERN_TEST_OPERATORS) {
@@ -1012,6 +1093,31 @@ function requirePatternOperands(fieldPath, filter, type) {
       if (typeof text === "string") requirePatternText(fieldPath, operator, text, false);
     }
   }
+  requireTolerance(fieldPath, filter);
+}
+function requireTolerance(fieldPath, filter) {
+  const { tolerance, eq } = filter;
+  if (tolerance === void 0) return;
+  if (!isPatternTolerance(tolerance)) {
+    invalid(`"tolerance" on field "${fieldPath}" must be 0, 1, 2, or "auto"`, fieldPath, "tolerance");
+  }
+  if (typeof eq !== "string") {
+    invalid(
+      `"tolerance" applies only to an "eq" test, while the filter on field "${fieldPath}" sets no "eq" with text`,
+      fieldPath,
+      "tolerance"
+    );
+  }
+  if (tolerance === 0 || tolerance === "auto") return;
+  const text = foldTypoText(eq, PATTERN_HOST);
+  const requiredRuns = typoRunsNeeded(tolerance, text.longestFold);
+  const distinctRuns = distinctTypoRunCount(text, requiredRuns);
+  if (distinctRuns >= requiredRuns) return;
+  throw new NarsilError(
+    ErrorCodes.SEARCH_INVALID_FILTER,
+    `A tolerance of ${tolerance} on "eq" of pattern field "${fieldPath}" needs ${requiredRuns} distinct runs of three code points in the case fold of the text, while the text holds ${distinctRuns}. Lengthen the text, lower the tolerance, or set it to "auto"`,
+    { fieldPath, operator: "tolerance", requiredRuns, distinctRuns }
+  );
 }
 function requireWellFormedText(fieldPath, filter) {
   for (const [operator, operand] of Object.entries(filter)) {
@@ -1033,6 +1139,7 @@ var TEXT_OPERATORS = ["startsWith", "endsWith"];
 var EQUALITY_OPERATORS = ["eq", "ne"];
 var LIST_OPERATORS = ["in", "nin"];
 var GEO_OPERATORS = ["radius", "polygon"];
+var TEST_MODIFIERS = /* @__PURE__ */ new Set(["caseFold", "tolerance"]);
 function invalidShape(message) {
   throw new NarsilError(ErrorCodes.SEARCH_INVALID_FILTER, message);
 }
@@ -1136,7 +1243,7 @@ function filterTestCount(expression) {
 function testsIn(filter) {
   let tests = 0;
   for (const [operator, operand] of Object.entries(filter)) {
-    if (operator === "caseFold") continue;
+    if (TEST_MODIFIERS.has(operator)) continue;
     tests += operator === "size" && isObjectRecord(operand) ? Math.max(1, Object.keys(operand).length) : 1;
   }
   return Math.max(1, tests);
@@ -2078,4 +2185,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, 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, polygonBoxes, polygonContainment, projectionKeepsField, pruneStatsToQueryTerms, radiusBoxes, readSortValues, requireMatchingCursor, requireSortableFields, requireValidFilter, requireValidOperands, requireWithinResultWindow, resolveProjection, sanitizeGlobalStats, setNestedValue, sortModesOf, sortSignatureEntry, sortSignatureOf, undeclaredFieldOnStrictIndex, undeclaredFilterField };
+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 };

package/dist/{chunk-BVBIQQKG.mjs → chunk-DFFQOA7S.mjs}

@@ -1,15 +1,15 @@
-import { joinPatternWorkMeter, countsWithoutScores, fanOutMatchCount, fanOutQuery, sanitizeGlobalStats, computeFacets, cloneProjected, projectionKeepsField, setNestedValue, fnv1a, everyValueFacetConfig, mergeFacets, undeclaredFilterField, requireValidOperands, kWayMerge, polygonContainment, polygonBoxes, radiusBoxes, locationCode, coveringRanges, GEO_UNIT_METRES } from './chunk-VKX2BPXD.mjs';
+import { requirePatternSearchFor, patternIndexOf, joinPatternWorkMeter, countsWithoutScores, fanOutMatchCount, fanOutQuery, sanitizeGlobalStats, computeFacets, cloneProjected, projectionKeepsField, setNestedValue, fnv1a, requirePatternSearch, PATTERN_HOST, everyValueFacetConfig, mergeFacets, undeclaredFilterField, requireValidOperands, kWayMerge, polygonContainment, polygonBoxes, radiusBoxes, locationCode, coveringRanges } from './chunk-D4EF7J3I.mjs';
 import { getLanguage, detectRuntime } from './chunk-4MQ5F4IL.mjs';
-import { MAX_DOC_ID_LENGTH } from './chunk-3DDUNI6N.mjs';
-import { SCRATCH_SLOTS_PER_THREAD_POOL, osqRecordBytes, openSharedVectorField, osqBitsOf, createVectorStore, DISK_STORAGE_BLOCK_BYTES, createOsqQuantizer, magnitude, createHNSWIndex, nativeStoreScratchBytes, createOrdinalFilter, isTombstoned, addToOrdinalFilter, ordinalFilterValues, nativeScoresOf, toScore, removeFromOrdinalFilter, euclideanDistance, dotProduct, cosineSimilarityWithMagnitudes, ordinalFilterHas, STORE_CALIBRATION_GENERATION, entryForOrd, toDistance, sharedMemoryAvailable, requireWholeNeighbourLists, topLayerInParts, GRAPH_BUILD_CHUNKS_IN_FLIGHT_PER_WORKER, GRAPH_BUILD_DISPATCH_CHUNK, releaseLocksHeldBy, VECTOR_SEARCH_TIMEOUT_MS, VECTOR_SEARCH_LOAD_TIMEOUT_MS, VECTOR_INSERT_TIMEOUT_MS, VECTOR_SCRATCH_SLOTS } from './chunk-PO53FV4Q.mjs';
+import { MAX_DOC_ID_LENGTH, GEO_UNIT_METRES } from './chunk-V3B24XR7.mjs';
+import { SCRATCH_SLOTS_PER_THREAD_POOL, osqRecordBytes, openSharedVectorField, osqBitsOf, createVectorStore, DISK_STORAGE_BLOCK_BYTES, createOsqQuantizer, magnitude, createHNSWIndex, nativeStoreScratchBytes, createOrdinalFilter, isTombstoned, addToOrdinalFilter, ordinalFilterValues, nativeScoresOf, toScore, removeFromOrdinalFilter, euclideanDistance, dotProduct, cosineSimilarityWithMagnitudes, ordinalFilterHas, STORE_CALIBRATION_GENERATION, entryForOrd, toDistance, sharedMemoryAvailable, requireWholeNeighbourLists, topLayerInParts, GRAPH_BUILD_CHUNKS_IN_FLIGHT_PER_WORKER, GRAPH_BUILD_DISPATCH_CHUNK, releaseLocksHeldBy, VECTOR_SEARCH_TIMEOUT_MS, VECTOR_SEARCH_LOAD_TIMEOUT_MS, VECTOR_INSERT_TIMEOUT_MS, VECTOR_SCRATCH_SLOTS } from './chunk-AMGDG4ZJ.mjs';
 import { noteFallback } from './chunk-2E35UM3G.mjs';
-import { GrowableUint32, patternSearchModule } from './chunk-XW25X6AU.mjs';
-import { bitsetHas, createBitSet, bitsetSet, bitsetOrInto, bitsetAndNotInto, bitsetAndInto, PATTERN_RUN_CODE_POINTS, bitsetFromSet, bitsetIsEmpty, bitsetAnd, bitsetNot } from './chunk-ZKRV5M2P.mjs';
-import { encodePartialSpellings, countSpelling, expandTermPrefix, suggestDisplayTerms, spellingCountsOf, codePointOrder, encodeStringBlob, partialWordSearchModule, partitionDocumentFrequency } from './chunk-T5ZWEWVD.mjs';
-import { tokenizeOptions, getNestedValue, visitTokens, textFieldsChanged, fuzzyPrefixOf, boundedLevenshtein, getFlatSchema, tokenize, getOrCreateFieldNameIndex, tokenizeIterator, getFieldValueByInternalId } from './chunk-I23G3IZC.mjs';
-import { schemaFieldsOf, partialFieldsOf, isWordIndexedBase, validateDocument, validateDocumentStrict, encodeDocument, extractVectorFieldsFromSchema, parsedTypeOf, isListBase, VINCENTY_CONVERGENCE_THRESHOLD, EARTH_RADIUS_METERS, VINCENTY_MAX_ITERATIONS, DEG_TO_RAD } from './chunk-Z3DQPOJQ.mjs';
+import { GrowableUint32, bitsetHas, createBitSet, bitsetSet, bitsetOrInto, bitsetAndNotInto, bitsetAndInto, PATTERN_RUN_CODE_POINTS, bitsetFromSet, isPatternTolerance, bitsetIsEmpty, bitsetAnd, bitsetNot } from './chunk-4344I4MR.mjs';
+import { encodePartialSpellings, countSpelling, expandTermPrefix, suggestDisplayTerms, spellingCountsOf, codePointOrder, encodeStringBlob, partialWordSearchModule, partitionDocumentFrequency } from './chunk-PJU6EF22.mjs';
+import { tokenizeOptions, getNestedValue, visitTokens, textFieldsChanged, getFlatSchema, tokenize, getOrCreateFieldNameIndex, tokenizeIterator, getFieldValueByInternalId } from './chunk-NO3ABFLE.mjs';
+import { partialFieldsOf, schemaFieldsOf, isWordIndexedBase, validateDocument, validateDocumentStrict, encodeDocument, extractVectorFieldsFromSchema, parsedTypeOf, isListBase, VINCENTY_CONVERGENCE_THRESHOLD, EARTH_RADIUS_METERS, VINCENTY_MAX_ITERATIONS, DEG_TO_RAD } from './chunk-356UOTK2.mjs';
 import { MAX_M, EARLIER_RELEASE_MIN_M, MIN_M } from './chunk-KEHK2O6P.mjs';
-import { compareCodePoints, appendFoldedCodePoint, toReducedSortValue, readSortField, defaultSortMode, compareComparableValues, truncateSortString, SORT_VALUE_MAX_CODE_POINTS } from './chunk-LJYTW7GT.mjs';
+import { fuzzyPrefixOf, boundedLevenshtein } from './chunk-GES7U2PM.mjs';
+import { compareCodePoints, toReducedSortValue, readSortField, defaultSortMode, compareComparableValues, truncateSortString, SORT_VALUE_MAX_CODE_POINTS } from './chunk-IBR6634K.mjs';
 import { NarsilError, ErrorCodes } from './chunk-I64LXKO3.mjs';
 import { totalmem } from 'os';
 import { getHeapStatistics } from 'v8';
@@ -944,54 +944,6 @@ function createSurfaceRegistry() {
   };
 }
 
-// src/core/pattern-index/platform.ts
-function platformPatternSearch() {
-  return patternSearchModule;
-}
-
-// 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";
-}
-function registerPatternSearch(module) {
-  if (!isPatternSearchModule(module)) {
-    throw new NarsilError(
-      ErrorCodes.CONFIG_INVALID,
-      'registerPatternSearch takes the patternSearch object that "@delali/narsil/pattern" exports'
-    );
-  }
-  registered = module;
-}
-function availablePatternSearch() {
-  return registered ?? platformPatternSearch();
-}
-function requirePatternSearchFor(schema) {
-  for (const { path, pattern } of schemaFieldsOf(schema)) {
-    if (pattern) requirePatternSearch(path);
-  }
-}
-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/host.ts
-var PATTERN_HOST = { appendFoldedCodePoint };
-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/geo/haversine.ts
 function haversineDistance(lat1, lon1, lat2, lon2) {
   const phi1 = lat1 * DEG_TO_RAD;
@@ -2023,18 +1975,21 @@ function textsOf(operand) {
 }
 function evaluatePatternTests(fieldPath, filter, context, bitsets) {
   const caseFold = filter.caseFold === true;
-  const matching = (operator, texts) => {
+  const matching = (operator, texts, tolerance = 0) => {
     const into = createBitSet(context.capacity);
-    for (const text of texts) context.matchPattern(fieldPath, operator, text, caseFold, into);
+    for (const text of texts) context.matchPattern(fieldPath, operator, text, caseFold, tolerance, into);
     return into;
   };
-  if (typeof filter.eq === "string") bitsets.push(matching("eq", [filter.eq]));
+  const eqTolerance = isPatternTolerance(filter.tolerance) ? filter.tolerance : 0;
+  if (typeof filter.eq === "string") bitsets.push(matching("eq", [filter.eq], eqTolerance));
   if (typeof filter.ne === "string") bitsets.push(excluding(context, fieldPath, matching("eq", [filter.ne])));
   if (filter.in !== void 0) bitsets.push(matching("eq", textsOf(filter.in)));
   if (filter.nin !== void 0) bitsets.push(excluding(context, fieldPath, matching("eq", textsOf(filter.nin))));
   if (typeof filter.startsWith === "string") bitsets.push(matching("startsWith", [filter.startsWith]));
   if (typeof filter.endsWith === "string") bitsets.push(matching("endsWith", [filter.endsWith]));
   if (typeof filter.contains === "string") bitsets.push(matching("contains", [filter.contains]));
+  if (typeof filter.wildcard === "string") bitsets.push(matching("wildcard", [filter.wildcard]));
+  if (typeof filter.regex === "string") bitsets.push(matching("regex", [filter.regex]));
 }
 
 // src/filters/field-tests.ts
@@ -2082,7 +2037,7 @@ function elementBits(context, fieldPath, parsed, value) {
   const { capacity } = context;
   if (parsed.pattern) {
     const matches = createBitSet(capacity);
-    context.matchPattern(fieldPath, "eq", value, false, matches);
+    context.matchPattern(fieldPath, "eq", value, false, 0, matches);
     return matches;
   }
   if (typeof value === "number")
@@ -2095,7 +2050,7 @@ function anyElementBits(context, fieldPath, parsed, values) {
   const { capacity } = context;
   const union = createBitSet(capacity);
   if (parsed.pattern) {
-    for (const value of values) context.matchPattern(fieldPath, "eq", value, false, union);
+    for (const value of values) context.matchPattern(fieldPath, "eq", value, false, 0, union);
     return union;
   }
   if (parsed.base === "enum[]") {
@@ -2239,7 +2194,10 @@ var FIELD_FILTER_OPERATORS = [
   "startsWith",
   "endsWith",
   "contains",
+  "wildcard",
+  "regex",
   "caseFold",
+  "tolerance",
   "containsAll",
   "matchesAny",
   "size",
@@ -2973,13 +2931,14 @@ function buildFilterContext(state, schema, meter) {
     sizeIndex: (fieldPath) => state.sizeIndexes.get(fieldPath),
     textRangeBitset: (fieldPath, bounds) => textRangeBitsetOf(state, fieldPath, flat[fieldPath], bounds, capacity),
     isPatternField: (fieldPath) => patternFields.has(fieldPath),
-    matchPattern: (fieldPath, operator, text, caseFold, into) => {
+    matchPattern: (fieldPath, operator, text, caseFold, tolerance, into) => {
       const index = state.patternIndexes.get(fieldPath);
       if (index === void 0) return;
       requirePatternSearch(fieldPath).matchInto({
         operator,
         text,
         caseFold,
+        tolerance,
         index,
         matches: into,
         meter,
@@ -3525,7 +3484,7 @@ function platformPartialWordSearch() {
 }
 
 // src/core/partition/partial-words/registry.ts
-var registered2 = null;
+var registered = null;
 function isPartialWordSearchModule(value) {
   return value !== null && typeof value === "object" && value.name === "partialWords" && "createGrowingSlot" in value && typeof value.createGrowingSlot === "function" && "createFrozenSlot" in value && typeof value.createFrozenSlot === "function" && "buildTable" in value && typeof value.buildTable === "function" && "expand" in value && typeof value.expand === "function";
 }
@@ -3536,10 +3495,10 @@ function registerPartialWordSearch(module) {
       'Pass registerPartialWordSearch the partialWordSearch object that "@delali/narsil/partial-words" exports'
     );
   }
-  registered2 = module;
+  registered = module;
 }
 function availablePartialWordSearch() {
-  return registered2 ?? platformPartialWordSearch();
+  return registered ?? platformPartialWordSearch();
 }
 function requirePartialWordSearchFor(schema) {
   const fields = partialFieldsOf(schema);
@@ -11179,4 +11138,4 @@ function createDirectExecutor(options) {
   };
 }
 
-export { CHECKSUM_YIELD_CHUNK_BYTES, CONSECUTIVE_TIMEOUTS_BEFORE_DEATH, DEFAULT_BACKPRESSURE_LIMIT, DEFAULT_REQUEST_TIMEOUT_MS, FIELD_FILTER_OPERATORS, FILTER_EXPRESSION_KEYS, MAX_FILE_BYTES, NATIVE_CRC32_MIN_BYTES, NO_LIVE_VECTOR_AT_POSITION, SHUTDOWN_TIMEOUT_MS, VALID_HNSW_METRICS, VECTOR_FILE_MAX_VECTORS, VECTOR_FILE_PAYLOAD_VERSION, assembleGraphParts, buildSegmentPayload, bytesToVectors, countDead, createDirectExecutor, createFrozenSegment, createPartitionIndex, createPartitionManager, createPartitionRouter, createSharedFrozenSegment, deadBitsWhere, deadBytesFor, decodeEveryStoredDocument, decodeMapWithoutFields, decodeStoredDocument, decodeVectorFilePayload, decodeVectorGraphPartPayload, decodeVectorGraphPayload, decodeVectorIndexParts, encodeSegmentState, freezeSegmentShared, generateId, getStopWords, getTokenizer, graphPartsOfEarlierPayload, hasStopWords, hasTokenizer, isCompositePartition, isDead, mergeFrozenSegments, mergeSegmentContents, missingWorkerEntry, nodeThreadId, partitionStateOf, readHeapStatistics, registerPartialWordSearch, registerPatternSearch, registerStopWords, registerTokenizer, requirePartialWordSearchFor, requirePatternSearchFor, resolveIndexAnalysis, resolvePartitionInsertOptions, resolveRequestThreadCount, resolveWorkerCount, resolveWorkerEntry, segmentArraysOf, selectionKeeps, shareSegmentArrays, spawnNodeWorker, splitWorkerBudget, survivorDocumentsOf, vectorsPerFile, vectorsToBytes, workerResourceLimits };
+export { CHECKSUM_YIELD_CHUNK_BYTES, CONSECUTIVE_TIMEOUTS_BEFORE_DEATH, DEFAULT_BACKPRESSURE_LIMIT, DEFAULT_REQUEST_TIMEOUT_MS, FIELD_FILTER_OPERATORS, FILTER_EXPRESSION_KEYS, MAX_FILE_BYTES, NATIVE_CRC32_MIN_BYTES, NO_LIVE_VECTOR_AT_POSITION, SHUTDOWN_TIMEOUT_MS, VALID_HNSW_METRICS, VECTOR_FILE_MAX_VECTORS, VECTOR_FILE_PAYLOAD_VERSION, assembleGraphParts, buildSegmentPayload, bytesToVectors, countDead, createDirectExecutor, createFrozenSegment, createPartitionIndex, createPartitionManager, createPartitionRouter, createSharedFrozenSegment, deadBitsWhere, deadBytesFor, decodeEveryStoredDocument, decodeMapWithoutFields, decodeStoredDocument, decodeVectorFilePayload, decodeVectorGraphPartPayload, decodeVectorGraphPayload, decodeVectorIndexParts, encodeSegmentState, freezeSegmentShared, generateId, getStopWords, getTokenizer, graphPartsOfEarlierPayload, hasStopWords, hasTokenizer, isCompositePartition, isDead, mergeFrozenSegments, mergeSegmentContents, missingWorkerEntry, nodeThreadId, partitionStateOf, readHeapStatistics, registerPartialWordSearch, registerStopWords, registerTokenizer, requirePartialWordSearchFor, resolveIndexAnalysis, resolvePartitionInsertOptions, resolveRequestThreadCount, resolveWorkerCount, resolveWorkerEntry, segmentArraysOf, selectionKeeps, shareSegmentArrays, spawnNodeWorker, splitWorkerBudget, survivorDocumentsOf, vectorsPerFile, vectorsToBytes, workerResourceLimits };

package/dist/{chunk-CTOSGRM7.mjs → chunk-G7IP3UDZ.mjs}

@@ -1,9 +1,10 @@
-import { clampRowCount, sortSignatureOf, requireSortableFields, decodePageCursor, requireMatchingCursor, resolveProjection, encodePageCursor, requireWithinResultWindow, normalizeSort, fanOutQuery, sortModesOf, applySorting, applyPagination, projectionKeepsField, countsWithoutScores, fanOutMatchCount, fnv1aBytes, requireValidFilter, createPatternWorkMeter, everyValueFacetConfig, fulltextMatches, mergeFacets, pruneStatsToQueryTerms, partitionsIn, undeclaredFieldOnStrictIndex } from './chunk-VKX2BPXD.mjs';
-import { MAX_INDEX_NAME_LENGTH, INDEX_NAME_PATTERN, MAX_DOC_ID_LENGTH, DEFAULT_LIMIT, DEFAULT_MAX_PER_GROUP, DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, ABSOLUTE_WINDOWS_PATH_PATTERN, MODULE_URL_SCHEME_PATTERN, DEFAULT_LINEAR_ALPHA, MIN_LINEAR_ALPHA, MAX_LINEAR_ALPHA, DEFAULT_RANK_CONSTANT, MIN_RANK_CONSTANT, DEFAULT_OFFSET, DEFAULT_FUZZY_PREFIX_LENGTH, RESULT_WINDOW, PARTIAL_WORD_MIN_CODE_POINTS, PARTIAL_WORDS_ADDED_PER_QUERY, MAX_TOLERANCE, MAX_PREFIX_LENGTH } from './chunk-3DDUNI6N.mjs';
+import { clampRowCount, sortSignatureOf, requireSortableFields, decodePageCursor, requireMatchingCursor, resolveProjection, encodePageCursor, requireWithinResultWindow, normalizeSort, fanOutQuery, sortModesOf, applySorting, applyPagination, projectionKeepsField, countsWithoutScores, fanOutMatchCount, fnv1aBytes, requireValidFilter, createPatternWorkMeter, everyValueFacetConfig, fulltextMatches, mergeFacets, pruneStatsToQueryTerms, partitionsIn, undeclaredFieldOnStrictIndex } from './chunk-D4EF7J3I.mjs';
+import { MAX_INDEX_NAME_LENGTH, INDEX_NAME_PATTERN, MAX_DOC_ID_LENGTH, DEFAULT_LIMIT, DEFAULT_MAX_PER_GROUP, DEFAULT_SUGGEST_LIMIT, MAX_SUGGEST_LIMIT, MAX_SUGGEST_SCATTER_LIMIT, ABSOLUTE_WINDOWS_PATH_PATTERN, MODULE_URL_SCHEME_PATTERN, DEFAULT_LINEAR_ALPHA, MIN_LINEAR_ALPHA, MAX_LINEAR_ALPHA, DEFAULT_RANK_CONSTANT, MIN_RANK_CONSTANT, DEFAULT_OFFSET, DEFAULT_FUZZY_PREFIX_LENGTH, RESULT_WINDOW, PARTIAL_WORD_MIN_CODE_POINTS, PARTIAL_WORDS_ADDED_PER_QUERY, MAX_TOLERANCE, MAX_PREFIX_LENGTH } from './chunk-V3B24XR7.mjs';
 import { MIN_OVERSAMPLE } from './chunk-ZJ4CSAB2.mjs';
-import { tokenize, fuzzyTermMatches } from './chunk-I23G3IZC.mjs';
-import { partialFieldsOf, MIN_PATTERN_VALUE_LIMIT, MAX_PATTERN_VALUE_LIMIT, flattenSchema, isWordIndexedFieldType, isGeopointOrVectorType } from './chunk-Z3DQPOJQ.mjs';
-import { holdsUnpairedSurrogate, compareCodePoints, compareComparableKeys, codePointCount } from './chunk-LJYTW7GT.mjs';
+import { tokenize } from './chunk-NO3ABFLE.mjs';
+import { partialFieldsOf, MIN_PATTERN_VALUE_LIMIT, MAX_PATTERN_VALUE_LIMIT, flattenSchema, isWordIndexedFieldType, isGeopointOrVectorType } from './chunk-356UOTK2.mjs';
+import { fuzzyTermMatches } from './chunk-GES7U2PM.mjs';
+import { holdsUnpairedSurrogate, compareCodePoints, compareComparableKeys, codePointCount } from './chunk-IBR6634K.mjs';
 import { NarsilError, ErrorCodes } from './chunk-I64LXKO3.mjs';
 
 // src/search/cursor-binding.ts

package/dist/chunk-GES7U2PM.mjs

@@ -0,0 +1,68 @@
+// 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, cells: 0 };
+  if (a === b) return { distance: 0, withinTolerance: true, cells: 0 };
+  return tabulatedLevenshtein(a, b, tolerance);
+}
+function tabulatedLevenshtein(a, b, tolerance) {
+  if (tolerance < 0) return { distance: -1, withinTolerance: false, cells: 0 };
+  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, cells: 0 };
+  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;
+  let cells = 0;
+  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];
+    if (high >= low) cells += high - low + 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, cells };
+    const finished = previous;
+    previous = current;
+    current = finished;
+  }
+  const distance = previous[n];
+  return { distance, withinTolerance: distance <= tolerance, cells };
+}
+
+export { boundedLevenshtein, fuzzyPrefixOf, fuzzyTermMatches, tabulatedLevenshtein };