@yoch/frozenminisearch 1.2.0 → 1.2.1

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+## v1.2.1 — `@yoch/frozenminisearch`
+
+Patch release: lower search overhead when stored fields are disabled and fewer query-normalization allocations. No API or MSv5 wire-format changes.
+
+### Improved
+
+- **Search without `storeFields`** — skip stored-field reads during scoring and result finalization when the index has no stored fields (`storeFields: []`).
+- **String query normalization** — pre-allocated term/spec buffers, hoisted per-query field boosts and match weights, and shared `termToQuerySpec` building (fewer intermediate arrays and closures).
+
 ## v1.2.0 — `@yoch/frozenminisearch`
 
 Minor release: configurable MSv5 snapshot compression and Node 20 support.

package/dist/cjs/index.cjs

@@ -260,7 +260,9 @@ function finalizeSearchResults(params) {
             queryTerms: terms,
             match,
         };
-        Object.assign(result, getStoredFields(docId));
+        if (getStoredFields != null) {
+            Object.assign(result, getStoredFields(docId));
+        }
         if (filter == null || filter(result)) {
             results.push(result);
         }
@@ -4186,56 +4188,76 @@ function normalizeStringQuery(query, searchOptions, params) {
         ...params.globalSearchOptions,
         ...searchOptions,
     };
-    const terms = options.tokenize(query)
-        .flatMap((term) => options.processTerm(term))
-        .filter(term => !!term);
+    const tokens = options.tokenize(query);
+    const terms = [];
+    for (const token of tokens) {
+        const processed = options.processTerm(token);
+        if (Array.isArray(processed)) {
+            for (const term of processed) {
+                if (term)
+                    terms.push(term);
+            }
+        }
+        else if (processed) {
+            terms.push(processed);
+        }
+    }
+    const toSpec = termToQuerySpec(options);
+    const specs = new Array(terms.length);
+    for (let i = 0; i < terms.length; i++) {
+        specs[i] = toSpec(terms[i], i, terms);
+    }
+    const { fuzzy: fuzzyWeight, prefix: prefixWeight } = {
+        ...defaultSearchOptions.weights,
+        ...options.weights,
+    };
     return {
         options,
-        specs: terms.map(termToQuerySpec(options)),
+        specs,
         operator: options.combineWith,
+        fieldBoosts: fieldBoostsForQuery(options, params.fields),
+        fuzzyWeight,
+        prefixWeight,
     };
 }
 function lazyIndexedTerm(indexView, termIndex) {
     return { kind: 'lazy', resolve: () => indexView.resolveTermByIndex(termIndex) };
 }
