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

package/dist/chunk-T5ZWEWVD.mjs

@@ -0,0 +1,658 @@
+import { tokenizeOptions, getNestedValue, tokenizeIterator, fuzzyTermMatches } from './chunk-I23G3IZC.mjs';
+import { compareCodePoints } from './chunk-LJYTW7GT.mjs';
+
+// src/core/partition/suggestions.ts
+function verbatimOccurrences(state, token) {
+  const postingList = state.invertedIdx.lookup(token);
+  if (!postingList) return 0;
+  const derived = postingList.totalTermFrequency - state.surfaceRegistry.stemChangedTotalFor(token);
+  return derived > 0 ? derived : 0;
+}
+function suggestDisplayTerms(state, surfacePrefix, stemmedPrefix, limit) {
+  if (limit <= 0 || surfacePrefix.length === 0) return [];
+  const groups = /* @__PURE__ */ new Map();
+  for (const candidate of state.surfaceRegistry.candidatesForPrefix(surfacePrefix)) {
+    const postingList = state.invertedIdx.lookup(candidate.token);
+    if (!postingList || postingList.docIdSet.size === 0) continue;
+    let group = groups.get(candidate.token);
+    if (!group) {
+      group = { documentFrequency: postingList.docIdSet.size, surfaces: [] };
+      groups.set(candidate.token, group);
+    }
+    group.surfaces.push({ surface: candidate.surface, occurrences: candidate.occurrences });
+  }
+  const termPrefixes = state.surfaceRegistry.size() === 0 && stemmedPrefix !== surfacePrefix && stemmedPrefix.length > 0 ? [surfacePrefix, stemmedPrefix] : [surfacePrefix];
+  for (const prefix of termPrefixes) {
+    for (const suggestion of state.invertedIdx.prefixSearch(prefix, Number.MAX_SAFE_INTEGER)) {
+      const occurrences = verbatimOccurrences(state, suggestion.term);
+      if (occurrences === 0) continue;
+      let group = groups.get(suggestion.term);
+      if (!group) {
+        group = { documentFrequency: suggestion.documentFrequency, surfaces: [] };
+        groups.set(suggestion.term, group);
+      } else if (group.surfaces.some((s) => s.surface === suggestion.term)) {
+        continue;
+      }
+      group.surfaces.push({ surface: suggestion.term, occurrences });
+    }
+  }
+  const results = [];
+  for (const [token, group] of groups) {
+    results.push({ token, documentFrequency: group.documentFrequency, surfaces: group.surfaces });
+  }
+  results.sort((a, b) => b.documentFrequency - a.documentFrequency || compareCodePoints(a.token, b.token));
+  if (results.length > limit) results.length = limit;
+  return results;
+}
+function partitionDocumentFrequency(subs, token) {
+  let documents = 0;
+  for (const sub of subs) documents += sub.invertedIdx.documentFrequency(token);
+  return documents;
+}
+function expandTermPrefix(subs, surfacePrefix, stemmedToken, maxExpansions) {
+  if (maxExpansions <= 0 || surfacePrefix.length === 0) return [];
+  const candidates = /* @__PURE__ */ new Set();
+  const holdsSurfaceForms = subs.some((sub) => sub.surfaceRegistry.size() > 0);
+  const termPrefixes = !holdsSurfaceForms && stemmedToken !== surfacePrefix && stemmedToken.length > 0 ? [surfacePrefix, stemmedToken] : [surfacePrefix];
+  for (const sub of subs) {
+    for (const candidate of sub.surfaceRegistry.candidatesForPrefix(surfacePrefix)) candidates.add(candidate.token);
+    for (const prefix of termPrefixes) {
+      for (const suggestion of sub.invertedIdx.prefixSearch(prefix, Number.MAX_SAFE_INTEGER)) {
+        if (candidates.has(suggestion.term)) continue;
+        if (verbatimOccurrences(sub, suggestion.term) > 0) candidates.add(suggestion.term);
+      }
+    }
+  }
+  const ranked = [];
+  for (const token of candidates) {
+    const documents = partitionDocumentFrequency(subs, token);
+    if (documents > 0) ranked.push({ token, documents });
+  }
+  ranked.sort((a, b) => b.documents - a.documents || compareCodePoints(a.token, b.token));
+  if (ranked.length > maxExpansions) ranked.length = maxExpansions;
+  return ranked.map((entry) => entry.token);
+}
+
+// src/core/partition/partial-words/text.ts
+var encoder = new TextEncoder();
+var LAST_BASIC_PLANE_CODE_POINT = 65535;
+var UTF8_CONTINUATION_MASK = 192;
+var UTF8_CONTINUATION_BITS = 128;
+function codePointsOf(text) {
+  const points = [];
+  let index = 0;
+  while (index < text.length) {
+    const point = text.codePointAt(index) ?? text.charCodeAt(index);
+    points.push(point);
+    index += point > LAST_BASIC_PLANE_CODE_POINT ? 2 : 1;
+  }
+  return points;
+}
+function runKeyAt(points, at) {
+  return String.fromCodePoint(points[at], points[at + 1], points[at + 2]);
+}
+function partialWordProbe(text) {
+  return { text, codePoints: codePointsOf(text), utf8: encoder.encode(text) };
+}
+function utf8Contains(haystack, start, end, needle) {
+  const last = end - needle.length;
+  for (let from = start; from <= last; from++) {
+    let at = 0;
+    while (at < needle.length && haystack[from + at] === needle[at]) at++;
+    if (at === needle.length) return true;
+  }
+  return false;
+}
+function utf8CodePointCount(bytes, start, end) {
+  let count = 0;
+  for (let at = start; at < end; at++) {
+    if ((bytes[at] & UTF8_CONTINUATION_MASK) !== UTF8_CONTINUATION_BITS) count++;
+  }
+  return count;
+}
+
+// src/core/partition/partial-words/expansion.ts
+function excludedFromRequest(request, token) {
+  if (token === request.ownToken) return true;
+  return request.tolerance > 0 && fuzzyTermMatches(request.ownToken, token, request.tolerance, request.prefixLength);
+}
+function addedWordsFor(subs, readers, request) {
+  if (request.share <= 0) return [];
+  const probe = partialWordProbe(request.written);
+  const shortestSpelling = /* @__PURE__ */ new Map();
+  for (const reader of readers) {
+    reader.forEachContaining(probe, (token, spellingLength) => {
+      const known = shortestSpelling.get(token);
+      if (known === void 0 || spellingLength < known) shortestSpelling.set(token, spellingLength);
+    });
+  }
+  const ranked = [];
+  for (const [token, spellingLength] of shortestSpelling) {
+    if (excludedFromRequest(request, token)) continue;
+    const documents = partitionDocumentFrequency(subs, token);
+    if (documents > 0) ranked.push({ token, documents, spellingLength });
+  }
+  ranked.sort((a, b) => b.documents - a.documents || compareCodePoints(a.token, b.token));
+  if (ranked.length > request.share) ranked.length = request.share;
+  const writtenLength = probe.codePoints.length;
+  return ranked.map((word) => ({ token: word.token, factor: writtenLength / word.spellingLength }));
+}
+function expandPartialWords(subs, analysis, requests) {
+  const readers = [];
+  for (const sub of subs) {
+    const reader = sub.partialWords.readerFor(analysis);
+    if (reader !== null) readers.push(reader);
+  }
+  return requests.map((request) => readers.length === 0 ? [] : addedWordsFor(subs, readers, request));
+}
+
+// src/core/partition/partial-words/constants.ts
+var PARTIAL_WORD_RUN_CODE_POINTS = 3;
+var GROWING_PARTIAL_ENTRY_BYTES = 96;
+var GROWING_PARTIAL_RUN_BYTES = 120;
+var GROWING_PARTIAL_RUN_MEMBER_BYTES = 24;
+var GROWING_PARTIAL_COUNTED_SPELLING_BYTES = 64;
+var FROZEN_PARTIAL_REMOVED_ENTRY_BYTES = 48;
+
+// src/core/partition/frozen/string-blob.ts
+var SURROGATE = /[\ud800-\udfff]/;
+var encoder2 = new TextEncoder();
+function encodeOneByOne(strings) {
+  const encoded = new Array(strings.length);
+  let blobLength = 0;
+  for (let i = 0; i < strings.length; i++) {
+    encoded[i] = encoder2.encode(strings[i]);
+    blobLength += encoded[i].length;
+  }
+  const blob = new Uint8Array(blobLength);
+  const offsets = new Uint32Array(strings.length + 1);
+  let cursor = 0;
+  for (let i = 0; i < strings.length; i++) {
+    blob.set(encoded[i], cursor);
+    cursor += encoded[i].length;
+    offsets[i + 1] = cursor;
+  }
+  return { blob, offsets };
+}
+function basicPlaneUtf8Bytes(text) {
+  let bytes = text.length;
+  for (let i = 0; i < text.length; i++) {
+    const unit = text.charCodeAt(i);
+    if (unit >= 128) bytes += unit < 2048 ? 1 : 2;
+  }
+  return bytes;
+}
+function encodeStringBlob(strings) {
+  const joined = strings.join("");
+  if (SURROGATE.test(joined)) return encodeOneByOne(strings);
+  const blob = encoder2.encode(joined);
+  const offsets = new Uint32Array(strings.length + 1);
+  let cursor = 0;
+  for (let i = 0; i < strings.length; i++) {
+    cursor += basicPlaneUtf8Bytes(strings[i]);
+    offsets[i + 1] = cursor;
+  }
+  return cursor === blob.length ? { blob, offsets } : encodeOneByOne(strings);
+}
+function orderByComparator(strings) {
+  const order = new Array(strings.length);
+  for (let i = 0; i < strings.length; i++) order[i] = i;
+  return order.sort((a, b) => compareCodePoints(strings[a], strings[b]));
+}
+function alreadyInCodePointOrder(strings) {
+  for (let i = 1; i < strings.length; i++) {
+    if (compareCodePoints(strings[i - 1], strings[i]) > 0) return false;
+  }
+  return true;
+}
+function codePointOrder(strings) {
+  if (alreadyInCodePointOrder(strings)) return strings.map((_, i) => i);
+  if (SURROGATE.test(strings.join(""))) return orderByComparator(strings);
+  const positions = /* @__PURE__ */ new Map();
+  for (let i = 0; i < strings.length; i++) positions.set(strings[i], i);
+  if (positions.size !== strings.length) return orderByComparator(strings);
+  const order = new Array(strings.length);
+  const sorted = [...strings].sort();
+  for (let i = 0; i < sorted.length; i++) order[i] = positions.get(sorted[i]) ?? 0;
+  return order;
+}
+
+// src/core/partition/partial-words/frozen-table.ts
+function buildPartialWordTable(source, tokenTable) {
+  const spellings = [];
+  const spellingTokens = [];
+  const spellingCounts = [];
+  const runLists = /* @__PURE__ */ new Map();
+  const addSpelling = (spelling, tokenIndex, count) => {
+    const points = codePointsOf(spelling);
+    if (points.length <= PARTIAL_WORD_RUN_CODE_POINTS) return;
+    const entry = spellings.length;
+    spellings.push(spelling);
+    spellingTokens.push(tokenIndex);
+    spellingCounts.push(count);
+    for (let at = 0; at + PARTIAL_WORD_RUN_CODE_POINTS <= points.length; at++) {
+      const key = runKeyAt(points, at);
+      const list = runLists.get(key);
+      if (list === void 0) runLists.set(key, [entry]);
+      else if (list[list.length - 1] !== entry) list.push(entry);
+    }
+  };
+  for (let at = 0; at < source.tokens.length; at++) {
+    if (source.counts[at] <= 0) continue;
+    const tokenIndex = tokenTable.find(source.tokens[at]);
+    if (tokenIndex >= 0) addSpelling(source.spellings[at], tokenIndex, source.counts[at]);
+  }
+  const runKeys = [...runLists.keys()].sort(compareCodePoints);
+  const runs = new Uint32Array(runKeys.length * PARTIAL_WORD_RUN_CODE_POINTS);
+  const runOffsets = new Uint32Array(runKeys.length + 1);
+  let memberCount = 0;
+  for (const key of runKeys) memberCount += runLists.get(key)?.length ?? 0;
+  const runEntries = new Uint32Array(memberCount);
+  let cursor = 0;
+  for (let run = 0; run < runKeys.length; run++) {
+    const points = codePointsOf(runKeys[run]);
+    runs.set(points, run * PARTIAL_WORD_RUN_CODE_POINTS);
+    for (const entry of runLists.get(runKeys[run]) ?? []) runEntries[cursor++] = entry;
+    runOffsets[run + 1] = cursor;
+  }
+  const spellingBlob = encodeStringBlob(spellings);
+  return {
+    fields: [...source.fields],
+    spellings: spellingBlob.blob,
+    spellingOffsets: spellingBlob.offsets,
+    spellingTokens: Uint32Array.from(spellingTokens),
+    spellingCounts: Uint32Array.from(spellingCounts),
+    runs,
+    runOffsets,
+    runEntries
+  };
+}
+function findRun(runs, first, second, third) {
+  let low = 0;
+  let high = runs.length / PARTIAL_WORD_RUN_CODE_POINTS;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    const at = middle * PARTIAL_WORD_RUN_CODE_POINTS;
+    const difference = runs[at] - first || runs[at + 1] - second || runs[at + 2] - third;
+    if (difference === 0) return middle;
+    if (difference < 0) low = middle + 1;
+    else high = middle;
+  }
+  return -1;
+}
+function partialWordTableBytes(table) {
+  return table.spellings.byteLength + table.spellingOffsets.byteLength + table.spellingTokens.byteLength + table.spellingCounts.byteLength + table.runs.byteLength + table.runOffsets.byteLength + table.runEntries.byteLength;
+}
+function readPartialWordTable(table, tokenTable, removedCounts) {
+  const { spellings, spellingOffsets, spellingTokens, spellingCounts, runs, runOffsets, runEntries } = table;
+  function narrowestRun(points) {
+    let narrowest = -1;
+    let narrowestLength = Number.POSITIVE_INFINITY;
+    for (let at = 0; at + PARTIAL_WORD_RUN_CODE_POINTS <= points.length; at++) {
+      const run = findRun(runs, points[at], points[at + 1], points[at + 2]);
+      if (run < 0) return -1;
+      const length = runOffsets[run + 1] - runOffsets[run];
+      if (length < narrowestLength) {
+        narrowest = run;
+        narrowestLength = length;
+      }
+    }
+    return narrowest;
+  }
+  return {
+    forEachContaining(probe, visit) {
+      if (probe.codePoints.length < PARTIAL_WORD_RUN_CODE_POINTS) return;
+      const run = narrowestRun(probe.codePoints);
+      if (run < 0) return;
+      for (let member = runOffsets[run]; member < runOffsets[run + 1]; member++) {
+        const entry = runEntries[member];
+        const start = spellingOffsets[entry];
+        const end = spellingOffsets[entry + 1];
+        if (end - start <= probe.utf8.length) continue;
+        if ((removedCounts.get(entry) ?? 0) >= spellingCounts[entry]) continue;
+        if (!utf8Contains(spellings, start, end, probe.utf8)) continue;
+        const length = utf8CodePointCount(spellings, start, end);
+        if (length <= probe.codePoints.length) continue;
+        visit(tokenTable.tokenAt(spellingTokens[entry]), length);
+      }
+    },
+    entryOf(spelling, token) {
+      const tokenIndex = tokenTable.find(token);
+      if (tokenIndex < 0) return -1;
+      const probe = partialWordProbe(spelling);
+      if (probe.codePoints.length <= PARTIAL_WORD_RUN_CODE_POINTS) return -1;
+      const run = narrowestRun(probe.codePoints);
+      if (run < 0) return -1;
+      for (let member = runOffsets[run]; member < runOffsets[run + 1]; member++) {
+        const entry = runEntries[member];
+        if (spellingTokens[entry] !== tokenIndex) continue;
+        const start = spellingOffsets[entry];
+        const end = spellingOffsets[entry + 1];
+        if (end - start === probe.utf8.length && utf8Contains(spellings, start, end, probe.utf8)) return entry;
+      }
+      return -1;
+    },
+    bytes() {
+      return partialWordTableBytes(table);
+    }
+  };
+}
+
+// src/core/partition/partial-words/spellings.ts
+function countSpelling(counts, token, spelling, change) {
+  let byToken = counts.get(token);
+  if (byToken === void 0) {
+    if (change <= 0) return;
+    byToken = /* @__PURE__ */ new Map();
+    counts.set(token, byToken);
+  }
+  const next = (byToken.get(spelling) ?? 0) + change;
+  if (next > 0) {
+    byToken.set(spelling, next);
+    return;
+  }
+  byToken.delete(spelling);
+  if (byToken.size === 0) counts.delete(token);
+}
+function textsOf(value) {
+  if (typeof value === "string") return [value];
+  if (!Array.isArray(value)) return [];
+  return value.filter((element) => typeof element === "string");
+}
+function countDocumentSpellings(counts, document, analysis, direction) {
+  const tokenizing = { ...tokenizeOptions(analysis.options), collectSurfaces: true };
+  for (const field of analysis.fields) {
+    for (const text of textsOf(getNestedValue(document, field))) {
+      for (const occurrence of tokenizeIterator(text, analysis.language, tokenizing)) {
+        countSpelling(counts, occurrence.token, occurrence.surface ?? occurrence.token, direction);
+      }
+    }
+  }
+}
+function spellingCountsOf(documents, analysis) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const document of documents) countDocumentSpellings(counts, document, analysis, 1);
+  return counts;
+}
+function encodePartialSpellings(fields, counts) {
+  const encoded = { fields: [...fields], tokens: [], spellings: [], counts: [] };
+  for (const [token, byToken] of counts) {
+    for (const [spelling, count] of byToken) {
+      encoded.tokens.push(token);
+      encoded.spellings.push(spelling);
+      encoded.counts.push(count);
+    }
+  }
+  return encoded;
+}
+function sameFields(left, right) {
+  if (left.length !== right.length) return false;
+  for (let at = 0; at < left.length; at++) {
+    if (left[at] !== right[at]) return false;
+  }
+  return true;
+}
+
+// src/core/partition/partial-words/frozen-slot.ts
+function createFrozenPartialWordSlot(initial, tokenTable, documents) {
+  let table = initial;
+  let removedCounts = /* @__PURE__ */ new Map();
+  let reader = initial === null ? null : readPartialWordTable(initial, tokenTable, removedCounts);
+  let pendingRemovals = [];
+  function subtractPendingRemovals(current, analysis) {
+    if (pendingRemovals.length === 0) return;
+    const removed = /* @__PURE__ */ new Map();
+    for (const ordinal of pendingRemovals) countDocumentSpellings(removed, documents.documentAt(ordinal), analysis, 1);
+    pendingRemovals = [];
+    for (const [token, bySpelling] of removed) {
+      for (const [spelling, count] of bySpelling) {
+        const entry = current.entryOf(spelling, token);
+        if (entry >= 0) removedCounts.set(entry, (removedCounts.get(entry) ?? 0) + count);
+      }
+    }
+  }
+  return {
+    readerFor(analysis) {
+      if (analysis.fields.length === 0) return null;
+      if (table === null || reader === null || !sameFields(table.fields, analysis.fields)) {
+        const counts = spellingCountsOf(documents.survivors(), analysis);
+        table = buildPartialWordTable(encodePartialSpellings(analysis.fields, counts), tokenTable);
+        removedCounts = /* @__PURE__ */ new Map();
+        pendingRemovals = [];
+        reader = readPartialWordTable(table, tokenTable, removedCounts);
+        return reader;
+      }
+      subtractPendingRemovals(reader, analysis);
+      return reader;
+    },
+    afterRemoval(ordinal) {
+      if (table !== null) pendingRemovals.push(ordinal);
+    },
+    spellings() {
+      return null;
+    },
+    bytes() {
+      if (table === null) return 0;
+      return partialWordTableBytes(table) + removedCounts.size * FROZEN_PARTIAL_REMOVED_ENTRY_BYTES;
+    }
+  };
+}
+
+// src/core/partition/partial-words/growing-slot.ts
+function createGrowingPartialWordSlot(view) {
+  let fields = [];
+  let everyDocumentPending = false;
+  const pending = /* @__PURE__ */ new Set();
+  const counts = /* @__PURE__ */ new Map();
+  const entriesByToken = /* @__PURE__ */ new Map();
+  const entrySpellings = [];
+  const entryTokens = [];
+  const entryLengths = [];
+  const freeEntries = [];
+  const runs = /* @__PURE__ */ new Map();
+  let liveEntries = 0;
+  let runMembers = 0;
+  let countedSpellings = 0;
+  function resetSpellings() {
+    pending.clear();
+    counts.clear();
+    countedSpellings = 0;
+    entriesByToken.clear();
+    entrySpellings.length = 0;
+    entryTokens.length = 0;
+    entryLengths.length = 0;
+    freeEntries.length = 0;
+    runs.clear();
+    liveEntries = 0;
+    runMembers = 0;
+  }
+  function addEntry(token, spelling) {
+    const points = codePointsOf(spelling);
+    if (points.length <= PARTIAL_WORD_RUN_CODE_POINTS) return;
+    const entry = freeEntries.pop() ?? entrySpellings.length;
+    entrySpellings[entry] = spelling;
+    entryTokens[entry] = token;
+    entryLengths[entry] = points.length;
+    let byToken = entriesByToken.get(token);
+    if (byToken === void 0) {
+      byToken = /* @__PURE__ */ new Map();
+      entriesByToken.set(token, byToken);
+    }
+    byToken.set(spelling, entry);
+    liveEntries++;
+    for (let at = 0; at + PARTIAL_WORD_RUN_CODE_POINTS <= points.length; at++) {
+      const key = runKeyAt(points, at);
+      let members = runs.get(key);
+      if (members === void 0) {
+        members = /* @__PURE__ */ new Set();
+        runs.set(key, members);
+      }
+      if (members.has(entry)) continue;
+      members.add(entry);
+      runMembers++;
+    }
+  }
+  function removeEntry(token, spelling) {
+    const byToken = entriesByToken.get(token);
+    const entry = byToken?.get(spelling);
+    if (byToken === void 0 || entry === void 0) return;
+    const points = codePointsOf(spelling);
+    for (let at = 0; at + PARTIAL_WORD_RUN_CODE_POINTS <= points.length; at++) {
+      const key = runKeyAt(points, at);
+      const members = runs.get(key);
+      if (members === void 0 || !members.delete(entry)) continue;
+      runMembers--;
+      if (members.size === 0) runs.delete(key);
+    }
+    byToken.delete(spelling);
+    if (byToken.size === 0) entriesByToken.delete(token);
+    entrySpellings[entry] = "";
+    entryTokens[entry] = "";
+    entryLengths[entry] = 0;
+    freeEntries.push(entry);
+    liveEntries--;
+  }
+  function change(token, spelling, delta) {
+    let byToken = counts.get(token);
+    const before = byToken?.get(spelling) ?? 0;
+    const after = Math.max(0, before + delta);
+    if (after === before) return;
+    if (byToken === void 0) {
+      byToken = /* @__PURE__ */ new Map();
+      counts.set(token, byToken);
+    }
+    if (after > 0) byToken.set(spelling, after);
+    else byToken.delete(spelling);
+    if (byToken.size === 0) counts.delete(token);
+    if (before === 0) {
+      countedSpellings++;
+      addEntry(token, spelling);
+    } else if (after === 0) {
+      countedSpellings--;
+      removeEntry(token, spelling);
+    }
+  }
+  function applyCounts(source, direction) {
+    for (const [token, byToken] of source) {
+      for (const [spelling, count] of byToken) change(token, spelling, count * direction);
+    }
+  }
+  function adoptFields(next) {
+    if (sameFields(fields, next)) return;
+    fields = [...next];
+    resetSpellings();
+    everyDocumentPending = fields.length > 0;
+  }
+  function documentAt(internalId) {
+    const docId = view.docStore.getExternalId(internalId);
+    return docId === void 0 ? void 0 : view.docStore.get(docId)?.fields;
+  }
+  function resolvePending(analysis) {
+    if (everyDocumentPending) {
+      resetSpellings();
+      const derived2 = /* @__PURE__ */ new Map();
+      for (const [, stored] of view.docStore.all()) countDocumentSpellings(derived2, stored.fields, analysis, 1);
+      applyCounts(derived2, 1);
+      everyDocumentPending = false;
+      return;
+    }
+    if (pending.size === 0) return;
+    const derived = /* @__PURE__ */ new Map();
+    for (const internalId of pending) {
+      const document = documentAt(internalId);
+      if (document !== void 0) countDocumentSpellings(derived, document, analysis, 1);
+    }
+    pending.clear();
+    applyCounts(derived, 1);
+  }
+  const reader = {
+    forEachContaining(probe, visit) {
+      const points = probe.codePoints;
+      if (points.length < PARTIAL_WORD_RUN_CODE_POINTS) return;
+      let narrowest = null;
+      for (let at = 0; at + PARTIAL_WORD_RUN_CODE_POINTS <= points.length; at++) {
+        const members = runs.get(runKeyAt(points, at));
+        if (members === void 0) return;
+        if (narrowest === null || members.size < narrowest.size) narrowest = members;
+      }
+      if (narrowest === null) return;
+      for (const entry of narrowest) {
+        const length = entryLengths[entry];
+        if (length <= points.length) continue;
+        if (!entrySpellings[entry].includes(probe.text)) continue;
+        visit(entryTokens[entry], length);
+      }
+    },
+    bytes() {
+      return slot.bytes();
+    }
+  };
+  const slot = {
+    readerFor(analysis) {
+      if (analysis.fields.length === 0) return null;
+      adoptFields(analysis.fields);
+      resolvePending(analysis);
+      return reader;
+    },
+    spellings() {
+      if (fields.length === 0 || everyDocumentPending || pending.size > 0) return null;
+      return encodePartialSpellings(fields, counts);
+    },
+    afterDocument(documentFields, internalId, spellings, direction) {
+      if (documentFields.length === 0) return;
+      if (!sameFields(fields, documentFields)) {
+        const holdsOnlyThisDocument = direction === 1 && view.docStore.count() === 1;
+        adoptFields(documentFields);
+        if (holdsOnlyThisDocument) everyDocumentPending = false;
+      }
+      if (everyDocumentPending) return;
+      if (direction === -1 && pending.delete(internalId)) return;
+      if (spellings !== null) {
+        applyCounts(spellings, direction);
+      } else if (direction === 1) {
+        pending.add(internalId);
+      } else {
+        everyDocumentPending = true;
+      }
+    },
+    afterMerge(spellings, internalIds) {
+      if (internalIds.length === 0) return;
+      if (fields.length === 0 && spellings !== null && view.docStore.count() === internalIds.length) {
+        adoptFields(spellings.fields);
+        everyDocumentPending = false;
+      }
+      if (fields.length === 0 || everyDocumentPending) return;
+      if (spellings === null || !sameFields(fields, spellings.fields)) {
+        for (const internalId of internalIds) pending.add(internalId);
+        return;
+      }
+      for (let at = 0; at < spellings.tokens.length; at++) {
+        change(spellings.tokens[at], spellings.spellings[at], spellings.counts[at]);
+      }
+    },
+    forgetSpellings() {
+      resetSpellings();
+      everyDocumentPending = fields.length > 0;
+    },
+    clear() {
+      fields = [];
+      everyDocumentPending = false;
+      resetSpellings();
+    },
+    bytes() {
+      return liveEntries * GROWING_PARTIAL_ENTRY_BYTES + runs.size * GROWING_PARTIAL_RUN_BYTES + runMembers * GROWING_PARTIAL_RUN_MEMBER_BYTES + countedSpellings * GROWING_PARTIAL_COUNTED_SPELLING_BYTES;
+    }
+  };
+  return slot;
+}
+
+// src/core/partition/partial-words/module.ts
+var partialWordSearchModule = {
+  name: "partialWords",
+  createGrowingSlot: createGrowingPartialWordSlot,
+  createFrozenSlot: createFrozenPartialWordSlot,
+  buildTable: buildPartialWordTable,
+  expand: expandPartialWords
+};
+
+export { codePointOrder, countSpelling, encodePartialSpellings, encodeStringBlob, expandTermPrefix, partialWordSearchModule, partitionDocumentFrequency, spellingCountsOf, suggestDisplayTerms };

