@yoch/minisearch 8.0.0-beta.2

package/dist/cjs/index.cjs

@@ -0,0 +1,2961 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/** @ignore */
+const ENTRIES = 'ENTRIES';
+/** @ignore */
+const KEYS = 'KEYS';
+/** @ignore */
+const VALUES = 'VALUES';
+/** @ignore */
+const LEAF = '';
+/**
+ * @private
+ */
+class TreeIterator {
+    constructor(set, type) {
+        const node = set._tree;
+        const keys = Array.from(node.keys());
+        this.set = set;
+        this._type = type;
+        this._path = keys.length > 0 ? [{ node, keys }] : [];
+    }
+    next() {
+        const value = this.dive();
+        this.backtrack();
+        return value;
+    }
+    dive() {
+        if (this._path.length === 0) {
+            return { done: true, value: undefined };
+        }
+        const { node, keys } = last$1(this._path);
+        if (last$1(keys) === LEAF) {
+            return { done: false, value: this.result() };
+        }
+        const child = node.get(last$1(keys));
+        this._path.push({ node: child, keys: Array.from(child.keys()) });
+        return this.dive();
+    }
+    backtrack() {
+        if (this._path.length === 0) {
+            return;
+        }
+        const keys = last$1(this._path).keys;
+        keys.pop();
+        if (keys.length > 0) {
+            return;
+        }
+        this._path.pop();
+        this.backtrack();
+    }
+    key() {
+        return this.set._prefix + this._path
+            .map(({ keys }) => last$1(keys))
+            .filter(key => key !== LEAF)
+            .join('');
+    }
+    value() {
+        return last$1(this._path).node.get(LEAF);
+    }
+    result() {
+        switch (this._type) {
+            case VALUES: return this.value();
+            case KEYS: return this.key();
+            default: return [this.key(), this.value()];
+        }
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+}
+const last$1 = (array) => {
+    return array[array.length - 1];
+};
+
+/* eslint-disable no-labels */
+/**
+ * @ignore
+ */
+const fuzzySearch = (node, query, maxDistance) => {
+    const results = new Map();
+    if (query === undefined)
+        return results;
+    // Number of columns in the Levenshtein matrix.
+    const n = query.length + 1;
+    // Matching terms can never be longer than N + maxDistance.
+    const m = n + maxDistance;
+    // Fill first matrix row and column with numbers: 0 1 2 3 ...
+    const matrix = new Uint8Array(m * n).fill(maxDistance + 1);
+    for (let j = 0; j < n; ++j)
+        matrix[j] = j;
+    for (let i = 1; i < m; ++i)
+        matrix[i * n] = i;
+    recurse(node, query, maxDistance, results, matrix, 1, n, '');
+    return results;
+};
+// Modified version of http://stevehanov.ca/blog/?id=114
+// This builds a Levenshtein matrix for a given query and continuously updates
+// it for nodes in the radix tree that fall within the given maximum edit
+// distance. Keeping the same matrix around is beneficial especially for larger
+// edit distances.
+//
+//           k   a   t   e   <-- query
+//       0   1   2   3   4
+//   c   1   1   2   3   4
+//   a   2   2   1   2   3
+//   t   3   3   2   1  [2]  <-- edit distance
+//   ^
+//   ^ term in radix tree, rows are added and removed as needed
+const recurse = (node, query, maxDistance, results, matrix, m, n, prefix) => {
+    const offset = m * n;
+    key: for (const key of node.keys()) {
+        if (key === LEAF) {
+            // We've reached a leaf node. Check if the edit distance acceptable and
+            // store the result if it is.
+            const distance = matrix[offset - 1];
+            if (distance <= maxDistance) {
+                results.set(prefix, [node.get(key), distance]);
+            }
+        }
+        else {
+            // Iterate over all characters in the key. Update the Levenshtein matrix
+            // and check if the minimum distance in the last row is still within the
+            // maximum edit distance. If it is, we can recurse over all child nodes.
+            let i = m;
+            for (let pos = 0; pos < key.length; ++pos, ++i) {
+                const char = key[pos];
+                const thisRowOffset = n * i;
+                const prevRowOffset = thisRowOffset - n;
+                // Set the first column based on the previous row, and initialize the
+                // minimum distance in the current row.
+                let minDistance = matrix[thisRowOffset];
+                const jmin = Math.max(0, i - maxDistance - 1);
+                const jmax = Math.min(n - 1, i + maxDistance);
+                // Iterate over remaining columns (characters in the query).
+                for (let j = jmin; j < jmax; ++j) {
+                    const different = char !== query[j];
+                    // It might make sense to only read the matrix positions used for
+                    // deletion/insertion if the characters are different. But we want to
+                    // avoid conditional reads for performance reasons.
+                    const rpl = matrix[prevRowOffset + j] + +different;
+                    const del = matrix[prevRowOffset + j + 1] + 1;
+                    const ins = matrix[thisRowOffset + j] + 1;
+                    const dist = matrix[thisRowOffset + j + 1] = Math.min(rpl, del, ins);
+                    if (dist < minDistance)
+                        minDistance = dist;
+                }
+                // Because distance will never decrease, we can stop. There will be no
+                // matching child nodes.
+                if (minDistance > maxDistance) {
+                    continue key;
+                }
+            }
+            recurse(node.get(key), query, maxDistance, results, matrix, i, n, prefix + key);
+        }
+    }
+};
+
+/* eslint-disable no-labels */
+/**
+ * A class implementing the same interface as a standard JavaScript
+ * [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map)
+ * with string keys, but adding support for efficiently searching entries with
+ * prefix or fuzzy search. This class is used internally by {@link MiniSearch}
+ * as the inverted index data structure. The implementation is a radix tree
+ * (compressed prefix tree).
+ *
+ * Since this class can be of general utility beyond _MiniSearch_, it is
+ * internal to `@yoch/minisearch` (not a separate public entry point).
+ *
+ * @typeParam T  The type of the values stored in the map.
+ */
+class SearchableMap {
+    /**
+     * The constructor is normally called without arguments, creating an empty
+     * map. In order to create a {@link SearchableMap} from an iterable or from an
+     * object, check {@link SearchableMap.from} and {@link
+     * SearchableMap.fromObject}.
+     *
+     * The constructor arguments are for internal use, when creating derived
+     * mutable views of a map at a prefix.
+     */
+    constructor(tree = new Map(), prefix = '') {
+        this._size = undefined;
+        this._tree = tree;
+        this._prefix = prefix;
+    }
+    /**
+     * Root radix tree backing this map. Used when cloning or serializing the full
+     * index so {@link Map} key insertion order (prefix / fuzzy / autoSuggest) is preserved.
+     */
+    get radixTree() {
+        return this._tree;
+    }
+    /**
+     * Creates and returns a mutable view of this {@link SearchableMap},
+     * containing only entries that share the given prefix.
+     *
+     * ### Usage:
+     *
+     * ```javascript
+     * let map = new SearchableMap()
+     * map.set("unicorn", 1)
+     * map.set("universe", 2)
+     * map.set("university", 3)
+     * map.set("unique", 4)
+     * map.set("hello", 5)
+     *
+     * let uni = map.atPrefix("uni")
+     * uni.get("unique") // => 4
+     * uni.get("unicorn") // => 1
+     * uni.get("hello") // => undefined
+     *
+     * let univer = map.atPrefix("univer")
+     * univer.get("unique") // => undefined
+     * univer.get("universe") // => 2
+     * univer.get("university") // => 3
+     * ```
+     *
+     * @param prefix  The prefix
+     * @return A {@link SearchableMap} representing a mutable view of the original
+     * Map at the given prefix
+     */
+    atPrefix(prefix) {
+        if (!prefix.startsWith(this._prefix)) {
+            throw new Error('Mismatched prefix');
+        }
+        const [node, path] = trackDown(this._tree, prefix.slice(this._prefix.length));
+        if (node === undefined) {
+            const [parentNode, key] = last(path);
+            for (const k of parentNode.keys()) {
+                if (k !== LEAF && k.startsWith(key)) {
+                    const node = new Map();
+                    node.set(k.slice(key.length), parentNode.get(k));
+                    return new SearchableMap(node, prefix);
+                }
+            }
+        }
+        return new SearchableMap(node, prefix);
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/clear
+     */
+    clear() {
+        this._size = undefined;
+        this._tree.clear();
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/delete
+     * @param key  Key to delete
+     */
+    delete(key) {
+        this._size = undefined;
+        return remove(this._tree, key);
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/entries
+     * @return An iterator iterating through `[key, value]` entries.
+     */
+    entries() {
+        return new TreeIterator(this, ENTRIES);
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/forEach
+     * @param fn  Iteration function
+     */
+    forEach(fn) {
+        for (const [key, value] of this) {
+            fn(key, value, this);
+        }
+    }
+    /**
+     * Returns a Map of all the entries that have a key within the given edit
+     * distance from the search key. The keys of the returned Map are the matching
+     * keys, while the values are two-element arrays where the first element is
+     * the value associated to the key, and the second is the edit distance of the
+     * key to the search key.
+     *
+     * ### Usage:
+     *
+     * ```javascript
+     * let map = new SearchableMap()
+     * map.set('hello', 'world')
+     * map.set('hell', 'yeah')
+     * map.set('ciao', 'mondo')
+     *
+     * // Get all entries that match the key 'hallo' with a maximum edit distance of 2
+     * map.fuzzyGet('hallo', 2)
+     * // => Map(2) { 'hello' => ['world', 1], 'hell' => ['yeah', 2] }
+     *
+     * // In the example, the "hello" key has value "world" and edit distance of 1
+     * // (change "e" to "a"), the key "hell" has value "yeah" and edit distance of 2
+     * // (change "e" to "a", delete "o")
+     * ```
+     *
+     * @param key  The search key
+     * @param maxEditDistance  The maximum edit distance (Levenshtein)
+     * @return A Map of the matching keys to their value and edit distance
+     */
+    fuzzyGet(key, maxEditDistance) {
+        return fuzzySearch(this._tree, key, maxEditDistance);
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/get
+     * @param key  Key to get
+     * @return Value associated to the key, or `undefined` if the key is not
+     * found.
+     */
+    get(key) {
+        const node = lookup(this._tree, key);
+        return node !== undefined ? node.get(LEAF) : undefined;
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/has
+     * @param key  Key
+     * @return True if the key is in the map, false otherwise
+     */
+    has(key) {
+        const node = lookup(this._tree, key);
+        return node !== undefined && node.has(LEAF);
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/keys
+     * @return An `Iterable` iterating through keys
+     */
+    keys() {
+        return new TreeIterator(this, KEYS);
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/set
+     * @param key  Key to set
+     * @param value  Value to associate to the key
+     * @return The {@link SearchableMap} itself, to allow chaining
+     */
+    set(key, value) {
+        if (typeof key !== 'string') {
+            throw new Error('key must be a string');
+        }
+        this._size = undefined;
+        const node = createPath(this._tree, key);
+        node.set(LEAF, value);
+        return this;
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/size
+     */
+    get size() {
+        if (this._size) {
+            return this._size;
+        }
+        /** @ignore */
+        this._size = 0;
+        const iter = this.entries();
+        while (!iter.next().done)
+            this._size += 1;
+        return this._size;
+    }
+    /**
+     * Updates the value at the given key using the provided function. The function
+     * is called with the current value at the key, and its return value is used as
+     * the new value to be set.
+     *
+     * ### Example:
+     *
+     * ```javascript
+     * // Increment the current value by one
+     * searchableMap.update('somekey', (currentValue) => currentValue == null ? 0 : currentValue + 1)
+     * ```
+     *
+     * If the value at the given key is or will be an object, it might not require
+     * re-assignment. In that case it is better to use `fetch()`, because it is
+     * faster.
+     *
+     * @param key  The key to update
+     * @param fn  The function used to compute the new value from the current one
+     * @return The {@link SearchableMap} itself, to allow chaining
+     */
+    update(key, fn) {
+        if (typeof key !== 'string') {
+            throw new Error('key must be a string');
+        }
+        this._size = undefined;
+        const node = createPath(this._tree, key);
+        node.set(LEAF, fn(node.get(LEAF)));
+        return this;
+    }
+    /**
+     * Fetches the value of the given key. If the value does not exist, calls the
+     * given function to create a new value, which is inserted at the given key
+     * and subsequently returned.
+     *
+     * ### Example:
+     *
+     * ```javascript
+     * const map = searchableMap.fetch('somekey', () => new Map())
+     * map.set('foo', 'bar')
+     * ```
+     *
+     * @param key  The key to update
+     * @param initial  A function that creates a new value if the key does not exist
+     * @return The existing or new value at the given key
+     */
+    fetch(key, initial) {
+        if (typeof key !== 'string') {
+            throw new Error('key must be a string');
+        }
+        this._size = undefined;
+        const node = createPath(this._tree, key);
+        let value = node.get(LEAF);
+        if (value === undefined) {
+            node.set(LEAF, value = initial());
+        }
+        return value;
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/values
+     * @return An `Iterable` iterating through values.
+     */
+    values() {
+        return new TreeIterator(this, VALUES);
+    }
+    /**
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/@@iterator
+     */
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    /**
+     * Creates a {@link SearchableMap} from an `Iterable` of entries
+     *
+     * @param entries  Entries to be inserted in the {@link SearchableMap}
+     * @return A new {@link SearchableMap} with the given entries
+     */
+    static from(entries) {
+        const tree = new SearchableMap();
+        for (const [key, value] of entries) {
+            tree.set(key, value);
+        }
+        return tree;
+    }
+    /**
+     * Creates a {@link SearchableMap} from the iterable properties of a JavaScript object
+     *
+     * @param object  Object of entries for the {@link SearchableMap}
+     * @return A new {@link SearchableMap} with the given entries
+     */
+    static fromObject(object) {
+        return SearchableMap.from(Object.entries(object));
+    }
+}
+const trackDown = (tree, key, path = []) => {
+    if (key.length === 0 || tree == null) {
+        return [tree, path];
+    }
+    for (const k of tree.keys()) {
+        if (k !== LEAF && key.startsWith(k)) {
+            path.push([tree, k]); // performance: update in place
+            return trackDown(tree.get(k), key.slice(k.length), path);
+        }
+    }
+    path.push([tree, key]); // performance: update in place
+    return trackDown(undefined, '', path);
+};
+const lookup = (tree, key) => {
+    if (key.length === 0 || tree == null) {
+        return tree;
+    }
+    for (const k of tree.keys()) {
+        if (k !== LEAF && key.startsWith(k)) {
+            return lookup(tree.get(k), key.slice(k.length));
+        }
+    }
+};
+// Create a path in the radix tree for the given key, and returns the deepest
+// node. This function is in the hot path for indexing. It avoids unnecessary
+// string operations and recursion for performance.
+const createPath = (node, key) => {
+    const keyLength = key.length;
+    outer: for (let pos = 0; node && pos < keyLength;) {
+        for (const k of node.keys()) {
+            // Check whether this key is a candidate: the first characters must match.
+            if (k !== LEAF && key[pos] === k[0]) {
+                const len = Math.min(keyLength - pos, k.length);
+                // Advance offset to the point where key and k no longer match.
+                let offset = 1;
+                while (offset < len && key[pos + offset] === k[offset])
+                    ++offset;
+                const child = node.get(k);
+                if (offset === k.length) {
+                    // The existing key is shorter than the key we need to create.
+                    node = child;
+                }
+                else {
+                    // Partial match: we need to insert an intermediate node to contain
+                    // both the existing subtree and the new node.
+                    const intermediate = new Map();
+                    intermediate.set(k.slice(offset), child);
+                    node.set(key.slice(pos, pos + offset), intermediate);
+                    node.delete(k);
+                    node = intermediate;
+                }
+                pos += offset;
+                continue outer;
+            }
+        }
+        // Create a final child node to contain the final suffix of the key.
+        const child = new Map();
+        node.set(key.slice(pos), child);
+        return child;
+    }
+    return node;
+};
+const remove = (tree, key) => {
+    const [node, path] = trackDown(tree, key);
+    if (node === undefined) {
+        return;
+    }
+    node.delete(LEAF);
+    if (node.size === 0) {
+        cleanup(path);
+    }
+    else if (node.size === 1) {
+        const [key, value] = node.entries().next().value;
+        merge(path, key, value);
+    }
+};
+const cleanup = (path) => {
+    if (path.length === 0) {
+        return;
+    }
+    const [node, key] = last(path);
+    node.delete(key);
+    if (node.size === 0) {
+        cleanup(path.slice(0, -1));
+    }
+    else if (node.size === 1) {
+        const [key, value] = node.entries().next().value;
+        if (key !== LEAF) {
+            merge(path.slice(0, -1), key, value);
+        }
+    }
+};
+const merge = (path, key, value) => {
+    if (path.length === 0) {
+        return;
+    }
+    const [node, nodeKey] = last(path);
+    node.set(nodeKey + key, value);
+    node.delete(nodeKey);
+};
+const last = (array) => {
+    return array[array.length - 1];
+};
+
+const OR = 'or';
+const AND = 'and';
+const AND_NOT = 'and_not';
+const defaultBM25params = { k: 1.2, b: 0.7, d: 0.5 };
+const calcBM25Score = (termFreq, matchingCount, totalCount, fieldLength, avgFieldLength, bm25params) => {
+    const { k, b, d } = bm25params;
+    const invDocFreq = Math.log(1 + (totalCount - matchingCount + 0.5) / (matchingCount + 0.5));
+    return invDocFreq * (d + termFreq * (k + 1) / (termFreq + k * (1 - b + b * fieldLength / avgFieldLength)));
+};
+const getOwnProperty = (object, property) => Object.prototype.hasOwnProperty.call(object, property) ? object[property] : undefined;
+const assignUniqueTerm = (target, term) => {
+    if (!target.includes(term))
+        target.push(term);
+};
+const assignUniqueTerms = (target, source) => {
+    for (const term of source) {
+        if (!target.includes(term))
+            target.push(term);
+    }
+};
+const byScore = ({ score: a }, { score: b }) => b - a;
+/** Wrap Map<shortId, freq> as PostingListLike */
+function mapPostingList(freqs) {
+    return {
+        get size() { return freqs.size; },
+        forEachDoc(callback) {
+            for (const [docId, termFreq] of freqs) {
+                callback(docId, termFreq);
+            }
+        }
+    };
+}
+/** Wrap Map<fieldId, Map<shortId, freq>> as FieldTermDataLike */
+function mapFieldTermData(data) {
+    return {
+        get(fieldId) {
+            const freqs = data.get(fieldId);
+            return freqs == null ? undefined : mapPostingList(freqs);
+        }
+    };
+}
+function aggregateTerm(sourceTerm, derivedTerm, termWeight, termBoost, fieldTermData, fieldBoosts, context, boostDocumentFn, bm25params, results = new Map()) {
+    if (fieldTermData == null)
+        return results;
+    for (const field of Object.keys(fieldBoosts)) {
+        const fieldBoost = fieldBoosts[field];
+        const fieldId = context.fieldIds[field];
+        const postingList = fieldTermData.get(fieldId);
+        if (postingList == null)
+            continue;
+        let matchingFields = postingList.size;
+        const avgFieldLength = context.avgFieldLength[fieldId];
+        postingList.forEachDoc((docId, termFreq) => {
+            var _a;
+            if (context.isDocActive != null && !context.isDocActive(docId)) {
+                (_a = context.onInactiveDoc) === null || _a === void 0 ? void 0 : _a.call(context, docId, fieldId, derivedTerm);
+                matchingFields -= 1;
+                return;
+            }
+            const docBoost = boostDocumentFn
+                ? boostDocumentFn(context.getExternalId(docId), derivedTerm, context.getStoredFields(docId))
+                : 1;
+            if (!docBoost)
+                return;
+            const fieldLength = context.getFieldLength(docId, fieldId);
+            const rawScore = calcBM25Score(termFreq, matchingFields, context.documentCount, fieldLength, avgFieldLength, bm25params);
+            const weightedScore = termWeight * termBoost * fieldBoost * docBoost * rawScore;
+            const result = results.get(docId);
+            if (result) {
+                result.score += weightedScore;
+                assignUniqueTerm(result.terms, sourceTerm);
+                const match = getOwnProperty(result.match, derivedTerm);
+                if (match) {
+                    match.push(field);
+                }
+                else {
+                    result.match[derivedTerm] = [field];
+                }
+            }
+            else {
+                results.set(docId, {
+                    score: weightedScore,
+                    terms: [sourceTerm],
+                    match: { [derivedTerm]: [field] }
+                });
+            }
+        });
+    }
+    return results;
+}
+const combinators = {
+    [OR]: (a, b) => {
+        for (const docId of b.keys()) {
+            const existing = a.get(docId);
+            if (existing == null) {
+                a.set(docId, b.get(docId));
+            }
+            else {
+                const { score, terms, match } = b.get(docId);
+                existing.score = existing.score + score;
+                existing.match = Object.assign(existing.match, match);
+                assignUniqueTerms(existing.terms, terms);
+            }
+        }
+        return a;
+    },
+    [AND]: (a, b) => {
+        const combined = new Map();
+        for (const docId of b.keys()) {
+            const existing = a.get(docId);
+            if (existing == null)
+                continue;
+            const { score, terms, match } = b.get(docId);
+            assignUniqueTerms(existing.terms, terms);
+            combined.set(docId, {
+                score: existing.score + score,
+                terms: existing.terms,
+                match: Object.assign(existing.match, match)
+            });
+        }
+        return combined;
+    },
+    [AND_NOT]: (a, b) => {
+        for (const docId of b.keys())
+            a.delete(docId);
+        return a;
+    }
+};
+function combineResults(results, combineWith = OR) {
+    if (results.length === 0)
+        return new Map();
+    const operator = combineWith.toLowerCase();
+    const combinator = combinators[operator];
+    if (!combinator) {
+        throw new Error(`Invalid combination operator: ${combineWith}`);
+    }
+    return results.reduce(combinator) || new Map();
+}
+function finalizeSearchResults(params) {
+    const { rawResults, getExternalId, getStoredFields, filter, skipSort } = params;
+    const results = [];
+    for (const [docId, { score, terms, match }] of rawResults) {
+        const quality = terms.length || 1;
+        const result = {
+            id: getExternalId(docId),
+            score: score * quality,
+            terms: Object.keys(match),
+            queryTerms: terms,
+            match
+        };
+        Object.assign(result, getStoredFields(docId));
+        if (filter == null || filter(result)) {
+            results.push(result);
+        }
+    }
+    if (!skipSort) {
+        results.sort(byScore);
+    }
+    return results;
+}
+const termToQuerySpec = (options) => (term, i, terms) => {
+    const fuzzy = (typeof options.fuzzy === 'function')
+        ? options.fuzzy(term, i, terms)
+        : (options.fuzzy || false);
+    const prefix = (typeof options.prefix === 'function')
+        ? options.prefix(term, i, terms)
+        : (options.prefix === true);
+    const termBoost = (typeof options.boostTerm === 'function')
+        ? options.boostTerm(term, i, terms)
+        : 1;
+    return { term, fuzzy, prefix, termBoost };
+};
+
+const MAX_FREQ_UINT8 = 255;
+/** View into global flat posting buffers (no per-list allocation). */
+class SegmentPostingList {
+    constructor(docIds, freqs, offset, length) {
+        this._docIds = docIds;
+        this._freqs = freqs;
+        this._offset = offset;
+        this._length = length;
+    }
+    get size() {
+        return this._length;
+    }
+    forEachDoc(callback) {
+        const { _docIds, _freqs, _offset, _length } = this;
+        for (let i = 0; i < _length; i++) {
+            callback(_docIds[_offset + i], _freqs[_offset + i]);
+        }
+    }
+}
+/**
+ * Clamp term frequency to Uint8 for flat storage.
+ * This intentionally caps tf at 255 in frozen indexes; see benchmark scenario
+ * \"overflow frequencies\" to quantify the score drift for very large tf values.
+ */
+function clampFreq(freq) {
+    return freq > MAX_FREQ_UINT8 ? MAX_FREQ_UINT8 : freq;
+}
+function flatFieldTermData(termIndex, fieldCount, postingsOffsets, postingsLengths, allDocIds, allFreqs) {
+    const base = termIndex * fieldCount;
+    return {
+        get(fieldId) {
+            const len = postingsLengths[base + fieldId];
+            if (len === 0)
+                return undefined;
+            const off = postingsOffsets[base + fieldId];
+            return new SegmentPostingList(allDocIds, allFreqs, off, len);
+        }
+    };
+}
+
+/** Unicode space, newline, or punctuation — used by the default tokenizer */
+const SPACE_OR_PUNCTUATION = /[\n\r\p{Z}\p{P}]+/u;
+const defaultSearchOptions = {
+    combineWith: OR,
+    prefix: false,
+    fuzzy: false,
+    maxFuzzy: 6,
+    boost: {},
+    weights: { fuzzy: 0.45, prefix: 0.375 },
+    bm25: defaultBM25params
+};
+const defaultAutoSuggestOptions = {
+    combineWith: AND,
+    prefix: (term, i, terms) => i === terms.length - 1
+};
+/** Option defaults applied by {@link FrozenMiniSearch.loadBinary} before caller overrides */
+const defaultFrozenLoadOptions = {
+    idField: 'id',
+    extractField: (document, fieldName) => document[fieldName],
+    stringifyField: (fieldValue) => fieldValue.toString(),
+    tokenize: (text) => text.split(SPACE_OR_PUNCTUATION),
+    processTerm: (term) => term.toLowerCase(),
+    storeFields: [],
+    logger: () => { },
+    autoVacuum: false
+};
+
+const BINARY_MAGIC_V1 = 'MSv1';
+const BINARY_VERSION_V1 = 1;
+const BINARY_MAGIC_V2 = 'MSv2';
+const BINARY_VERSION_V2 = 2;
+const HEADER_SIZE_V2 = 48;
+const FREQ_UINT8 = 0;
+const FREQ_UINT16 = 1;
+function copyView(view) {
+    return Buffer.from(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+}
+function alignedSlice(buf, offset, length, alignment) {
+    if (length === 0)
+        return Buffer.alloc(0);
+    if (offset % alignment === 0) {
+        return buf.subarray(offset, offset + length);
+    }
+    return buf.subarray(offset, offset + length);
+}
+function readUint32Array(buf, offset, byteLength) {
+    if (byteLength === 0)
+        return new Uint32Array(0);
+    const slice = alignedSlice(buf, offset, byteLength, 4);
+    if (slice.byteOffset % 4 === 0 && slice.length === byteLength) {
+        return new Uint32Array(slice.buffer, slice.byteOffset, byteLength / 4);
+    }
+    const out = new Uint32Array(byteLength / 4);
+    for (let i = 0; i < out.length; i++)
+        out[i] = buf.readUInt32LE(offset + i * 4);
+    return out;
+}
+function readUint8Array(buf, offset, byteLength) {
+    if (byteLength === 0)
+        return new Uint8Array(0);
+    const slice = alignedSlice(buf, offset, byteLength, 1);
+    return new Uint8Array(slice.buffer, slice.byteOffset, byteLength);
+}
+function readFloat32Array(buf, offset, byteLength) {
+    if (byteLength === 0)
+        return new Float32Array(0);
+    const slice = alignedSlice(buf, offset, byteLength, 4);
+    if (slice.byteOffset % 4 === 0 && slice.length === byteLength) {
+        return new Float32Array(slice.buffer, slice.byteOffset, byteLength / 4);
+    }
+    const out = new Float32Array(byteLength / 4);
+    for (let i = 0; i < out.length; i++)
+        out[i] = buf.readFloatLE(offset + i * 4);
+    return out;
+}
+function encodeFrozenSnapshot(snap) {
+    const metaJson = Buffer.from(JSON.stringify({
+        documentCount: snap.documentCount,
+        nextId: snap.nextId,
+        fieldCount: snap.fieldCount,
+        fieldIds: snap.fieldIds,
+        externalIds: snap.externalIds,
+        storedFields: snap.storedFields,
+        treeShape: snap.treeShape
+    }), 'utf8');
+    const avgBuf = copyView(snap.avgFieldLength);
+    const flBuf = copyView(snap.fieldLengthMatrix);
+    const termBufs = snap.terms.map((term) => Buffer.from(term, 'utf8'));
+    const dictHeader = Buffer.alloc(4 + snap.terms.length * 4);
+    dictHeader.writeUInt32LE(snap.terms.length, 0);
+    for (let i = 0; i < termBufs.length; i++) {
+        dictHeader.writeUInt32LE(termBufs[i].length, 4 + i * 4);
+    }
+    const dict = Buffer.concat([dictHeader, ...termBufs]);
+    const offBuf = copyView(snap.postingsOffsets);
+    const lenBuf = copyView(snap.postingsLengths);
+    const docBuf = copyView(snap.allDocIds);
+    const freqBuf = copyView(snap.allFreqs);
+    const sections = [metaJson, avgBuf, flBuf, dict, offBuf, lenBuf, docBuf, freqBuf];
+    const header = Buffer.alloc(HEADER_SIZE_V2);
+    header.write(BINARY_MAGIC_V2, 0, 4, 'ascii');
+    header.writeUInt16LE(BINARY_VERSION_V2, 4);
+    header.writeUInt16LE(0, 6);
+    let off = HEADER_SIZE_V2;
+    for (let i = 0; i < sections.length; i++) {
+        header.writeUInt32LE(off, 8 + i * 4);
+        off += sections[i].length;
+    }
+    header.writeUInt32LE(off, 8 + sections.length * 4);
+    return Buffer.concat([header, ...sections]);
+}
+function decodeMSv2(buf) {
+    const metaOff = buf.readUInt32LE(8);
+    const avgOff = buf.readUInt32LE(12);
+    const flOff = buf.readUInt32LE(16);
+    const dictOff = buf.readUInt32LE(20);
+    const postOffOff = buf.readUInt32LE(24);
+    const postLenOff = buf.readUInt32LE(28);
+    const docIdsOff = buf.readUInt32LE(32);
+    const freqsOff = buf.readUInt32LE(36);
+    const endOff = buf.readUInt32LE(40);
+    const meta = JSON.parse(buf.toString('utf8', metaOff, avgOff));
+    const avgFieldLength = readFloat32Array(buf, avgOff, flOff - avgOff);
+    const fieldLengthMatrix = readUint32Array(buf, flOff, dictOff - flOff);
+    const termCount = buf.readUInt32LE(dictOff);
+    const terms = [];
+    let o = dictOff + 4 + termCount * 4;
+    for (let i = 0; i < termCount; i++) {
+        const len = buf.readUInt32LE(dictOff + 4 + i * 4);
+        terms.push(buf.toString('utf8', o, o + len));
+        o += len;
+    }
+    const slotCount = termCount * meta.fieldCount;
+    const postingsOffsets = readUint32Array(buf, postOffOff, slotCount * 4);
+    const postingsLengths = readUint32Array(buf, postLenOff, slotCount * 4);
+    const allDocIds = readUint32Array(buf, docIdsOff, freqsOff - docIdsOff);
+    const allFreqs = readUint8Array(buf, freqsOff, endOff - freqsOff);
+    return {
+        documentCount: meta.documentCount,
+        nextId: meta.nextId,
+        fieldIds: meta.fieldIds,
+        fieldCount: meta.fieldCount,
+        avgFieldLength,
+        externalIds: meta.externalIds,
+        storedFields: meta.storedFields,
+        fieldLengthMatrix,
+        terms,
+        treeShape: meta.treeShape,
+        postingsOffsets,
+        postingsLengths,
+        allDocIds,
+        allFreqs
+    };
+}
+function decodeMSv1(buf) {
+    const metaOff = buf.readUInt32LE(8);
+    const avgOff = buf.readUInt32LE(12);
+    const flOff = buf.readUInt32LE(16);
+    const dictOff = buf.readUInt32LE(20);
+    const postOff = buf.readUInt32LE(24);
+    const meta = JSON.parse(buf.toString('utf8', metaOff, avgOff));
+    const avgFieldLength = readFloat32Array(buf, avgOff, flOff - avgOff);
+    const fieldLengthMatrix = readUint32Array(buf, flOff, dictOff - flOff);
+    const termCount = buf.readUInt32LE(dictOff);
+    const terms = [];
+    let o = dictOff + 4 + termCount * 4;
+    for (let i = 0; i < termCount; i++) {
+        const len = buf.readUInt32LE(dictOff + 4 + i * 4);
+        terms.push(buf.toString('utf8', o, o + len));
+        o += len;
+    }
+    const fieldCount = meta.fieldCount;
+    const slotCount = termCount * fieldCount;
+    const postingsOffsets = new Uint32Array(slotCount);
+    const postingsLengths = new Uint32Array(slotCount);
+    const docIdChunks = [];
+    const freqChunks = [];
+    o = postOff;
+    for (let ti = 0; ti < termCount; ti++) {
+        const fc = buf.readUInt16LE(o);
+        o += 2;
+        const base = ti * fieldCount;
+        for (let f = 0; f < fc; f++) {
+            buf.readUInt32LE(o);
+            o += 4; // matchCount — same as docLen
+            const docLen = buf.readUInt32LE(o);
+            o += 4;
+            postingsLengths[base + f] = docLen;
+            if (docLen === 0) {
+                postingsOffsets[base + f] = 0;
+                o += 1;
+                continue;
+            }
+            postingsOffsets[base + f] = docIdChunks.length;
+            const kind = buf.readUInt8(o);
+            o += 1;
+            for (let d = 0; d < docLen; d++) {
+                docIdChunks.push(buf.readUInt32LE(o + d * 4));
+            }
+            o += docLen * 4;
+            const freqElem = kind === FREQ_UINT8 ? 1 : kind === FREQ_UINT16 ? 2 : 4;
+            for (let d = 0; d < docLen; d++) {
+                let freq;
+                if (kind === FREQ_UINT8)
+                    freq = buf.readUInt8(o + d);
+                else if (kind === FREQ_UINT16)
+                    freq = buf.readUInt16LE(o + d * 2);
+                else
+                    freq = buf.readUInt32LE(o + d * 4);
+                freqChunks.push(freq > 255 ? 255 : freq);
+            }
+            o += docLen * freqElem;
+        }
+    }
+    return {
+        documentCount: meta.documentCount,
+        nextId: meta.nextId,
+        fieldIds: meta.fieldIds,
+        fieldCount,
+        avgFieldLength,
+        externalIds: meta.externalIds,
+        storedFields: meta.storedFields,
+        fieldLengthMatrix,
+        terms,
+        treeShape: meta.treeShape,
+        postingsOffsets,
+        postingsLengths,
+        allDocIds: new Uint32Array(docIdChunks),
+        allFreqs: new Uint8Array(freqChunks)
+    };
+}
+function decodeFrozenSnapshot(buf) {
+    const magic = buf.toString('ascii', 0, 4);
+    const version = buf.readUInt16LE(4);
+    if (magic === BINARY_MAGIC_V2 && version === BINARY_VERSION_V2) {
+        return decodeMSv2(buf);
+    }
+    if (magic === BINARY_MAGIC_V1 && version === BINARY_VERSION_V1) {
+        return decodeMSv1(buf);
+    }
+    throw new Error(`Invalid frozen index: magic=${magic} version=${version}`);
+}
+function deserializeTermIndexTree(shape) {
+    const tree = new Map();
+    for (const [key, value] of shape) {
+        if (key === LEAF) {
+            tree.set(LEAF, value);
+        }
+        else {
+            tree.set(key, deserializeTermIndexTree(value));
+        }
+    }
+    return tree;
+}
+function serializeTermIndexTree(tree) {
+    const shape = [];
+    for (const [key, val] of tree) {
+        if (key === LEAF) {
+            shape.push([key, val]);
+        }
+        else {
+            shape.push([key, serializeTermIndexTree(val)]);
+        }
+    }
+    return shape;
+}
+
+function resolveIndexingOptions(options) {
+    if ((options === null || options === void 0 ? void 0 : options.fields) == null) {
+        throw new Error('MiniSearch: option "fields" must be provided');
+    }
+    return {
+        ...defaultFrozenLoadOptions,
+        ...options,
+        searchOptions: { ...defaultSearchOptions, ...(options.searchOptions || {}) },
+        autoSuggestOptions: { ...defaultAutoSuggestOptions, ...(options.autoSuggestOptions || {}) }
+    };
+}
+function buildFieldIds(fields) {
+    const fieldIds = {};
+    for (let i = 0; i < fields.length; i++) {
+        fieldIds[fields[i]] = i;
+    }
+    return fieldIds;
+}
+/** Token frequencies for one document field (after processTerm). */
+function collectFieldTermFreqs(tokens, fieldName, processTerm) {
+    const localFreqs = new Map();
+    for (const term of tokens) {
+        const processedTerm = processTerm(term, fieldName);
+        if (Array.isArray(processedTerm)) {
+            for (const t of processedTerm) {
+                localFreqs.set(t, (localFreqs.get(t) || 0) + 1);
+            }
+        }
+        else if (processedTerm) {
+            localFreqs.set(processedTerm, (localFreqs.get(processedTerm) || 0) + 1);
+        }
+    }
+    return localFreqs;
+}
+/** Same running average as {@link MiniSearch} private addFieldLength. */
+function updateAvgFieldLength(avgFieldLength, fieldId, count, length) {
+    const averageFieldLength = avgFieldLength[fieldId] || 0;
+    const totalFieldLength = (averageFieldLength * count) + length;
+    avgFieldLength[fieldId] = totalFieldLength / (count + 1);
+}
+function saveStoredFieldsForDocument(storeFields, extractField, document) {
+    if (storeFields.length === 0)
+        return undefined;
+    const documentFields = {};
+    for (const fieldName of storeFields) {
+        const fieldValue = extractField(document, fieldName);
+        if (fieldValue !== undefined)
+            documentFields[fieldName] = fieldValue;
+    }
+    return documentFields;
+}
+
+function getOrCreateTermIndex(builder, term) {
+    const existing = builder.index.get(term);
+    if (existing != null)
+        return existing;
+    const ti = builder.terms.length;
+    builder.terms.push(term);
+    builder.index.set(term, ti);
+    return ti;
+}
+function appendPosting(builder, termIndex, fieldId, docId, freq) {
+    const slot = termIndex * builder.fieldCount + fieldId;
+    let docIds = builder.postingsDocIds[slot];
+    let freqs = builder.postingsFreqs[slot];
+    if (docIds == null) {
+        docIds = [];
+        freqs = [];
+        builder.postingsDocIds[slot] = docIds;
+        builder.postingsFreqs[slot] = freqs;
+    }
+    docIds.push(docId);
+    freqs.push(clampFreq(freq));
+}
+function finalizeFlatPostings(builder) {
+    const termCount = builder.terms.length;
+    const slotCount = termCount * builder.fieldCount;
+    const postingsOffsets = new Uint32Array(slotCount);
+    const postingsLengths = new Uint32Array(slotCount);
+    const docScratch = [];
+    const freqScratch = [];
+    for (let ti = 0; ti < termCount; ti++) {
+        const base = ti * builder.fieldCount;
+        for (let f = 0; f < builder.fieldCount; f++) {
+            const offset = docScratch.length;
+            const docIds = builder.postingsDocIds[base + f];
+            const freqs = builder.postingsFreqs[base + f];
+            if (docIds == null || docIds.length === 0) {
+                postingsOffsets[base + f] = offset;
+                postingsLengths[base + f] = 0;
+                continue;
+            }
+            for (let i = 0; i < docIds.length; i++) {
+                docScratch.push(docIds[i]);
+                freqScratch.push(freqs[i]);
+            }
+            postingsOffsets[base + f] = offset;
+            postingsLengths[base + f] = docIds.length;
+        }
+    }
+    return {
+        postingsOffsets,
+        postingsLengths,
+        allDocIds: new Uint32Array(docScratch),
+        allFreqs: new Uint8Array(freqScratch)
+    };
+}
+function indexDocument(builder, document, shortId) {
+    const { extractField, stringifyField, tokenize, processTerm, fields, idField, storeFields } = builder.options;
+    const id = extractField(document, idField);
+    if (id == null) {
+        throw new Error(`MiniSearch: document does not have ID field "${idField}"`);
+    }
+    if (builder.idToShortId.has(id)) {
+        throw new Error(`MiniSearch: duplicate ID ${id}`);
+    }
+    builder.idToShortId.set(id, shortId);
+    builder.externalIds[shortId] = id;
+    builder.storedFields[shortId] = saveStoredFieldsForDocument(storeFields, extractField, document);
+    const documentCount = shortId + 1;
+    for (const field of fields) {
+        const fieldValue = extractField(document, field);
+        if (fieldValue == null)
+            continue;
+        const tokens = tokenize(stringifyField(fieldValue, field), field);
+        const fieldId = builder.fieldIds[field];
+        const uniqueTerms = new Set(tokens).size;
+        const localFreqs = collectFieldTermFreqs(tokens, field, processTerm);
+        builder.fieldLengthMatrix[shortId * builder.fieldCount + fieldId] = uniqueTerms;
+        updateAvgFieldLength(builder.avgFieldLength, fieldId, documentCount - 1, uniqueTerms);
+        for (const [term, freq] of localFreqs) {
+            const ti = getOrCreateTermIndex(builder, term);
+            appendPosting(builder, ti, fieldId, shortId, freq);
+        }
+    }
+}
+function createBuilder(options, documentCount) {
+    const fieldCount = options.fields.length;
+    return {
+        options,
+        fieldIds: buildFieldIds(options.fields),
+        fieldCount,
+        documentCount,
+        index: new SearchableMap(),
+        terms: [],
+        postingsDocIds: [],
+        postingsFreqs: [],
+        externalIds: new Array(documentCount),
+        idToShortId: new Map(),
+        storedFields: new Array(documentCount),
+        fieldLengthMatrix: new Uint32Array(documentCount * fieldCount),
+        avgFieldLength: []
+    };
+}
+function buildFrozenParamsFromDocuments(documents, options) {
+    var _a;
+    const resolved = resolveIndexingOptions(options);
+    const documentCount = documents.length;
+    const builder = createBuilder(resolved, documentCount);
+    for (let d = 0; d < documentCount; d++) {
+        indexDocument(builder, documents[d], d);
+    }
+    const flat = finalizeFlatPostings(builder);
+    const avgFieldLength = new Float32Array(builder.fieldCount);
+    for (let f = 0; f < builder.fieldCount; f++) {
+        avgFieldLength[f] = (_a = builder.avgFieldLength[f]) !== null && _a !== void 0 ? _a : 0;
+    }
+    return {
+        options: resolved,
+        documentCount,
+        nextId: documentCount,
+        fieldIds: builder.fieldIds,
+        fieldCount: builder.fieldCount,
+        externalIds: builder.externalIds,
+        idToShortId: builder.idToShortId,
+        storedFields: builder.storedFields,
+        fieldLengthMatrix: builder.fieldLengthMatrix,
+        avgFieldLength,
+        index: builder.index,
+        terms: builder.terms,
+        postingsOffsets: flat.postingsOffsets,
+        postingsLengths: flat.postingsLengths,
+        allDocIds: flat.allDocIds,
+        allFreqs: flat.allFreqs
+    };
+}
+
+/** Shared wildcard query symbol for MiniSearch and FrozenMiniSearch */
+const WILDCARD_QUERY = Symbol('*');
+
+const READ_ONLY_MSG = 'FrozenMiniSearch is read-only. Rebuild from a mutable MiniSearch instance.';
+const MAP_NODE_ESTIMATE_BYTES = 120;
+function throwReadOnly() {
+    throw new Error(READ_ONLY_MSG);
+}
+function cloneRadixTreeWithTermIndex(tree, termIndexByLeaf) {
+    const out = new Map();
+    for (const [key, val] of tree) {
+        if (key === LEAF) {
+            const idx = termIndexByLeaf.get(val);
+            if (idx == null) {
+                throw new Error('FrozenMiniSearch: missing term index while cloning tree');
+            }
+            out.set(LEAF, idx);
+        }
+        else {
+            out.set(key, cloneRadixTreeWithTermIndex(val, termIndexByLeaf));
+        }
+    }
+    return out;
+}
+function countRadixMapNodes(tree) {
+    let n = 1;
+    for (const [key, val] of tree) {
+        if (key !== LEAF)
+            n += countRadixMapNodes(val);
+    }
+    return n;
+}
+function frozenMemoryBreakdown(frozen) {
+    return frozen.memoryBreakdown();
+}
+/** Instantiate {@link FrozenMiniSearch} from pre-built flat index parts. */
+function assembleFrozen(params) {
+    return new FrozenMiniSearch(params);
+}
+function buildFlatPostingsFromSource(source, fieldCount, shortIdRemap) {
+    const terms = [];
+    const leafToIndex = new WeakMap();
+    for (const [term, fieldIndex] of source._index) {
+        const ti = terms.length;
+        terms.push(term);
+        leafToIndex.set(fieldIndex, ti);
+    }
+    const termCount = terms.length;
+    const slotCount = termCount * fieldCount;
+    const postingsOffsets = new Uint32Array(slotCount);
+    const postingsLengths = new Uint32Array(slotCount);
+    const docScratch = [];
+    const freqScratch = [];
+    for (const [, fieldIndex] of source._index) {
+        const ti = leafToIndex.get(fieldIndex);
+        const base = ti * fieldCount;
+        for (let f = 0; f < fieldCount; f++) {
+            const offset = docScratch.length;
+            const freqs = fieldIndex.get(f);
+            if (freqs == null || freqs.size === 0) {
+                postingsOffsets[base + f] = offset;
+                postingsLengths[base + f] = 0;
+                continue;
+            }
+            let count = 0;
+            for (const [shortId, freq] of freqs) {
+                const docId = shortIdRemap != null ? shortIdRemap[shortId] : shortId;
+                // Skip discarded docs when dense remapping is enabled. This prevents
+                // invalid docIds (no externalId) from leaking into frozen search results.
+                if (docId === 0xffffffff)
+                    continue;
+                docScratch.push(docId);
+                freqScratch.push(clampFreq(freq));
+                count++;
+            }
+            postingsOffsets[base + f] = offset;
+            postingsLengths[base + f] = count;
+        }
+    }
+    const allDocIds = new Uint32Array(docScratch);
+    const allFreqs = new Uint8Array(freqScratch);
+    const tree = cloneRadixTreeWithTermIndex(source._index.radixTree, leafToIndex);
+    return { terms, tree, postingsOffsets, postingsLengths, allDocIds, allFreqs };
+}
+function freezeFromMiniSearch(source) {
+    var _a;
+    const fieldCount = source._options.fields.length;
+    const { _documentCount, _nextId } = source;
+    const useDense = _documentCount < _nextId;
+    let shortIdRemap = null;
+    const externalIds = new Array(useDense ? _documentCount : _nextId);
+    const storedFields = new Array(externalIds.length);
+    const idToShortId = new Map();
+    if (useDense) {
+        shortIdRemap = new Uint32Array(_nextId);
+        shortIdRemap.fill(0xffffffff);
+        let dense = 0;
+        for (const [shortId, id] of source._documentIds) {
+            shortIdRemap[shortId] = dense;
+            externalIds[dense] = id;
+            idToShortId.set(id, dense);
+            storedFields[dense] = source._storedFields.get(shortId);
+            dense++;
+        }
+    }
+    else {
+        for (const [shortId, id] of source._documentIds) {
+            externalIds[shortId] = id;
+            idToShortId.set(id, shortId);
+            storedFields[shortId] = source._storedFields.get(shortId);
+        }
+    }
+    const matrixRows = useDense ? _documentCount : _nextId;
+    const fieldLengthMatrix = new Uint32Array(matrixRows * fieldCount);
+    for (const [shortId, lengths] of source._fieldLength) {
+        const row = shortIdRemap != null ? shortIdRemap[shortId] : shortId;
+        if (row === 0xffffffff)
+            continue;
+        for (let f = 0; f < fieldCount; f++) {
+            fieldLengthMatrix[row * fieldCount + f] = (_a = lengths[f]) !== null && _a !== void 0 ? _a : 0;
+        }
+    }
+    const avgFieldLength = new Float32Array(source._avgFieldLength.length);
+    for (let i = 0; i < source._avgFieldLength.length; i++) {
+        avgFieldLength[i] = source._avgFieldLength[i];
+    }
+    const flat = buildFlatPostingsFromSource(source, fieldCount, shortIdRemap);
+    const frozenIndex = new SearchableMap(flat.tree);
+    return assembleFrozen({
+        options: source._options,
+        documentCount: _documentCount,
+        nextId: useDense ? _documentCount : _nextId,
+        fieldIds: source._fieldIds,
+        fieldCount,
+        externalIds,
+        idToShortId,
+        storedFields,
+        fieldLengthMatrix,
+        avgFieldLength,
+        index: frozenIndex,
+        terms: flat.terms,
+        postingsOffsets: flat.postingsOffsets,
+        postingsLengths: flat.postingsLengths,
+        allDocIds: flat.allDocIds,
+        allFreqs: flat.allFreqs
+    });
+}
+function buildFrozenFromDocuments(documents, options) {
+    return assembleFrozen(buildFrozenParamsFromDocuments(documents, options));
+}
+class FrozenMiniSearch {
+    constructor(params) {
+        this._options = params.options;
+        this._documentCount = params.documentCount;
+        this._nextId = params.nextId;
+        this._externalIds = params.externalIds;
+        this._idToShortId = params.idToShortId;
+        this._fieldIds = params.fieldIds;
+        this._fieldCount = params.fieldCount;
+        this._fieldLengthMatrix = params.fieldLengthMatrix;
+        this._avgFieldLength = params.avgFieldLength;
+        this._storedFields = params.storedFields;
+        this._index = params.index;
+        this._terms = params.terms;
+        this._postingsOffsets = params.postingsOffsets;
+        this._postingsLengths = params.postingsLengths;
+        this._allDocIds = params.allDocIds;
+        this._allFreqs = params.allFreqs;
+    }
+    get documentCount() { return this._documentCount; }
+    get termCount() { return this._index.size; }
+    memoryBreakdown() {
+        const termCount = this.termCount;
+        const slotCount = termCount * this._fieldCount;
+        const postingsTyped = this._allDocIds.byteLength + this._allFreqs.byteLength +
+            this._postingsOffsets.byteLength + this._postingsLengths.byteLength;
+        let storedJson = 0;
+        for (const row of this._storedFields) {
+            if (row != null)
+                storedJson += JSON.stringify(row).length;
+        }
+        const mapNodeCount = countRadixMapNodes(this._index.radixTree);
+        const radixEst = mapNodeCount * MAP_NODE_ESTIMATE_BYTES;
+        const estimatedStructuredBytes = postingsTyped +
+            this._fieldLengthMatrix.byteLength +
+            this._avgFieldLength.byteLength +
+            radixEst +
+            storedJson +
+            this._idToShortId.size * 32;
+        return {
+            termCount,
+            documentCount: this._documentCount,
+            nextId: this._nextId,
+            postings: {
+                slotCount,
+                allDocIdsBytes: this._allDocIds.byteLength,
+                allFreqsBytes: this._allFreqs.byteLength,
+                offsetsBytes: this._postingsOffsets.byteLength,
+                lengthsBytes: this._postingsLengths.byteLength,
+                totalTypedBytes: postingsTyped
+            },
+            radixTree: {
+                mapNodeCount,
+                estimatedBytes: radixEst
+            },
+            documents: {
+                externalIdsSlots: this._externalIds.length,
+                storedFieldsSlots: this._storedFields.length,
+                idToShortIdEntries: this._idToShortId.size,
+                fieldLengthMatrixBytes: this._fieldLengthMatrix.byteLength,
+                avgFieldLengthBytes: this._avgFieldLength.byteLength,
+                storedFieldsJsonBytes: storedJson
+            },
+            estimatedStructuredBytes
+        };
+    }
+    has(id) {
+        return this._idToShortId.has(id);
+    }
+    getStoredFields(id) {
+        const shortId = this._idToShortId.get(id);
+        return shortId == null ? undefined : this._storedFields[shortId];
+    }
+    add() { throwReadOnly(); }
+    addAll() { throwReadOnly(); }
+    addAllAsync() { throwReadOnly(); }
+    remove() { throwReadOnly(); }
+    removeAll() { throwReadOnly(); }
+    discard() { throwReadOnly(); }
+    discardAll() { throwReadOnly(); }
+    replace() { throwReadOnly(); }
+    vacuum() { throwReadOnly(); }
+    search(query, searchOptions = {}) {
+        const { searchOptions: globalSearchOptions } = this._options;
+        const searchOptionsWithDefaults = { ...globalSearchOptions, ...searchOptions };
+        const rawResults = this.executeQuery(query, searchOptions);
+        const skipSort = query === FrozenMiniSearch.wildcard && searchOptionsWithDefaults.boostDocument == null;
+        return finalizeSearchResults({
+            rawResults,
+            getExternalId: (docId) => this._externalIds[docId],
+            getStoredFields: (docId) => this._storedFields[docId],
+            filter: searchOptionsWithDefaults.filter,
+            skipSort
+        });
+    }
+    autoSuggest(queryString, options = {}) {
+        options = { ...this._options.autoSuggestOptions, ...options };
+        const suggestions = new Map();
+        for (const { score, terms } of this.search(queryString, options)) {
+            const phrase = terms.join(' ');
+            const suggestion = suggestions.get(phrase);
+            if (suggestion != null) {
+                suggestion.score += score;
+                suggestion.count += 1;
+            }
+            else {
+                suggestions.set(phrase, { score, terms, count: 1 });
+            }
+        }
+        return [...suggestions.entries()]
+            .map(([suggestion, { score, terms, count }]) => ({
+            suggestion,
+            terms,
+            score: score / count
+        }))
+            .sort((a, b) => b.score - a.score);
+    }
+    saveBinary() {
+        return encodeFrozenSnapshot({
+            documentCount: this._documentCount,
+            nextId: this._nextId,
+            fieldIds: this._fieldIds,
+            fieldCount: this._fieldCount,
+            avgFieldLength: this._avgFieldLength,
+            externalIds: this._externalIds,
+            storedFields: this._storedFields,
+            fieldLengthMatrix: this._fieldLengthMatrix,
+            terms: this._terms,
+            treeShape: serializeTermIndexTree(this._index.radixTree),
+            postingsOffsets: this._postingsOffsets,
+            postingsLengths: this._postingsLengths,
+            allDocIds: this._allDocIds,
+            allFreqs: this._allFreqs
+        });
+    }
+    static loadBinary(buffer, options) {
+        if ((options === null || options === void 0 ? void 0 : options.fields) == null) {
+            throw new Error('FrozenMiniSearch: option "fields" must be provided');
+        }
+        const snap = decodeFrozenSnapshot(buffer);
+        const fieldNames = options.fields;
+        for (const name of fieldNames) {
+            if (snap.fieldIds[name] === undefined) {
+                throw new Error(`FrozenMiniSearch: field "${name}" not found in frozen index`);
+            }
+        }
+        const opts = {
+            ...defaultFrozenLoadOptions,
+            ...options,
+            searchOptions: {
+                ...defaultSearchOptions,
+                ...(options.searchOptions || {})
+            },
+            autoSuggestOptions: { ...defaultAutoSuggestOptions, ...(options.autoSuggestOptions || {}) }
+        };
+        const index = new SearchableMap(deserializeTermIndexTree(snap.treeShape));
+        const idToShortId = new Map();
+        for (let i = 0; i < snap.externalIds.length; i++) {
+            if (snap.externalIds[i] !== undefined) {
+                idToShortId.set(snap.externalIds[i], i);
+            }
+        }
+        return assembleFrozen({
+            options: opts,
+            documentCount: snap.documentCount,
+            nextId: snap.nextId,
+            fieldIds: snap.fieldIds,
+            fieldCount: snap.fieldCount,
+            externalIds: snap.externalIds,
+            idToShortId,
+            storedFields: snap.storedFields,
+            fieldLengthMatrix: snap.fieldLengthMatrix,
+            avgFieldLength: snap.avgFieldLength,
+            index,
+            terms: snap.terms,
+            postingsOffsets: snap.postingsOffsets,
+            postingsLengths: snap.postingsLengths,
+            allDocIds: snap.allDocIds,
+            allFreqs: snap.allFreqs
+        });
+    }
+    /**
+     * Build a read-only index in one pass from documents (no mutable MiniSearch step).
+     *
+     * Use {@link MiniSearch} + {@link MiniSearch#freeze} when you need remove, discard, or
+     * incremental updates before freezing.
+     */
+    static fromDocuments(documents, options) {
+        return buildFrozenFromDocuments(documents, options);
+    }
+    getFieldLength(docId, fieldId) {
+        var _a;
+        return (_a = this._fieldLengthMatrix[docId * this._fieldCount + fieldId]) !== null && _a !== void 0 ? _a : 0;
+    }
+    fieldTermDataFor(termIndex) {
+        return flatFieldTermData(termIndex, this._fieldCount, this._postingsOffsets, this._postingsLengths, this._allDocIds, this._allFreqs);
+    }
+    aggregateContext() {
+        return {
+            documentCount: this._documentCount,
+            avgFieldLength: this._avgFieldLength,
+            fieldIds: this._fieldIds,
+            getFieldLength: (docId, fieldId) => this.getFieldLength(docId, fieldId),
+            getExternalId: (docId) => this._externalIds[docId],
+            getStoredFields: (docId) => this._storedFields[docId]
+        };
+    }
+    termResults(sourceTerm, derivedTerm, termWeight, termBoost, termIndex, fieldBoosts, boostDocumentFn, bm25params, results = new Map()) {
+        if (termIndex == null)
+            return results;
+        return aggregateTerm(sourceTerm, derivedTerm, termWeight, termBoost, this.fieldTermDataFor(termIndex), fieldBoosts, this.aggregateContext(), boostDocumentFn, bm25params, results);
+    }
+    executeQuery(query, searchOptions = {}) {
+        if (query === FrozenMiniSearch.wildcard) {
+            return this.executeWildcardQuery(searchOptions);
+        }
+        if (typeof query !== 'string') {
+            const options = { ...searchOptions, ...query, queries: undefined };
+            const results = query.queries.map((subquery) => this.executeQuery(subquery, options));
+            return combineResults(results, options.combineWith);
+        }
+        const { tokenize, processTerm, searchOptions: globalSearchOptions } = this._options;
+        const options = { tokenize, processTerm, ...globalSearchOptions, ...searchOptions };
+        const { tokenize: searchTokenize, processTerm: searchProcessTerm } = options;
+        const terms = searchTokenize(query)
+            .flatMap((term) => searchProcessTerm(term))
+            .filter((term) => !!term);
+        const queries = terms.map(termToQuerySpec(options));
+        const results = queries.map((q) => this.executeQuerySpec(q, options));
+        return combineResults(results, options.combineWith);
+    }
+    executeQuerySpec(query, searchOptions) {
+        var _a, _b;
+        const options = { ...this._options.searchOptions, ...searchOptions };
+        const boosts = (options.fields || this._options.fields).reduce((b, field) => ({ ...b, [field]: getOwnProperty(options.boost, field) || 1 }), {});
+        const { boostDocument, weights, maxFuzzy, bm25: bm25params } = options;
+        const fuzzyWeight = (_a = weights === null || weights === void 0 ? void 0 : weights.fuzzy) !== null && _a !== void 0 ? _a : 0.45;
+        const prefixWeight = (_b = weights === null || weights === void 0 ? void 0 : weights.prefix) !== null && _b !== void 0 ? _b : 0.375;
+        const termIndex = this._index.get(query.term);
+        const results = this.termResults(query.term, query.term, 1, query.termBoost, termIndex, boosts, boostDocument, bm25params);
+        let prefixMatches;
+        let fuzzyMatches;
+        if (query.prefix) {
+            prefixMatches = this._index.atPrefix(query.term);
+        }
+        if (query.fuzzy) {
+            const fuzzy = (query.fuzzy === true) ? 0.2 : query.fuzzy;
+            const maxDistance = fuzzy < 1
+                ? Math.min(maxFuzzy, Math.round(query.term.length * fuzzy))
+                : fuzzy;
+            if (maxDistance)
+                fuzzyMatches = this._index.fuzzyGet(query.term, maxDistance);
+        }
+        if (prefixMatches) {
+            for (const [term, ti] of prefixMatches) {
+                const distance = term.length - query.term.length;
+                if (!distance)
+                    continue;
+                fuzzyMatches === null || fuzzyMatches === void 0 ? void 0 : fuzzyMatches.delete(term);
+                const weight = prefixWeight * term.length / (term.length + 0.3 * distance);
+                this.termResults(query.term, term, weight, query.termBoost, ti, boosts, boostDocument, bm25params, results);
+            }
+        }
+        if (fuzzyMatches) {
+            for (const term of fuzzyMatches.keys()) {
+                const [ti, distance] = fuzzyMatches.get(term);
+                if (!distance)
+                    continue;
+                const weight = fuzzyWeight * term.length / (term.length + distance);
+                this.termResults(query.term, term, weight, query.termBoost, ti, boosts, boostDocument, bm25params, results);
+            }
+        }
+        return results;
+    }
+    executeWildcardQuery(searchOptions) {
+        const results = new Map();
+        const options = { ...this._options.searchOptions, ...searchOptions };
+        for (let shortId = 0; shortId < this._nextId; shortId++) {
+            const id = this._externalIds[shortId];
+            if (id === undefined)
+                continue;
+            const score = options.boostDocument
+                ? options.boostDocument(id, '', this._storedFields[shortId])
+                : 1;
+            results.set(shortId, { score, terms: [], match: {} });
+        }
+        return results;
+    }
+}
+FrozenMiniSearch.wildcard = WILDCARD_QUERY;
+
+/**
+ * {@link MiniSearch} is the main entrypoint class, implementing a full-text
+ * search engine in memory.
+ *
+ * @typeParam T  The type of the documents being indexed.
+ *
+ * ### Basic example:
+ *
+ * ```javascript
+ * const documents = [
+ *   {
+ *     id: 1,
+ *     title: 'Moby Dick',
+ *     text: 'Call me Ishmael. Some years ago...',
+ *     category: 'fiction'
+ *   },
+ *   {
+ *     id: 2,
+ *     title: 'Zen and the Art of Motorcycle Maintenance',
+ *     text: 'I can see by my watch...',
+ *     category: 'fiction'
+ *   },
+ *   {
+ *     id: 3,
+ *     title: 'Neuromancer',
+ *     text: 'The sky above the port was...',
+ *     category: 'fiction'
+ *   },
+ *   {
+ *     id: 4,
+ *     title: 'Zen and the Art of Archery',
+ *     text: 'At first sight it must seem...',
+ *     category: 'non-fiction'
+ *   },
+ *   // ...and more
+ * ]
+ *
+ * // Create a search engine that indexes the 'title' and 'text' fields for
+ * // full-text search. Search results will include 'title' and 'category' (plus the
+ * // id field, that is always stored and returned)
+ * const miniSearch = new MiniSearch({
+ *   fields: ['title', 'text'],
+ *   storeFields: ['title', 'category']
+ * })
+ *
+ * // Add documents to the index
+ * miniSearch.addAll(documents)
+ *
+ * // Search for documents:
+ * let results = miniSearch.search('zen art motorcycle')
+ * // => [
+ * //   { id: 2, title: 'Zen and the Art of Motorcycle Maintenance', category: 'fiction', score: 2.77258 },
+ * //   { id: 4, title: 'Zen and the Art of Archery', category: 'non-fiction', score: 1.38629 }
+ * // ]
+ * ```
+ */
+class MiniSearch {
+    /**
+     * @param options  Configuration options
+     *
+     * ### Examples:
+     *
+     * ```javascript
+     * // Create a search engine that indexes the 'title' and 'text' fields of your
+     * // documents:
+     * const miniSearch = new MiniSearch({ fields: ['title', 'text'] })
+     * ```
+     *
+     * ### ID Field:
+     *
+     * ```javascript
+     * // Your documents are assumed to include a unique 'id' field, but if you want
+     * // to use a different field for document identification, you can set the
+     * // 'idField' option:
+     * const miniSearch = new MiniSearch({ idField: 'key', fields: ['title', 'text'] })
+     * ```
+     *
+     * ### Options and defaults:
+     *
+     * ```javascript
+     * // The full set of options (here with their default value) is:
+     * const miniSearch = new MiniSearch({
+     *   // idField: field that uniquely identifies a document
+     *   idField: 'id',
+     *
+     *   // extractField: function used to get the value of a field in a document.
+     *   // By default, it assumes the document is a flat object with field names as
+     *   // property keys and field values as string property values, but custom logic
+     *   // can be implemented by setting this option to a custom extractor function.
+     *   extractField: (document, fieldName) => document[fieldName],
+     *
+     *   // tokenize: function used to split fields into individual terms. By
+     *   // default, it is also used to tokenize search queries, unless a specific
+     *   // `tokenize` search option is supplied. When tokenizing an indexed field,
+     *   // the field name is passed as the second argument.
+     *   tokenize: (string, _fieldName) => string.split(SPACE_OR_PUNCTUATION),
+     *
+     *   // processTerm: function used to process each tokenized term before
+     *   // indexing. It can be used for stemming and normalization. Return a falsy
+     *   // value in order to discard a term. By default, it is also used to process
+     *   // search queries, unless a specific `processTerm` option is supplied as a
+     *   // search option. When processing a term from a indexed field, the field
+     *   // name is passed as the second argument.
+     *   processTerm: (term, _fieldName) => term.toLowerCase(),
+     *
+     *   // searchOptions: default search options, see the `search` method for
+     *   // details
+     *   searchOptions: undefined,
+     *
+     *   // fields: document fields to be indexed. Mandatory, but not set by default
+     *   fields: undefined
+     *
+     *   // storeFields: document fields to be stored and returned as part of the
+     *   // search results.
+     *   storeFields: []
+     * })
+     * ```
+     */
+    constructor(options) {
+        if ((options === null || options === void 0 ? void 0 : options.fields) == null) {
+            throw new Error('MiniSearch: option "fields" must be provided');
+        }
+        const autoVacuum = (options.autoVacuum == null || options.autoVacuum === true) ? defaultAutoVacuumOptions : options.autoVacuum;
+        this._options = {
+            ...defaultOptions,
+            ...options,
+            autoVacuum,
+            searchOptions: { ...defaultSearchOptions, ...(options.searchOptions || {}) },
+            autoSuggestOptions: { ...defaultAutoSuggestOptions, ...(options.autoSuggestOptions || {}) }
+        };
+        this._index = new SearchableMap();
+        this._documentCount = 0;
+        this._documentIds = new Map();
+        this._idToShortId = new Map();
+        // Fields are defined during initialization, don't change, are few in
+        // number, rarely need iterating over, and have string keys. Therefore in
+        // this case an object is a better candidate than a Map to store the mapping
+        // from field key to ID.
+        this._fieldIds = {};
+        this._fieldLength = new Map();
+        this._avgFieldLength = [];
+        this._nextId = 0;
+        this._storedFields = new Map();
+        this._dirtCount = 0;
+        this._currentVacuum = null;
+        this._enqueuedVacuum = null;
+        this._enqueuedVacuumConditions = defaultVacuumConditions;
+        this.addFields(this._options.fields);
+    }
+    /**
+     * Adds a document to the index
+     *
+     * @param document  The document to be indexed
+     */
+    add(document) {
+        const { extractField, stringifyField, tokenize, processTerm, fields, idField } = this._options;
+        const id = extractField(document, idField);
+        if (id == null) {
+            throw new Error(`MiniSearch: document does not have ID field "${idField}"`);
+        }
+        if (this._idToShortId.has(id)) {
+            throw new Error(`MiniSearch: duplicate ID ${id}`);
+        }
+        const shortDocumentId = this.addDocumentId(id);
+        const stored = saveStoredFieldsForDocument(this._options.storeFields, extractField, document);
+        if (stored != null)
+            this._storedFields.set(shortDocumentId, stored);
+        for (const field of fields) {
+            const fieldValue = extractField(document, field);
+            if (fieldValue == null)
+                continue;
+            const tokens = tokenize(stringifyField(fieldValue, field), field);
+            const fieldId = this._fieldIds[field];
+            const uniqueTerms = new Set(tokens).size;
+            const localFreqs = collectFieldTermFreqs(tokens, field, processTerm);
+            this.addFieldLength(shortDocumentId, fieldId, this._documentCount - 1, uniqueTerms);
+            for (const [term] of localFreqs) {
+                const freq = localFreqs.get(term);
+                for (let i = 0; i < freq; i++) {
+                    this.addTerm(fieldId, shortDocumentId, term);
+                }
+            }
+        }
+    }
+    /**
+     * Adds all the given documents to the index
+     *
+     * @param documents  An array of documents to be indexed
+     */
+    addAll(documents) {
+        for (const document of documents)
+            this.add(document);
+    }
+    /**
+     * Adds all the given documents to the index asynchronously.
+     *
+     * Returns a promise that resolves (to `undefined`) when the indexing is done.
+     * This method is useful when index many documents, to avoid blocking the main
+     * thread. The indexing is performed asynchronously and in chunks.
+     *
+     * @param documents  An array of documents to be indexed
+     * @param options  Configuration options
+     * @return A promise resolving to `undefined` when the indexing is done
+     */
+    addAllAsync(documents, options = {}) {
+        const { chunkSize = 10 } = options;
+        const acc = { chunk: [], promise: Promise.resolve() };
+        const { chunk, promise } = documents.reduce(({ chunk, promise }, document, i) => {
+            chunk.push(document);
+            if ((i + 1) % chunkSize === 0) {
+                return {
+                    chunk: [],
+                    promise: promise
+                        .then(() => new Promise(resolve => setTimeout(resolve, 0)))
+                        .then(() => this.addAll(chunk))
+                };
+            }
+            else {
+                return { chunk, promise };
+            }
+        }, acc);
+        return promise.then(() => this.addAll(chunk));
+    }
+    /**
+     * Removes the given document from the index.
+     *
+     * The document to remove must NOT have changed between indexing and removal,
+     * otherwise the index will be corrupted.
+     *
+     * This method requires passing the full document to be removed (not just the
+     * ID), and immediately removes the document from the inverted index, allowing
+     * memory to be released. A convenient alternative is {@link
+     * MiniSearch#discard}, which needs only the document ID, and has the same
+     * visible effect, but delays cleaning up the index until the next vacuuming.
+     *
+     * @param document  The document to be removed
+     */
+    remove(document) {
+        const { tokenize, processTerm, extractField, stringifyField, fields, idField } = this._options;
+        const id = extractField(document, idField);
+        if (id == null) {
+            throw new Error(`MiniSearch: document does not have ID field "${idField}"`);
+        }
+        const shortId = this._idToShortId.get(id);
+        if (shortId == null) {
+            throw new Error(`MiniSearch: cannot remove document with ID ${id}: it is not in the index`);
+        }
+        for (const field of fields) {
+            const fieldValue = extractField(document, field);
+            if (fieldValue == null)
+                continue;
+            const tokens = tokenize(stringifyField(fieldValue, field), field);
+            const fieldId = this._fieldIds[field];
+            const uniqueTerms = new Set(tokens).size;
+            this.removeFieldLength(shortId, fieldId, this._documentCount, uniqueTerms);
+            for (const term of tokens) {
+                const processedTerm = processTerm(term, field);
+                if (Array.isArray(processedTerm)) {
+                    for (const t of processedTerm) {
+                        this.removeTerm(fieldId, shortId, t);
+                    }
+                }
+                else if (processedTerm) {
+                    this.removeTerm(fieldId, shortId, processedTerm);
+                }
+            }
+        }
+        this._storedFields.delete(shortId);
+        this._documentIds.delete(shortId);
+        this._idToShortId.delete(id);
+        this._fieldLength.delete(shortId);
+        this._documentCount -= 1;
+    }
+    /**
+     * Removes all the given documents from the index. If called with no arguments,
+     * it removes _all_ documents from the index.
+     *
+     * @param documents  The documents to be removed. If this argument is omitted,
+     * all documents are removed. Note that, for removing all documents, it is
+     * more efficient to call this method with no arguments than to pass all
+     * documents.
+     */
+    removeAll(documents) {
+        if (documents) {
+            for (const document of documents)
+                this.remove(document);
+        }
+        else if (arguments.length > 0) {
+            throw new Error('Expected documents to be present. Omit the argument to remove all documents.');
+        }
+        else {
+            this._index = new SearchableMap();
+            this._documentCount = 0;
+            this._documentIds = new Map();
+            this._idToShortId = new Map();
+            this._fieldLength = new Map();
+            this._avgFieldLength = [];
+            this._storedFields = new Map();
+            this._nextId = 0;
+        }
+    }
+    /**
+     * Discards the document with the given ID, so it won't appear in search results
+     *
+     * It has the same visible effect of {@link MiniSearch.remove} (both cause the
+     * document to stop appearing in searches), but a different effect on the
+     * internal data structures:
+     *
+     *   - {@link MiniSearch#remove} requires passing the full document to be
+     *   removed as argument, and removes it from the inverted index immediately.
+     *
+     *   - {@link MiniSearch#discard} instead only needs the document ID, and
+     *   works by marking the current version of the document as discarded, so it
+     *   is immediately ignored by searches. This is faster and more convenient
+     *   than {@link MiniSearch#remove}, but the index is not immediately
+     *   modified. To take care of that, vacuuming is performed after a certain
+     *   number of documents are discarded, cleaning up the index and allowing
+     *   memory to be released.
+     *
+     * After discarding a document, it is possible to re-add a new version, and
+     * only the new version will appear in searches. In other words, discarding
+     * and re-adding a document works exactly like removing and re-adding it. The
+     * {@link MiniSearch.replace} method can also be used to replace a document
+     * with a new version.
+     *
+     * #### Details about vacuuming
+     *
+     * Repetite calls to this method would leave obsolete document references in
+     * the index, invisible to searches. Two mechanisms take care of cleaning up:
+     * clean up during search, and vacuuming.
+     *
+     *   - Upon search, whenever a discarded ID is found (and ignored for the
+     *   results), references to the discarded document are removed from the
+     *   inverted index entries for the search terms. This ensures that subsequent
+     *   searches for the same terms do not need to skip these obsolete references
+     *   again.
+     *
+     *   - In addition, vacuuming is performed automatically by default (see the
+     *   `autoVacuum` field in {@link Options}) after a certain number of
+     *   documents are discarded. Vacuuming traverses all terms in the index,
+     *   cleaning up all references to discarded documents. Vacuuming can also be
+     *   triggered manually by calling {@link MiniSearch#vacuum}.
+     *
+     * @param id  The ID of the document to be discarded
+     */
+    discard(id) {
+        const shortId = this._idToShortId.get(id);
+        if (shortId == null) {
+            throw new Error(`MiniSearch: cannot discard document with ID ${id}: it is not in the index`);
+        }
+        this._idToShortId.delete(id);
+        this._documentIds.delete(shortId);
+        this._storedFields.delete(shortId);
+        (this._fieldLength.get(shortId) || []).forEach((fieldLength, fieldId) => {
+            this.removeFieldLength(shortId, fieldId, this._documentCount, fieldLength);
+        });
+        this._fieldLength.delete(shortId);
+        this._documentCount -= 1;
+        this._dirtCount += 1;
+        this.maybeAutoVacuum();
+    }
+    maybeAutoVacuum() {
+        if (this._options.autoVacuum === false) {
+            return;
+        }
+        const { minDirtFactor, minDirtCount, batchSize, batchWait } = this._options.autoVacuum;
+        this.conditionalVacuum({ batchSize, batchWait }, { minDirtCount, minDirtFactor });
+    }
+    /**
+     * Discards the documents with the given IDs, so they won't appear in search
+     * results
+     *
+     * It is equivalent to calling {@link MiniSearch#discard} for all the given
+     * IDs, but with the optimization of triggering at most one automatic
+     * vacuuming at the end.
+     *
+     * Note: to remove all documents from the index, it is faster and more
+     * convenient to call {@link MiniSearch.removeAll} with no argument, instead
+     * of passing all IDs to this method.
+     */
+    discardAll(ids) {
+        const autoVacuum = this._options.autoVacuum;
+        try {
+            this._options.autoVacuum = false;
+            for (const id of ids) {
+                this.discard(id);
+            }
+        }
+        finally {
+            this._options.autoVacuum = autoVacuum;
+        }
+        this.maybeAutoVacuum();
+    }
+    /**
+     * It replaces an existing document with the given updated version
+     *
+     * It works by discarding the current version and adding the updated one, so
+     * it is functionally equivalent to calling {@link MiniSearch#discard}
+     * followed by {@link MiniSearch#add}. The ID of the updated document should
+     * be the same as the original one.
+     *
+     * Since it uses {@link MiniSearch#discard} internally, this method relies on
+     * vacuuming to clean up obsolete document references from the index, allowing
+     * memory to be released (see {@link MiniSearch#discard}).
+     *
+     * @param updatedDocument  The updated document to replace the old version
+     * with
+     */
+    replace(updatedDocument) {
+        const { idField, extractField } = this._options;
+        const id = extractField(updatedDocument, idField);
+        this.discard(id);
+        this.add(updatedDocument);
+    }
+    /**
+     * Triggers a manual vacuuming, cleaning up references to discarded documents
+     * from the inverted index
+     *
+     * Vacuuming is only useful for applications that use the {@link
+     * MiniSearch#discard} or {@link MiniSearch#replace} methods.
+     *
+     * By default, vacuuming is performed automatically when needed (controlled by
+     * the `autoVacuum` field in {@link Options}), so there is usually no need to
+     * call this method, unless one wants to make sure to perform vacuuming at a
+     * specific moment.
+     *
+     * Vacuuming traverses all terms in the inverted index in batches, and cleans
+     * up references to discarded documents from the posting list, allowing memory
+     * to be released.
+     *
+     * The method takes an optional object as argument with the following keys:
+     *
+     *   - `batchSize`: the size of each batch (1000 by default)
+     *
+     *   - `batchWait`: the number of milliseconds to wait between batches (10 by
+     *   default)
+     *
+     * On large indexes, vacuuming could have a non-negligible cost: batching
+     * avoids blocking the thread for long, diluting this cost so that it is not
+     * negatively affecting the application. Nonetheless, this method should only
+     * be called when necessary, and relying on automatic vacuuming is usually
+     * better.
+     *
+     * It returns a promise that resolves (to undefined) when the clean up is
+     * completed. If vacuuming is already ongoing at the time this method is
+     * called, a new one is enqueued immediately after the ongoing one, and a
+     * corresponding promise is returned. However, no more than one vacuuming is
+     * enqueued on top of the ongoing one, even if this method is called more
+     * times (enqueuing multiple ones would be useless).
+     *
+     * @param options  Configuration options for the batch size and delay. See
+     * {@link VacuumOptions}.
+     */
+    vacuum(options = {}) {
+        return this.conditionalVacuum(options);
+    }
+    conditionalVacuum(options, conditions) {
+        // If a vacuum is already ongoing, schedule another as soon as it finishes,
+        // unless there's already one enqueued. If one was already enqueued, do not
+        // enqueue another on top, but make sure that the conditions are the
+        // broadest.
+        if (this._currentVacuum) {
+            this._enqueuedVacuumConditions = this._enqueuedVacuumConditions && conditions;
+            if (this._enqueuedVacuum != null) {
+                return this._enqueuedVacuum;
+            }
+            this._enqueuedVacuum = this._currentVacuum.then(() => {
+                const conditions = this._enqueuedVacuumConditions;
+                this._enqueuedVacuumConditions = defaultVacuumConditions;
+                return this.performVacuuming(options, conditions);
+            });
+            return this._enqueuedVacuum;
+        }
+        if (this.vacuumConditionsMet(conditions) === false) {
+            return Promise.resolve();
+        }
+        this._currentVacuum = this.performVacuuming(options);
+        return this._currentVacuum;
+    }
+    async performVacuuming(options, conditions) {
+        const initialDirtCount = this._dirtCount;
+        if (this.vacuumConditionsMet(conditions)) {
+            const batchSize = options.batchSize || defaultVacuumOptions.batchSize;
+            const batchWait = options.batchWait || defaultVacuumOptions.batchWait;
+            let i = 1;
+            for (const [term, fieldsData] of this._index) {
+                for (const [fieldId, fieldIndex] of fieldsData) {
+                    for (const [shortId] of fieldIndex) {
+                        if (this._documentIds.has(shortId)) {
+                            continue;
+                        }
+                        if (fieldIndex.size <= 1) {
+                            fieldsData.delete(fieldId);
+                        }
+                        else {
+                            fieldIndex.delete(shortId);
+                        }
+                    }
+                }
+                if (this._index.get(term).size === 0) {
+                    this._index.delete(term);
+                }
+                if (i % batchSize === 0) {
+                    await new Promise((resolve) => setTimeout(resolve, batchWait));
+                }
+                i += 1;
+            }
+            this._dirtCount -= initialDirtCount;
+        }
+        // Make the next lines always async, so they execute after this function returns
+        await null;
+        this._currentVacuum = this._enqueuedVacuum;
+        this._enqueuedVacuum = null;
+    }
+    vacuumConditionsMet(conditions) {
+        if (conditions == null) {
+            return true;
+        }
+        let { minDirtCount, minDirtFactor } = conditions;
+        minDirtCount = minDirtCount || defaultAutoVacuumOptions.minDirtCount;
+        minDirtFactor = minDirtFactor || defaultAutoVacuumOptions.minDirtFactor;
+        return this.dirtCount >= minDirtCount && this.dirtFactor >= minDirtFactor;
+    }
+    /**
+     * Is `true` if a vacuuming operation is ongoing, `false` otherwise
+     */
+    get isVacuuming() {
+        return this._currentVacuum != null;
+    }
+    /**
+     * The number of documents discarded since the most recent vacuuming
+     */
+    get dirtCount() {
+        return this._dirtCount;
+    }
+    /**
+     * A number between 0 and 1 giving an indication about the proportion of
+     * documents that are discarded, and can therefore be cleaned up by vacuuming.
+     * A value close to 0 means that the index is relatively clean, while a higher
+     * value means that the index is relatively dirty, and vacuuming could release
+     * memory.
+     */
+    get dirtFactor() {
+        return this._dirtCount / (1 + this._documentCount + this._dirtCount);
+    }
+    /**
+     * Returns `true` if a document with the given ID is present in the index and
+     * available for search, `false` otherwise
+     *
+     * @param id  The document ID
+     */
+    has(id) {
+        return this._idToShortId.has(id);
+    }
+    /**
+     * Returns the stored fields (as configured in the `storeFields` constructor
+     * option) for the given document ID. Returns `undefined` if the document is
+     * not present in the index.
+     *
+     * @param id  The document ID
+     */
+    getStoredFields(id) {
+        const shortId = this._idToShortId.get(id);
+        if (shortId == null) {
+            return undefined;
+        }
+        return this._storedFields.get(shortId);
+    }
+    /**
+     * Search for documents matching the given search query.
+     *
+     * The result is a list of scored document IDs matching the query, sorted by
+     * descending score, and each including data about which terms were matched and
+     * in which fields.
+     *
+     * ### Basic usage:
+     *
+     * ```javascript
+     * // Search for "zen art motorcycle" with default options: terms have to match
+     * // exactly, and individual terms are joined with OR
+     * miniSearch.search('zen art motorcycle')
+     * // => [ { id: 2, score: 2.77258, match: { ... } }, { id: 4, score: 1.38629, match: { ... } } ]
+     * ```
+     *
+     * ### Restrict search to specific fields:
+     *
+     * ```javascript
+     * // Search only in the 'title' field
+     * miniSearch.search('zen', { fields: ['title'] })
+     * ```
+     *
+     * ### Field boosting:
+     *
+     * ```javascript
+     * // Boost a field
+     * miniSearch.search('zen', { boost: { title: 2 } })
+     * ```
+     *
+     * ### Prefix search:
+     *
+     * ```javascript
+     * // Search for "moto" with prefix search (it will match documents
+     * // containing terms that start with "moto" or "neuro")
+     * miniSearch.search('moto neuro', { prefix: true })
+     * ```
+     *
+     * ### Fuzzy search:
+     *
+     * ```javascript
+     * // Search for "ismael" with fuzzy search (it will match documents containing
+     * // terms similar to "ismael", with a maximum edit distance of 0.2 term.length
+     * // (rounded to nearest integer)
+     * miniSearch.search('ismael', { fuzzy: 0.2 })
+     * ```
+     *
+     * ### Combining strategies:
+     *
+     * ```javascript
+     * // Mix of exact match, prefix search, and fuzzy search
+     * miniSearch.search('ismael mob', {
+     *  prefix: true,
+     *  fuzzy: 0.2
+     * })
+     * ```
+     *
+     * ### Advanced prefix and fuzzy search:
+     *
+     * ```javascript
+     * // Perform fuzzy and prefix search depending on the search term. Here
+     * // performing prefix and fuzzy search only on terms longer than 3 characters
+     * miniSearch.search('ismael mob', {
+     *  prefix: term => term.length > 3
+     *  fuzzy: term => term.length > 3 ? 0.2 : null
+     * })
+     * ```
+     *
+     * ### Combine with AND:
+     *
+     * ```javascript
+     * // Combine search terms with AND (to match only documents that contain both
+     * // "motorcycle" and "art")
+     * miniSearch.search('motorcycle art', { combineWith: 'AND' })
+     * ```
+     *
+     * ### Combine with AND_NOT:
+     *
+     * There is also an AND_NOT combinator, that finds documents that match the
+     * first term, but do not match any of the other terms. This combinator is
+     * rarely useful with simple queries, and is meant to be used with advanced
+     * query combinations (see later for more details).
+     *
+     * ### Filtering results:
+     *
+     * ```javascript
+     * // Filter only results in the 'fiction' category (assuming that 'category'
+     * // is a stored field)
+     * miniSearch.search('motorcycle art', {
+     *   filter: (result) => result.category === 'fiction'
+     * })
+     * ```
+     *
+     * ### Wildcard query
+     *
+     * Searching for an empty string (assuming the default tokenizer) returns no
+     * results. Sometimes though, one needs to match all documents, like in a
+     * "wildcard" search. This is possible by passing the special value
+     * {@link MiniSearch.wildcard} as the query:
+     *
+     * ```javascript
+     * // Return search results for all documents
+     * miniSearch.search(MiniSearch.wildcard)
+     * ```
+     *
+     * Note that search options such as `filter` and `boostDocument` are still
+     * applied, influencing which results are returned, and their order:
+     *
+     * ```javascript
+     * // Return search results for all documents in the 'fiction' category
+     * miniSearch.search(MiniSearch.wildcard, {
+     *   filter: (result) => result.category === 'fiction'
+     * })
+     * ```
+     *
+     * ### Advanced combination of queries:
+     *
+     * It is possible to combine different subqueries with OR, AND, and AND_NOT,
+     * and even with different search options, by passing a query expression
+     * tree object as the first argument, instead of a string.
+     *
+     * ```javascript
+     * // Search for documents that contain "zen" and ("motorcycle" or "archery")
+     * miniSearch.search({
+     *   combineWith: 'AND',
+     *   queries: [
+     *     'zen',
+     *     {
+     *       combineWith: 'OR',
+     *       queries: ['motorcycle', 'archery']
+     *     }
+     *   ]
+     * })
+     *
+     * // Search for documents that contain ("apple" or "pear") but not "juice" and
+     * // not "tree"
+     * miniSearch.search({
+     *   combineWith: 'AND_NOT',
+     *   queries: [
+     *     {
+     *       combineWith: 'OR',
+     *       queries: ['apple', 'pear']
+     *     },
+     *     'juice',
+     *     'tree'
+     *   ]
+     * })
+     * ```
+     *
+     * Each node in the expression tree can be either a string, or an object that
+     * supports all {@link SearchOptions} fields, plus a `queries` array field for
+     * subqueries.
+     *
+     * Note that, while this can become complicated to do by hand for complex or
+     * deeply nested queries, it provides a formalized expression tree API for
+     * external libraries that implement a parser for custom query languages.
+     *
+     * @param query  Search query
+     * @param searchOptions  Search options. Each option, if not given, defaults to the corresponding value of `searchOptions` given to the constructor, or to the library default.
+     */
+    search(query, searchOptions = {}) {
+        const { searchOptions: globalSearchOptions } = this._options;
+        const searchOptionsWithDefaults = { ...globalSearchOptions, ...searchOptions };
+        const rawResults = this.executeQuery(query, searchOptions);
+        const skipSort = query === MiniSearch.wildcard && searchOptionsWithDefaults.boostDocument == null;
+        return finalizeSearchResults({
+            rawResults,
+            getExternalId: (docId) => this._documentIds.get(docId),
+            getStoredFields: (docId) => this._storedFields.get(docId),
+            filter: searchOptionsWithDefaults.filter,
+            skipSort
+        });
+    }
+    /**
+     * Provide suggestions for the given search query
+     *
+     * The result is a list of suggested modified search queries, derived from the
+     * given search query, each with a relevance score, sorted by descending score.
+     *
+     * By default, it uses the same options used for search, except that by
+     * default it performs prefix search on the last term of the query, and
+     * combine terms with `'AND'` (requiring all query terms to match). Custom
+     * options can be passed as a second argument. Defaults can be changed upon
+     * calling the {@link MiniSearch} constructor, by passing a
+     * `autoSuggestOptions` option.
+     *
+     * ### Basic usage:
+     *
+     * ```javascript
+     * // Get suggestions for 'neuro':
+     * miniSearch.autoSuggest('neuro')
+     * // => [ { suggestion: 'neuromancer', terms: [ 'neuromancer' ], score: 0.46240 } ]
+     * ```
+     *
+     * ### Multiple words:
+     *
+     * ```javascript
+     * // Get suggestions for 'zen ar':
+     * miniSearch.autoSuggest('zen ar')
+     * // => [
+     * //  { suggestion: 'zen archery art', terms: [ 'zen', 'archery', 'art' ], score: 1.73332 },
+     * //  { suggestion: 'zen art', terms: [ 'zen', 'art' ], score: 1.21313 }
+     * // ]
+     * ```
+     *
+     * ### Fuzzy suggestions:
+     *
+     * ```javascript
+     * // Correct spelling mistakes using fuzzy search:
+     * miniSearch.autoSuggest('neromancer', { fuzzy: 0.2 })
+     * // => [ { suggestion: 'neuromancer', terms: [ 'neuromancer' ], score: 1.03998 } ]
+     * ```
+     *
+     * ### Filtering:
+     *
+     * ```javascript
+     * // Get suggestions for 'zen ar', but only within the 'fiction' category
+     * // (assuming that 'category' is a stored field):
+     * miniSearch.autoSuggest('zen ar', {
+     *   filter: (result) => result.category === 'fiction'
+     * })
+     * // => [
+     * //  { suggestion: 'zen archery art', terms: [ 'zen', 'archery', 'art' ], score: 1.73332 },
+     * //  { suggestion: 'zen art', terms: [ 'zen', 'art' ], score: 1.21313 }
+     * // ]
+     * ```
+     *
+     * @param queryString  Query string to be expanded into suggestions
+     * @param options  Search options. The supported options and default values
+     * are the same as for the {@link MiniSearch#search} method, except that by
+     * default prefix search is performed on the last term in the query, and terms
+     * are combined with `'AND'`.
+     * @return  A sorted array of suggestions sorted by relevance score.
+     */
+    autoSuggest(queryString, options = {}) {
+        options = { ...this._options.autoSuggestOptions, ...options };
+        const suggestions = new Map();
+        for (const { score, terms } of this.search(queryString, options)) {
+            const phrase = terms.join(' ');
+            const suggestion = suggestions.get(phrase);
+            if (suggestion != null) {
+                suggestion.score += score;
+                suggestion.count += 1;
+            }
+            else {
+                suggestions.set(phrase, { score, terms, count: 1 });
+            }
+        }
+        const results = [];
+        for (const [suggestion, { score, terms, count }] of suggestions) {
+            results.push({ suggestion, terms, score: score / count });
+        }
+        results.sort(byScore);
+        return results;
+    }
+    /**
+     * Total number of documents available to search
+     */
+    get documentCount() {
+        return this._documentCount;
+    }
+    /**
+     * Number of terms in the index
+     */
+    get termCount() {
+        return this._index.size;
+    }
+    /**
+     * Deserializes a JSON index (serialized with `JSON.stringify(miniSearch)`)
+     * and instantiates a MiniSearch instance. It should be given the same options
+     * originally used when serializing the index.
+     *
+     * ### Usage:
+     *
+     * ```javascript
+     * // If the index was serialized with:
+     * let miniSearch = new MiniSearch({ fields: ['title', 'text'] })
+     * miniSearch.addAll(documents)
+     *
+     * const json = JSON.stringify(miniSearch)
+     * // It can later be deserialized like this:
+     * miniSearch = MiniSearch.loadJSON(json, { fields: ['title', 'text'] })
+     * ```
+     *
+     * @param json  JSON-serialized index
+     * @param options  configuration options, same as the constructor
+     * @return An instance of MiniSearch deserialized from the given JSON.
+     */
+    static loadJSON(json, options) {
+        if (options == null) {
+            throw new Error('MiniSearch: loadJSON should be given the same options used when serializing the index');
+        }
+        return this.loadJS(JSON.parse(json), options);
+    }
+    /**
+     * Async equivalent of {@link MiniSearch.loadJSON}
+     *
+     * This function is an alternative to {@link MiniSearch.loadJSON} that returns
+     * a promise, and loads the index in batches, leaving pauses between them to avoid
+     * blocking the main thread. It tends to be slower than the synchronous
+     * version, but does not block the main thread, so it can be a better choice
+     * when deserializing very large indexes.
+     *
+     * @param json  JSON-serialized index
+     * @param options  configuration options, same as the constructor
+     * @return A Promise that will resolve to an instance of MiniSearch deserialized from the given JSON.
+     */
+    static async loadJSONAsync(json, options) {
+        if (options == null) {
+            throw new Error('MiniSearch: loadJSON should be given the same options used when serializing the index');
+        }
+        return this.loadJSAsync(JSON.parse(json), options);
+    }
+    /**
+     * Returns the default value of an option. It will throw an error if no option
+     * with the given name exists.
+     *
+     * @param optionName  Name of the option
+     * @return The default value of the given option
+     *
+     * ### Usage:
+     *
+     * ```javascript
+     * // Get default tokenizer
+     * MiniSearch.getDefault('tokenize')
+     *
+     * // Get default term processor
+     * MiniSearch.getDefault('processTerm')
+     *
+     * // Unknown options will throw an error
+     * MiniSearch.getDefault('notExisting')
+     * // => throws 'MiniSearch: unknown option "notExisting"'
+     * ```
+     */
+    static getDefault(optionName) {
+        if (defaultOptions.hasOwnProperty(optionName)) {
+            return getOwnProperty(defaultOptions, optionName);
+        }
+        else {
+            throw new Error(`MiniSearch: unknown option "${optionName}"`);
+        }
+    }
+    /**
+     * @ignore
+     */
+    static loadJS(js, options) {
+        const { index, documentIds, fieldLength, storedFields, serializationVersion } = js;
+        const miniSearch = this.instantiateMiniSearch(js, options);
+        miniSearch._documentIds = objectToNumericMap(documentIds);
+        miniSearch._fieldLength = objectToNumericMap(fieldLength);
+        miniSearch._storedFields = objectToNumericMap(storedFields);
+        for (const [shortId, id] of miniSearch._documentIds) {
+            miniSearch._idToShortId.set(id, shortId);
+        }
+        for (const [term, data] of index) {
+            const dataMap = new Map();
+            for (const fieldId of Object.keys(data)) {
+                let indexEntry = data[fieldId];
+                // Version 1 used to nest the index entry inside a field called ds
+                if (serializationVersion === 1) {
+                    indexEntry = indexEntry.ds;
+                }
+                dataMap.set(parseInt(fieldId, 10), objectToNumericMap(indexEntry));
+            }
+            miniSearch._index.set(term, dataMap);
+        }
+        return miniSearch;
+    }
+    /**
+     * @ignore
+     */
+    static async loadJSAsync(js, options) {
+        const { index, documentIds, fieldLength, storedFields, serializationVersion } = js;
+        const miniSearch = this.instantiateMiniSearch(js, options);
+        miniSearch._documentIds = await objectToNumericMapAsync(documentIds);
+        miniSearch._fieldLength = await objectToNumericMapAsync(fieldLength);
+        miniSearch._storedFields = await objectToNumericMapAsync(storedFields);
+        for (const [shortId, id] of miniSearch._documentIds) {
+            miniSearch._idToShortId.set(id, shortId);
+        }
+        let count = 0;
+        for (const [term, data] of index) {
+            const dataMap = new Map();
+            for (const fieldId of Object.keys(data)) {
+                let indexEntry = data[fieldId];
+                // Version 1 used to nest the index entry inside a field called ds
+                if (serializationVersion === 1) {
+                    indexEntry = indexEntry.ds;
+                }
+                dataMap.set(parseInt(fieldId, 10), await objectToNumericMapAsync(indexEntry));
+            }
+            if (++count % 1000 === 0)
+                await wait(0);
+            miniSearch._index.set(term, dataMap);
+        }
+        return miniSearch;
+    }
+    /**
+     * @ignore
+     */
+    static instantiateMiniSearch(js, options) {
+        const { documentCount, nextId, fieldIds, averageFieldLength, dirtCount, serializationVersion } = js;
+        if (serializationVersion !== 1 && serializationVersion !== 2) {
+            throw new Error('MiniSearch: cannot deserialize an index created with an incompatible version');
+        }
+        const miniSearch = new MiniSearch(options);
+        miniSearch._documentCount = documentCount;
+        miniSearch._nextId = nextId;
+        miniSearch._idToShortId = new Map();
+        miniSearch._fieldIds = fieldIds;
+        miniSearch._avgFieldLength = averageFieldLength;
+        miniSearch._dirtCount = dirtCount || 0;
+        miniSearch._index = new SearchableMap();
+        return miniSearch;
+    }
+    /**
+     * @ignore
+     */
+    executeQuery(query, searchOptions = {}) {
+        if (query === MiniSearch.wildcard) {
+            return this.executeWildcardQuery(searchOptions);
+        }
+        if (typeof query !== 'string') {
+            const options = { ...searchOptions, ...query, queries: undefined };
+            const results = query.queries.map((subquery) => this.executeQuery(subquery, options));
+            return this.combineResults(results, options.combineWith);
+        }
+        const { tokenize, processTerm, searchOptions: globalSearchOptions } = this._options;
+        const options = { tokenize, processTerm, ...globalSearchOptions, ...searchOptions };
+        const { tokenize: searchTokenize, processTerm: searchProcessTerm } = options;
+        const terms = searchTokenize(query)
+            .flatMap((term) => searchProcessTerm(term))
+            .filter((term) => !!term);
+        const queries = terms.map(termToQuerySpec(options));
+        const results = queries.map(query => this.executeQuerySpec(query, options));
+        return this.combineResults(results, options.combineWith);
+    }
+    /**
+     * @ignore
+     */
+    executeQuerySpec(query, searchOptions) {
+        const options = { ...this._options.searchOptions, ...searchOptions };
+        const boosts = (options.fields || this._options.fields).reduce((boosts, field) => ({ ...boosts, [field]: getOwnProperty(options.boost, field) || 1 }), {});
+        const { boostDocument, weights, maxFuzzy, bm25: bm25params } = options;
+        const { fuzzy: fuzzyWeight, prefix: prefixWeight } = { ...defaultSearchOptions.weights, ...weights };
+        const data = this._index.get(query.term);
+        const results = this.termResults(query.term, query.term, 1, query.termBoost, data, boosts, boostDocument, bm25params);
+        let prefixMatches;
+        let fuzzyMatches;
+        if (query.prefix) {
+            prefixMatches = this._index.atPrefix(query.term);
+        }
+        if (query.fuzzy) {
+            const fuzzy = (query.fuzzy === true) ? 0.2 : query.fuzzy;
+            const maxDistance = fuzzy < 1 ? Math.min(maxFuzzy, Math.round(query.term.length * fuzzy)) : fuzzy;
+            if (maxDistance)
+                fuzzyMatches = this._index.fuzzyGet(query.term, maxDistance);
+        }
+        if (prefixMatches) {
+            for (const [term, data] of prefixMatches) {
+                const distance = term.length - query.term.length;
+                if (!distance) {
+                    continue;
+                } // Skip exact match.
+                // Delete the term from fuzzy results (if present) if it is also a
+                // prefix result. This entry will always be scored as a prefix result.
+                fuzzyMatches === null || fuzzyMatches === void 0 ? void 0 : fuzzyMatches.delete(term);
+                // Weight gradually approaches 0 as distance goes to infinity, with the
+                // weight for the hypothetical distance 0 being equal to prefixWeight.
+                // The rate of change is much lower than that of fuzzy matches to
+                // account for the fact that prefix matches stay more relevant than
+                // fuzzy matches for longer distances.
+                const weight = prefixWeight * term.length / (term.length + 0.3 * distance);
+                this.termResults(query.term, term, weight, query.termBoost, data, boosts, boostDocument, bm25params, results);
+            }
+        }
+        if (fuzzyMatches) {
+            for (const term of fuzzyMatches.keys()) {
+                const [data, distance] = fuzzyMatches.get(term);
+                if (!distance) {
+                    continue;
+                } // Skip exact match.
+                // Weight gradually approaches 0 as distance goes to infinity, with the
+                // weight for the hypothetical distance 0 being equal to fuzzyWeight.
+                const weight = fuzzyWeight * term.length / (term.length + distance);
+                this.termResults(query.term, term, weight, query.termBoost, data, boosts, boostDocument, bm25params, results);
+            }
+        }
+        return results;
+    }
+    /**
+     * @ignore
+     */
+    executeWildcardQuery(searchOptions) {
+        const results = new Map();
+        const options = { ...this._options.searchOptions, ...searchOptions };
+        for (const [shortId, id] of this._documentIds) {
+            const score = options.boostDocument ? options.boostDocument(id, '', this._storedFields.get(shortId)) : 1;
+            results.set(shortId, {
+                score,
+                terms: [],
+                match: {}
+            });
+        }
+        return results;
+    }
+    /**
+     * @ignore
+     */
+    combineResults(results, combineWith = OR) {
+        return combineResults(results, combineWith);
+    }
+    /**
+     * Build a read-only {@link FrozenMiniSearch} snapshot optimized for RAM and search CPU.
+     */
+    freeze() {
+        return freezeFromMiniSearch(this);
+    }
+    /**
+     * Allows serialization of the index to JSON, to possibly store it and later
+     * deserialize it with {@link MiniSearch.loadJSON}.
+     *
+     * Normally one does not directly call this method, but rather call the
+     * standard JavaScript `JSON.stringify()` passing the {@link MiniSearch}
+     * instance, and JavaScript will internally call this method. Upon
+     * deserialization, one must pass to {@link MiniSearch.loadJSON} the same
+     * options used to create the original instance that was serialized.
+     *
+     * ### Usage:
+     *
+     * ```javascript
+     * // Serialize the index:
+     * let miniSearch = new MiniSearch({ fields: ['title', 'text'] })
+     * miniSearch.addAll(documents)
+     * const json = JSON.stringify(miniSearch)
+     *
+     * // Later, to deserialize it:
+     * miniSearch = MiniSearch.loadJSON(json, { fields: ['title', 'text'] })
+     * ```
+     *
+     * @return A plain-object serializable representation of the search index.
+     */
+    toJSON() {
+        const index = [];
+        for (const [term, fieldIndex] of this._index) {
+            const data = {};
+            for (const [fieldId, freqs] of fieldIndex) {
+                data[fieldId] = Object.fromEntries(freqs);
+            }
+            index.push([term, data]);
+        }
+        return {
+            documentCount: this._documentCount,
+            nextId: this._nextId,
+            documentIds: Object.fromEntries(this._documentIds),
+            fieldIds: this._fieldIds,
+            fieldLength: Object.fromEntries(this._fieldLength),
+            averageFieldLength: this._avgFieldLength,
+            storedFields: Object.fromEntries(this._storedFields),
+            dirtCount: this._dirtCount,
+            index,
+            serializationVersion: 2
+        };
+    }
+    /**
+     * @ignore
+     */
+    termResults(sourceTerm, derivedTerm, termWeight, termBoost, fieldTermData, fieldBoosts, boostDocumentFn, bm25params, results = new Map()) {
+        return aggregateTerm(sourceTerm, derivedTerm, termWeight, termBoost, fieldTermData == null ? undefined : mapFieldTermData(fieldTermData), fieldBoosts, {
+            documentCount: this._documentCount,
+            avgFieldLength: this._avgFieldLength,
+            fieldIds: this._fieldIds,
+            getFieldLength: (docId, fieldId) => this._fieldLength.get(docId)[fieldId],
+            getExternalId: (docId) => this._documentIds.get(docId),
+            getStoredFields: (docId) => this._storedFields.get(docId),
+            isDocActive: (docId) => this._documentIds.has(docId),
+            onInactiveDoc: (docId, fieldId, term) => this.removeTerm(fieldId, docId, term)
+        }, boostDocumentFn, bm25params, results);
+    }
+    /**
+     * @ignore
+     */
+    addTerm(fieldId, documentId, term) {
+        const indexData = this._index.fetch(term, createMap);
+        let fieldIndex = indexData.get(fieldId);
+        if (fieldIndex == null) {
+            fieldIndex = new Map();
+            fieldIndex.set(documentId, 1);
+            indexData.set(fieldId, fieldIndex);
+        }
+        else {
+            const docs = fieldIndex.get(documentId);
+            fieldIndex.set(documentId, (docs || 0) + 1);
+        }
+    }
+    /**
+     * @ignore
+     */
+    removeTerm(fieldId, documentId, term) {
+        if (!this._index.has(term)) {
+            this.warnDocumentChanged(documentId, fieldId, term);
+            return;
+        }
+        const indexData = this._index.fetch(term, createMap);
+        const fieldIndex = indexData.get(fieldId);
+        if (fieldIndex == null || fieldIndex.get(documentId) == null) {
+            this.warnDocumentChanged(documentId, fieldId, term);
+        }
+        else if (fieldIndex.get(documentId) <= 1) {
+            if (fieldIndex.size <= 1) {
+                indexData.delete(fieldId);
+            }
+            else {
+                fieldIndex.delete(documentId);
+            }
+        }
+        else {
+            fieldIndex.set(documentId, fieldIndex.get(documentId) - 1);
+        }
+        if (this._index.get(term).size === 0) {
+            this._index.delete(term);
+        }
+    }
+    /**
+     * @ignore
+     */
+    warnDocumentChanged(shortDocumentId, fieldId, term) {
+        for (const fieldName of Object.keys(this._fieldIds)) {
+            if (this._fieldIds[fieldName] === fieldId) {
+                this._options.logger('warn', `MiniSearch: document with ID ${this._documentIds.get(shortDocumentId)} has changed before removal: term "${term}" was not present in field "${fieldName}". Removing a document after it has changed can corrupt the index!`, 'version_conflict');
+                return;
+            }
+        }
+    }
+    /**
+     * @ignore
+     */
+    addDocumentId(documentId) {
+        const shortDocumentId = this._nextId;
+        this._idToShortId.set(documentId, shortDocumentId);
+        this._documentIds.set(shortDocumentId, documentId);
+        this._documentCount += 1;
+        this._nextId += 1;
+        return shortDocumentId;
+    }
+    /**
+     * @ignore
+     */
+    addFields(fields) {
+        for (let i = 0; i < fields.length; i++) {
+            this._fieldIds[fields[i]] = i;
+        }
+    }
+    /**
+     * @ignore
+     */
+    addFieldLength(documentId, fieldId, count, length) {
+        let fieldLengths = this._fieldLength.get(documentId);
+        if (fieldLengths == null)
+            this._fieldLength.set(documentId, fieldLengths = []);
+        fieldLengths[fieldId] = length;
+        const averageFieldLength = this._avgFieldLength[fieldId] || 0;
+        const totalFieldLength = (averageFieldLength * count) + length;
+        this._avgFieldLength[fieldId] = totalFieldLength / (count + 1);
+    }
+    /**
+     * @ignore
+     */
+    removeFieldLength(documentId, fieldId, count, length) {
+        if (count === 1) {
+            this._avgFieldLength[fieldId] = 0;
+            return;
+        }
+        const totalFieldLength = (this._avgFieldLength[fieldId] * count) - length;
+        this._avgFieldLength[fieldId] = totalFieldLength / (count - 1);
+    }
+}
+/**
+ * The special wildcard symbol that can be passed to {@link MiniSearch#search}
+ * to match all documents
+ */
+MiniSearch.wildcard = WILDCARD_QUERY;
+const defaultOptions = {
+    idField: 'id',
+    extractField: (document, fieldName) => document[fieldName],
+    stringifyField: (fieldValue, fieldName) => fieldValue.toString(),
+    tokenize: (text) => text.split(SPACE_OR_PUNCTUATION),
+    processTerm: (term) => term.toLowerCase(),
+    fields: undefined,
+    searchOptions: undefined,
+    storeFields: [],
+    logger: (level, message) => {
+        if (typeof (console === null || console === void 0 ? void 0 : console[level]) === 'function')
+            console[level](message);
+    },
+    autoVacuum: true
+};
+const defaultVacuumOptions = { batchSize: 1000, batchWait: 10 };
+const defaultVacuumConditions = { minDirtFactor: 0.1, minDirtCount: 20 };
+const defaultAutoVacuumOptions = { ...defaultVacuumOptions, ...defaultVacuumConditions };
+const createMap = () => new Map();
+const objectToNumericMap = (object) => {
+    const map = new Map();
+    for (const key of Object.keys(object)) {
+        map.set(parseInt(key, 10), object[key]);
+    }
+    return map;
+};
+const objectToNumericMapAsync = async (object) => {
+    const map = new Map();
+    let count = 0;
+    for (const key of Object.keys(object)) {
+        map.set(parseInt(key, 10), object[key]);
+        if (++count % 1000 === 0) {
+            await wait(0);
+        }
+    }
+    return map;
+};
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+exports.AND = AND;
+exports.AND_NOT = AND_NOT;
+exports.FrozenMiniSearch = FrozenMiniSearch;
+exports.OR = OR;
+exports.assembleFrozen = assembleFrozen;
+exports.buildFrozenFromDocuments = buildFrozenFromDocuments;
+exports.default = MiniSearch;
+exports.freezeFromMiniSearch = freezeFromMiniSearch;
+exports.frozenMemoryBreakdown = frozenMemoryBreakdown;