-function visitQuerySpecForScoring(query, options, params, visit) {
+function visitQuerySpecForScoring(query, normalized, params, visit) {
     const { indexView } = params;
-    const { weights, maxFuzzy } = options;
-    const { fuzzy: fuzzyWeight, prefix: prefixWeight } = { ...defaultSearchOptions.weights, ...weights };
-    const maxDistance = maxFuzzyDistance(query, maxFuzzy);
+    const { fuzzyWeight, options, prefixWeight } = normalized;
+    const maxDistance = maxFuzzyDistance(query, options.maxFuzzy);
     const exactTi = indexView.resolveTermIndex(query.term);
     visit(exactTi == null ? undefined : indexView.fieldTermData(exactTi), query.term, 1);
-    const seenPrefix = new Set();
+    const seenPrefix = query.prefix && maxDistance ? new Set() : undefined;
     if (query.prefix) {
         for (const { termIndex, length } of indexView.getPrefixMatchesByIndex(query.term)) {
             const distance = length - query.term.length;
             if (!distance)
                 continue;
-            seenPrefix.add(termIndex);
+            seenPrefix === null || seenPrefix === void 0 ? void 0 : seenPrefix.add(termIndex);
             visit(indexView.fieldTermData(termIndex), lazyIndexedTerm(indexView, termIndex), prefixWeight * length / (length + 0.3 * distance));
         }
     }
     if (!maxDistance)
         return;
     for (const { termIndex, length, distance } of indexView.getFuzzyMatchesByIndex(query.term, maxDistance)) {
-        if (!distance || seenPrefix.has(termIndex))
+        if (!distance || (seenPrefix === null || seenPrefix === void 0 ? void 0 : seenPrefix.has(termIndex)))
             continue;
         visit(indexView.fieldTermData(termIndex), lazyIndexedTerm(indexView, termIndex), fuzzyWeight * length / (length + distance));
     }
 }
-function executeQuerySpecInternal(query, searchOptions, params, allowedDocs) {
-    const options = { ...params.globalSearchOptions, ...searchOptions };
-    const fieldBoosts = fieldBoostsForQuery(options, params.fields);
+function executeQuerySpecInternal(query, normalized, params, allowedDocs) {
+    const { fieldBoosts, options } = normalized;
     const termOptions = allowedDocs == null ? undefined : { allowedDocs };
     const results = new Map();
-    visitQuerySpecForScoring(query, options, params, (data, derivedTerm, termWeight) => {
+    visitQuerySpecForScoring(query, normalized, params, (data, derivedTerm, termWeight) => {
         aggregateTerm(query.term, derivedTerm, termWeight, query.termBoost, data, fieldBoosts, params.aggregateContext, options.boostDocument, options.bm25, results, termOptions);
     });
     return results;
 }
-function collectDocIdsForQuerySpec(query, searchOptions, params, allowedDocs) {
-    const options = { ...params.globalSearchOptions, ...searchOptions };
-    const fieldBoosts = fieldBoostsForQuery(options, params.fields);
+function collectDocIdsForQuerySpec(query, normalized, params, allowedDocs) {
+    const { fieldBoosts, options } = normalized;
     const docIds = new Set();
     const { indexView, aggregateContext } = params;
     const maxDistance = maxFuzzyDistance(query, options.maxFuzzy);
@@ -4243,19 +4265,19 @@ function collectDocIdsForQuerySpec(query, searchOptions, params, allowedDocs) {
     if (exactTi != null) {
         indexView.collectDocIds(exactTi, fieldBoosts, aggregateContext, docIds, allowedDocs);
     }
-    const seenPrefix = new Set();
+    const seenPrefix = query.prefix && maxDistance ? new Set() : undefined;
     if (query.prefix) {
         for (const { termIndex, length } of indexView.getPrefixMatchesByIndex(query.term)) {
             const distance = length - query.term.length;
             if (!distance)
                 continue;
-            seenPrefix.add(termIndex);
+            seenPrefix === null || seenPrefix === void 0 ? void 0 : seenPrefix.add(termIndex);
             indexView.collectDocIds(termIndex, fieldBoosts, aggregateContext, docIds, allowedDocs);
         }
     }
     if (maxDistance) {
         for (const { termIndex, distance } of indexView.getFuzzyMatchesByIndex(query.term, maxDistance)) {
-            if (!distance || seenPrefix.has(termIndex))
+            if (!distance || (seenPrefix === null || seenPrefix === void 0 ? void 0 : seenPrefix.has(termIndex)))
                 continue;
             indexView.collectDocIds(termIndex, fieldBoosts, aggregateContext, docIds, allowedDocs);
         }
@@ -4386,14 +4408,15 @@ function collectDocIdsForQueryInternal(query, searchOptions, params, allowedDocs
     if (typeof query !== 'string') {
         throw new Error('FrozenMiniSearch: invalid query');
     }
-    const { options, specs, operator } = normalizeStringQuery(query, searchOptions, params);
+    const normalized = normalizeStringQuery(query, searchOptions, params);
+    const { specs, operator } = normalized;
     const combineWith = (operator !== null && operator !== void 0 ? operator : params.globalSearchOptions.combineWith);
     if (specs.length <= 1) {
         return specs.length === 1
-            ? collectDocIdsForQuerySpec(specs[0], options, params, allowedDocs)
+            ? collectDocIdsForQuerySpec(specs[0], normalized, params, allowedDocs)
             : new Set();
     }
-    return collectCombinedDocIds(specs, combineWith, (spec, branchAllowed) => collectDocIdsForQuerySpec(spec, options, params, branchAllowed), allowedDocs);
+    return collectCombinedDocIds(specs, combineWith, (spec, branchAllowed) => collectDocIdsForQuerySpec(spec, normalized, params, branchAllowed), allowedDocs);
 }
 function executeWildcardQuery(searchOptions, params) {
     const results = new Map();
@@ -4423,12 +4446,13 @@ function executeQueryInternal(query, searchOptions, params, allowedDocs, run) {
     if (typeof query !== 'string') {
         throw new Error('FrozenMiniSearch: invalid query');
     }
-    const { options, specs, operator } = normalizeStringQuery(query, searchOptions, params);
+    const normalized = normalizeStringQuery(query, searchOptions, params);
+    const { specs, operator } = normalized;
     const combineWith = (operator !== null && operator !== void 0 ? operator : params.globalSearchOptions.combineWith);
     if (useGatedEvaluation(run, specs.length, combineWith, false)) {
-        return executeCombinedBranches(specs, combineWith, params, (spec, branchAllowed) => executeQuerySpecInternal(spec, options, params, branchAllowed), (spec, branchAllowed) => collectDocIdsForQuerySpec(spec, options, params, branchAllowed), allowedDocs);
+        return executeCombinedBranches(specs, combineWith, params, (spec, branchAllowed) => executeQuerySpecInternal(spec, normalized, params, branchAllowed), (spec, branchAllowed) => collectDocIdsForQuerySpec(spec, normalized, params, branchAllowed), allowedDocs);
     }
-    const results = specs.map(spec => executeQuerySpecInternal(spec, options, params, allowedDocs));
+    const results = specs.map(spec => executeQuerySpecInternal(spec, normalized, params, allowedDocs));
     return combineResults(results, combineWith);
 }
 function executeQuery(query, searchOptions, params) {
@@ -4619,6 +4643,7 @@ function materializeOwnedSnapshot(params, mode) {
 function frozenMemoryBreakdown(frozen) {
     return frozen.memoryBreakdown();
 }
+const noStoredFields = () => undefined;
 function assertFieldsMatchSnapshot(optionsFields, snapFieldIds) {
     const snapNames = Object.keys(snapFieldIds).sort();
     const optNames = [...optionsFields].sort();
@@ -4672,24 +4697,31 @@ class FrozenMiniSearch {
         this._termCount = params.termCount;
         this._postings = params.postings;
         this._fieldTermFlyweight = createFrozenFieldTermFlyweight(this._postings);
+        this._hasStoredFields = this._storedFields.kind !== 'none';
         this._aggregateContext = {
             documentCount: this._documentCount,
             avgFieldLength: this._avgFieldLength,
             fieldIds: this._fieldIds,
             getFieldLength: (docId, fieldId) => this.getFieldLength(docId, fieldId),
             getExternalId: docId => this._externalIds[docId],
-            getStoredFields: docId => readStoredFields(this._storedFields, docId),
+            getStoredFields: this._hasStoredFields
+                ? docId => readStoredFields(this._storedFields, docId)
+                : noStoredFields,
         };
         this._queryEngineParams = {
             fields: this._options.fields,
             globalSearchOptions: this._options.searchOptions,
             tokenize: this._options.tokenize,
             processTerm: this._options.processTerm,
-            indexView: createFrozenQueryIndexView(this._index, this._postings, this._fieldTermFlyweight, (callback) => {
-                forEachLiveShortId(this._nextId, this._externalIds, (shortId, id) => {
-                    callback(shortId, id, readStoredFields(this._storedFields, shortId));
-                });
-            }),
+            indexView: createFrozenQueryIndexView(this._index, this._postings, this._fieldTermFlyweight, this._hasStoredFields
+                ? (callback) => {
+                    forEachLiveShortId(this._nextId, this._externalIds, (shortId, id) => {
+                        callback(shortId, id, readStoredFields(this._storedFields, shortId));
+                    });
+                }
+                : (callback) => {
+                    forEachLiveShortId(this._nextId, this._externalIds, callback);
+                }),
             aggregateContext: this._aggregateContext,
         };
     }
@@ -4746,7 +4778,9 @@ class FrozenMiniSearch {
         return shortId == null ? undefined : readStoredFields(this._storedFields, shortId);
     }
     search(query, searchOptions = {}) {
-        return finalizeRawSearchResults(this.executeQuery(query, searchOptions), query, searchOptions, this._options.searchOptions, docId => this._externalIds[docId], docId => readStoredFields(this._storedFields, docId));
+        return finalizeRawSearchResults(this.executeQuery(query, searchOptions), query, searchOptions, this._options.searchOptions, docId => this._externalIds[docId], this._hasStoredFields
+            ? docId => readStoredFields(this._storedFields, docId)
+            : undefined);
     }
     autoSuggest(queryString, options = {}) {
         const merged = { ...this._options.autoSuggestOptions, ...options };

package/dist/es/index.d.ts

@@ -600,6 +600,7 @@ declare class FrozenMiniSearch<T = any> {
     private readonly _fieldTermFlyweight;
     private readonly _aggregateContext;
     private readonly _queryEngineParams;
+    private readonly _hasStoredFields;
     constructor(params: FrozenAssembleParams<T>);
     static readonly wildcard: typeof WILDCARD_QUERY;
     get documentCount(): number;

package/dist/es/index.js

@@ -256,7 +256,9 @@ function finalizeSearchResults(params) {
             queryTerms: terms,
             match,
         };
-        Object.assign(result, getStoredFields(docId));
+        if (getStoredFields != null) {
+            Object.assign(result, getStoredFields(docId));
+        }
         if (filter == null || filter(result)) {
             results.push(result);
         }
@@ -4182,56 +4184,76 @@ function normalizeStringQuery(query, searchOptions, params) {
         ...params.globalSearchOptions,
         ...searchOptions,
     };
-    const terms = options.tokenize(query)
-        .flatMap((term) => options.processTerm(term))
-        .filter(term => !!term);
+    const tokens = options.tokenize(query);
+    const terms = [];
+    for (const token of tokens) {
+        const processed = options.processTerm(token);
+        if (Array.isArray(processed)) {
+            for (const term of processed) {
+                if (term)
+                    terms.push(term);
+            }
+        }
+        else if (processed) {
+            terms.push(processed);
+        }
+    }
+    const toSpec = termToQuerySpec(options);
+    const specs = new Array(terms.length);
+    for (let i = 0; i < terms.length; i++) {
+        specs[i] = toSpec(terms[i], i, terms);
+    }
+    const { fuzzy: fuzzyWeight, prefix: prefixWeight } = {
+        ...defaultSearchOptions.weights,
+        ...options.weights,
+    };
     return {
         options,
-        specs: terms.map(termToQuerySpec(options)),
+        specs,
         operator: options.combineWith,
+        fieldBoosts: fieldBoostsForQuery(options, params.fields),
+        fuzzyWeight,
+        prefixWeight,
     };
 }
 function lazyIndexedTerm(indexView, termIndex) {
     return { kind: 'lazy', resolve: () => indexView.resolveTermByIndex(termIndex) };
 }
-function visitQuerySpecForScoring(query, options, params, visit) {
+function visitQuerySpecForScoring(query, normalized, params, visit) {
     const { indexView } = params;
-    const { weights, maxFuzzy } = options;
-    const { fuzzy: fuzzyWeight, prefix: prefixWeight } = { ...defaultSearchOptions.weights, ...weights };
-    const maxDistance = maxFuzzyDistance(query, maxFuzzy);
+    const { fuzzyWeight, options, prefixWeight } = normalized;
+    const maxDistance = maxFuzzyDistance(query, options.maxFuzzy);
     const exactTi = indexView.resolveTermIndex(query.term);
     visit(exactTi == null ? undefined : indexView.fieldTermData(exactTi), query.term, 1);
-    const seenPrefix = new Set();
+    const seenPrefix = query.prefix && maxDistance ? new Set() : undefined;
     if (query.prefix) {
         for (const { termIndex, length } of indexView.getPrefixMatchesByIndex(query.term)) {
             const distance = length - query.term.length;
             if (!distance)
                 continue;
-            seenPrefix.add(termIndex);
+            seenPrefix === null || seenPrefix === void 0 ? void 0 : seenPrefix.add(termIndex);
             visit(indexView.fieldTermData(termIndex), lazyIndexedTerm(indexView, termIndex), prefixWeight * length / (length + 0.3 * distance));
         }
     }
     if (!maxDistance)
         return;
     for (const { termIndex, length, distance } of indexView.getFuzzyMatchesByIndex(query.term, maxDistance)) {
-        if (!distance || seenPrefix.has(termIndex))
+        if (!distance || (seenPrefix === null || seenPrefix === void 0 ? void 0 : seenPrefix.has(termIndex)))
             continue;
         visit(indexView.fieldTermData(termIndex), lazyIndexedTerm(indexView, termIndex), fuzzyWeight * length / (length + distance));
     }
 }
-function executeQuerySpecInternal(query, searchOptions, params, allowedDocs) {
-    const options = { ...params.globalSearchOptions, ...searchOptions };
-    const fieldBoosts = fieldBoostsForQuery(options, params.fields);
+function executeQuerySpecInternal(query, normalized, params, allowedDocs) {
+    const { fieldBoosts, options } = normalized;
     const termOptions = allowedDocs == null ? undefined : { allowedDocs };
     const results = new Map();
-    visitQuerySpecForScoring(query, options, params, (data, derivedTerm, termWeight) => {
+    visitQuerySpecForScoring(query, normalized, params, (data, derivedTerm, termWeight) => {
         aggregateTerm(query.term, derivedTerm, termWeight, query.termBoost, data, fieldBoosts, params.aggregateContext, options.boostDocument, options.bm25, results, termOptions);
     });
     return results;
 }
-function collectDocIdsForQuerySpec(query, searchOptions, params, allowedDocs) {
-    const options = { ...params.globalSearchOptions, ...searchOptions };
-    const fieldBoosts = fieldBoostsForQuery(options, params.fields);
+function collectDocIdsForQuerySpec(query, normalized, params, allowedDocs) {
+    const { fieldBoosts, options } = normalized;
     const docIds = new Set();
     const { indexView, aggregateContext } = params;
     const maxDistance = maxFuzzyDistance(query, options.maxFuzzy);
@@ -4239,19 +4261,19 @@ function collectDocIdsForQuerySpec(query, searchOptions, params, allowedDocs) {
     if (exactTi != null) {
         indexView.collectDocIds(exactTi, fieldBoosts, aggregateContext, docIds, allowedDocs);
     }
-    const seenPrefix = new Set();
+    const seenPrefix = query.prefix && maxDistance ? new Set() : undefined;
     if (query.prefix) {
         for (const { termIndex, length } of indexView.getPrefixMatchesByIndex(query.term)) {
             const distance = length - query.term.length;
             if (!distance)
                 continue;
-            seenPrefix.add(termIndex);
+            seenPrefix === null || seenPrefix === void 0 ? void 0 : seenPrefix.add(termIndex);
             indexView.collectDocIds(termIndex, fieldBoosts, aggregateContext, docIds, allowedDocs);
         }
     }
     if (maxDistance) {
         for (const { termIndex, distance } of indexView.getFuzzyMatchesByIndex(query.term, maxDistance)) {
-            if (!distance || seenPrefix.has(termIndex))
+            if (!distance || (seenPrefix === null || seenPrefix === void 0 ? void 0 : seenPrefix.has(termIndex)))
                 continue;
             indexView.collectDocIds(termIndex, fieldBoosts, aggregateContext, docIds, allowedDocs);
         }
@@ -4382,14 +4404,15 @@ function collectDocIdsForQueryInternal(query, searchOptions, params, allowedDocs
     if (typeof query !== 'string') {
         throw new Error('FrozenMiniSearch: invalid query');
     }
-    const { options, specs, operator } = normalizeStringQuery(query, searchOptions, params);
+    const normalized = normalizeStringQuery(query, searchOptions, params);
+    const { specs, operator } = normalized;
     const combineWith = (operator !== null && operator !== void 0 ? operator : params.globalSearchOptions.combineWith);
     if (specs.length <= 1) {
         return specs.length === 1
-            ? collectDocIdsForQuerySpec(specs[0], options, params, allowedDocs)
+            ? collectDocIdsForQuerySpec(specs[0], normalized, params, allowedDocs)
             : new Set();
     }
-    return collectCombinedDocIds(specs, combineWith, (spec, branchAllowed) => collectDocIdsForQuerySpec(spec, options, params, branchAllowed), allowedDocs);
+    return collectCombinedDocIds(specs, combineWith, (spec, branchAllowed) => collectDocIdsForQuerySpec(spec, normalized, params, branchAllowed), allowedDocs);
 }
 function executeWildcardQuery(searchOptions, params) {
     const results = new Map();
@@ -4419,12 +4442,13 @@ function executeQueryInternal(query, searchOptions, params, allowedDocs, run) {
     if (typeof query !== 'string') {
         throw new Error('FrozenMiniSearch: invalid query');
     }
-    const { options, specs, operator } = normalizeStringQuery(query, searchOptions, params);
+    const normalized = normalizeStringQuery(query, searchOptions, params);
+    const { specs, operator } = normalized;
     const combineWith = (operator !== null && operator !== void 0 ? operator : params.globalSearchOptions.combineWith);
     if (useGatedEvaluation(run, specs.length, combineWith, false)) {
-        return executeCombinedBranches(specs, combineWith, params, (spec, branchAllowed) => executeQuerySpecInternal(spec, options, params, branchAllowed), (spec, branchAllowed) => collectDocIdsForQuerySpec(spec, options, params, branchAllowed), allowedDocs);
+        return executeCombinedBranches(specs, combineWith, params, (spec, branchAllowed) => executeQuerySpecInternal(spec, normalized, params, branchAllowed), (spec, branchAllowed) => collectDocIdsForQuerySpec(spec, normalized, params, branchAllowed), allowedDocs);
     }
-    const results = specs.map(spec => executeQuerySpecInternal(spec, options, params, allowedDocs));
+    const results = specs.map(spec => executeQuerySpecInternal(spec, normalized, params, allowedDocs));
     return combineResults(results, combineWith);
 }
 function executeQuery(query, searchOptions, params) {
@@ -4615,6 +4639,7 @@ function materializeOwnedSnapshot(params, mode) {
 function frozenMemoryBreakdown(frozen) {
     return frozen.memoryBreakdown();
 }
+const noStoredFields = () => undefined;
 function assertFieldsMatchSnapshot(optionsFields, snapFieldIds) {
     const snapNames = Object.keys(snapFieldIds).sort();
     const optNames = [...optionsFields].sort();
@@ -4668,24 +4693,31 @@ class FrozenMiniSearch {
         this._termCount = params.termCount;
         this._postings = params.postings;
         this._fieldTermFlyweight = createFrozenFieldTermFlyweight(this._postings);
+        this._hasStoredFields = this._storedFields.kind !== 'none';
         this._aggregateContext = {
             documentCount: this._documentCount,
             avgFieldLength: this._avgFieldLength,
             fieldIds: this._fieldIds,
             getFieldLength: (docId, fieldId) => this.getFieldLength(docId, fieldId),
             getExternalId: docId => this._externalIds[docId],
-            getStoredFields: docId => readStoredFields(this._storedFields, docId),
+            getStoredFields: this._hasStoredFields
+                ? docId => readStoredFields(this._storedFields, docId)
+                : noStoredFields,
         };
         this._queryEngineParams = {
             fields: this._options.fields,
             globalSearchOptions: this._options.searchOptions,
             tokenize: this._options.tokenize,
             processTerm: this._options.processTerm,
-            indexView: createFrozenQueryIndexView(this._index, this._postings, this._fieldTermFlyweight, (callback) => {
-                forEachLiveShortId(this._nextId, this._externalIds, (shortId, id) => {
-                    callback(shortId, id, readStoredFields(this._storedFields, shortId));
-                });
-            }),
+            indexView: createFrozenQueryIndexView(this._index, this._postings, this._fieldTermFlyweight, this._hasStoredFields
+                ? (callback) => {
+                    forEachLiveShortId(this._nextId, this._externalIds, (shortId, id) => {
+                        callback(shortId, id, readStoredFields(this._storedFields, shortId));
+                    });
+                }
+                : (callback) => {
+                    forEachLiveShortId(this._nextId, this._externalIds, callback);
+                }),
             aggregateContext: this._aggregateContext,
         };
     }
@@ -4742,7 +4774,9 @@ class FrozenMiniSearch {
         return shortId == null ? undefined : readStoredFields(this._storedFields, shortId);
     }
     search(query, searchOptions = {}) {
-        return finalizeRawSearchResults(this.executeQuery(query, searchOptions), query, searchOptions, this._options.searchOptions, docId => this._externalIds[docId], docId => readStoredFields(this._storedFields, docId));
+        return finalizeRawSearchResults(this.executeQuery(query, searchOptions), query, searchOptions, this._options.searchOptions, docId => this._externalIds[docId], this._hasStoredFields
+            ? docId => readStoredFields(this._storedFields, docId)
+            : undefined);
     }
     autoSuggest(queryString, options = {}) {
         const merged = { ...this._options.autoSuggestOptions, ...options };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yoch/frozenminisearch",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Read-only Node.js full-text search — compact frozen indexes and binary snapshots",
   "main": "dist/cjs/index.cjs",
   "module": "dist/es/index.js",