package/dist/{chunk-Y52WZWAU.mjs → chunk-TVFLHM7M.mjs}

@@ -1,8 +1,8 @@
-import { readSharedConfigFields, restoredEmbedding, restoredPartitionConfig, MAX_PARTITION_COUNT, MAX_REPLICATION_FACTOR } from './chunk-CVPA5Q7R.mjs';
-import { MAX_INDEX_NAME_LENGTH, INDEX_NAME_PATTERN } from './chunk-XZ4PAREY.mjs';
-import { getLanguage } from './chunk-KZTI25D3.mjs';
+import { readSharedConfigFields, restoredEmbedding, restoredPartitionConfig, MAX_PARTITION_COUNT, MAX_REPLICATION_FACTOR } from './chunk-LX4JERXI.mjs';
+import { getLanguage } from './chunk-4MQ5F4IL.mjs';
+import { MAX_INDEX_NAME_LENGTH, INDEX_NAME_PATTERN } from './chunk-3DDUNI6N.mjs';
 import { compareCodePoints } from './chunk-LJYTW7GT.mjs';
-import { NarsilError, ErrorCodes } from './chunk-RV77FR2F.mjs';
+import { NarsilError, ErrorCodes } from './chunk-I64LXKO3.mjs';
 import { encode, decode } from '@msgpack/msgpack';
 
 // src/distribution/cluster/index-settings.ts