@devisfuture/mega-collection 2.4.6 → 2.4.7

package/dist/search/text-search.mjs

@@ -0,0 +1,696 @@
+import { State as e } from "../State.mjs";
+import { DEFER_SEARCH_MUTATION_INDEX_UPDATES_KEY as t, MERGE_SHARED_SCOPE as n } from "../constants.mjs";
+import { buildIntersectionQueryGrams as r, createIntersectionPlan as i, indexLowerValue as a, intersectPostingLists as o, intersectPostingListsInCandidates as s, removeLowerValue as c } from "./ngram.mjs";
+import { SearchNestedCollection as l } from "./nested.mjs";
+import { createSearchRuntime as u } from "./utils.mjs";
+//#region src/search/text-search.ts
+var d = class {
+	constructor(t = {}) {
+		this.cachedIndexedFieldsList = null, this.cachedLinearSearchFieldsList = null, this.emittedWarningKeys = /* @__PURE__ */ new Set(), this.warnings = [], this.normalizedValuesCache = /* @__PURE__ */ new Map(), this.combinedNormalizedValuesCache = null, this.minQueryLength = t.minQueryLength ?? 1, this.silent = t.silent ?? !1, this.state = t.state ?? new e(t.data ?? []), this.namespace = this.state.createNamespace("search"), this.nestedCollection = new l(this.runtime.nestedStorage), this.nestedCollection.registerFields(t.nestedFields), this.state.subscribe((e) => this.handleStateMutation(e)), t.filterByPreviousResult && (this.runtime.filterByPreviousResult = !0);
+		let n = t.fields?.length, r = this.nestedCollection.hasRegisteredFields();
+		if (n) for (let e of t.fields) this.indexedFields.add(e);
+		this.dataset.length > 0 && (n || r) && this.rebuildConfiguredIndexes();
+	}
+	get dataset() {
+		return this.state.getOriginData();
+	}
+	get runtime() {
+		return this.state.getOrCreateScopedValue(this.namespace, "runtime", u);
+	}
+	get flatIndexes() {
+		return this.runtime.flatIndexes;
+	}
+	get indexedFields() {
+		return this.runtime.indexedFields;
+	}
+	shouldDeferMutationIndexUpdates() {
+		return this.state.getScopedValue(n, t) === !0;
+	}
+	markDeferredMutationState() {
+		this.runtime.deferredMutationVersion = this.state.getMutationVersion(), this.flatIndexes.clear(), this.nestedCollection.clearIndexes(), this.cachedIndexedFieldsList = null, this.cachedLinearSearchFieldsList = null, this.normalizedValuesCache.clear(), this.combinedNormalizedValuesCache = null, this.clearPreviousSearchState();
+	}
+	ensureConfiguredIndexesReady() {
+		this.runtime.deferredMutationVersion !== null && (this.runtime.deferredMutationVersion = null, this.dataset.length > 0 && (this.indexedFields.size > 0 || this.nestedCollection.hasRegisteredFields()) && this.rebuildConfiguredIndexes());
+	}
+	rebuildConfiguredIndexes() {
+		this.flatIndexes.clear(), this.nestedCollection.clearIndexes(), this.cachedIndexedFieldsList = null, this.cachedLinearSearchFieldsList = null, this.normalizedValuesCache.clear(), this.combinedNormalizedValuesCache = null;
+		for (let e of this.indexedFields) this.buildIndexFromData(this.dataset, e);
+		this.nestedCollection.hasRegisteredFields() && this.nestedCollection.buildIndexes(this.dataset);
+	}
+	buildIndexFromData(e, t) {
+		let n = this.state.getMutationVersion(), r = /* @__PURE__ */ new Map(), i = Array(e.length);
+		for (let n = 0, o = e.length; n < o; n++) {
+			let o = e[n][t];
+			if (typeof o != "string") continue;
+			let s = o.toLowerCase();
+			i[n] = s, a(r, s, n);
+		}
+		this.flatIndexes.set(t, {
+			ngramMap: r,
+			normalizedValues: i,
+			version: n
+		});
+	}
+	search(e, t, n) {
+		return typeof t == "string" ? this.searchField(e, t, n) : this.searchAll(e, t);
+	}
+	searchAll(e, t) {
+		return this.searchAllFields(e, t);
+	}
+	normalizeQuery(e) {
+		return e.trim().toLowerCase();
+	}
+	normalizeSearchWindow(e) {
+		let t = Math.max(0, Math.trunc(e?.offset ?? 0)), n = e?.limit, r = n === void 0 ? Infinity : Math.max(0, Math.trunc(n));
+		return {
+			offset: t,
+			limit: r,
+			take: Number.isFinite(r) ? t + r : Infinity,
+			hasWindow: t > 0 || Number.isFinite(r)
+		};
+	}
+	shouldTrackPreviousResult(e) {
+		return !e.hasWindow;
+	}
+	hasReachedWindowLimit(e, t) {
+		return Number.isFinite(e.limit) && t >= e.limit;
+	}
+	sliceItems(e, t) {
+		return t.hasWindow ? e.slice(t.offset, t.take) : e;
+	}
+	collectItemsFromIndices(e, t) {
+		let n = t.hasWindow && e.length > 0 ? e.slice(t.offset, t.take) : e, r = [];
+		for (let e = 0; e < n.length; e++) {
+			let t = this.dataset[n[e]];
+			t && r.push(t);
+		}
+		return {
+			items: r,
+			indices: n
+		};
+	}
+	createLookup(e) {
+		let t = new Uint8Array(this.dataset.length);
+		for (let n = 0; n < e.length; n++) t[e[n]] = 1;
+		return t;
+	}
+	getRestrictionLookup(e) {
+		let t = this.runtime.previousResultLookup;
+		if (t !== null && this.runtime.previousResultIndices === e && t.length === this.dataset.length) return t;
+		let n = this.createLookup(e);
+		return this.runtime.previousResultLookup = n, n;
+	}
+	getSearchSource(e) {
+		let { runtime: t } = this;
+		return t.filterByPreviousResult ? t.previousQuery !== null && t.previousResultIndices !== null && e.includes(t.previousQuery) ? {
+			indices: t.previousResultIndices,
+			lookup: this.getRestrictionLookup(t.previousResultIndices)
+		} : (t.previousResultIndices = null, t.previousResultLookup = null, t.previousQuery = null, {
+			indices: null,
+			lookup: null
+		}) : {
+			indices: null,
+			lookup: null
+		};
+	}
+	saveSearchResult(e, t) {
+		let { runtime: n } = this;
+		n.filterByPreviousResult && (n.previousResultIndices = e, n.previousResultLookup = null, n.previousQuery = t);
+	}
+	persistSearchResult(e, t, n) {
+		n && this.saveSearchResult(e.indices, t);
+	}
+	resetSearchState() {
+		return this.clearPreviousSearchState(), this;
+	}
+	getWarnings() {
+		return [...this.warnings];
+	}
+	getStats() {
+		let { totalQueries: e, indexedQueries: t, fallbackQueries: n, fallbackFields: r } = this.runtime.stats;
+		return {
+			totalQueries: e,
+			indexedQueries: t,
+			fallbackQueries: n,
+			fallbackRate: e === 0 ? 0 : n / e,
+			fallbackFields: Object.fromEntries(r)
+		};
+	}
+	resetStats() {
+		let { stats: e } = this.runtime;
+		return e.totalQueries = 0, e.indexedQueries = 0, e.fallbackQueries = 0, e.fallbackFields.clear(), this;
+	}
+	clearPreviousSearchState() {
+		let { runtime: e } = this;
+		e.previousResultIndices = null, e.previousResultLookup = null, e.previousQuery = null;
+	}
+	recordIndexedQuery() {
+		let { stats: e } = this.runtime;
+		e.totalQueries += 1, e.indexedQueries += 1;
+	}
+	recordFallbackQuery(e) {
+		let { stats: t } = this.runtime;
+		t.totalQueries += 1, t.fallbackQueries += 1, t.fallbackFields.set(e, (t.fallbackFields.get(e) ?? 0) + 1);
+	}
+	shouldEmitFallbackWarning(e) {
+		return !this.silent && e.length >= 2;
+	}
+	warnAboutFallback(e, t, n) {
+		if (!this.shouldEmitFallbackWarning(t)) return;
+		let r = `${e}\u0000${t}\u0000${n}`;
+		if (this.emittedWarningKeys.has(r)) return;
+		this.emittedWarningKeys.add(r);
+		let i = `[TextSearchEngine] warn: query "${t}" on ${e} used linear fallback. ${n}. Add the field(s) to the index schema to enable indexed search.`;
+		this.warnings.push(i), typeof process < "u" && process.env.NODE_ENV !== "production" && process.env.NODE_ENV !== "test" && console.warn(i);
+	}
+	getResolvedFlatIndex(e) {
+		let t = this.state.getMutationVersion(), n = this.flatIndexes.get(e);
+		return n && n.version !== t && this.dataset.length > 0 && (this.buildIndexFromData(this.dataset, e), n = this.flatIndexes.get(e)), n;
+	}
+	getQueryGrams(e) {
+		let t = r(e);
+		return t.size > 0 ? t : null;
+	}
+	searchAllFields(e, t) {
+		let n = this.normalizeQuery(e), r = this.normalizeSearchWindow(t), i = "all fields";
+		if (r.limit === 0) return [];
+		if (!n || n.length < this.minQueryLength) return this.sliceItems(this.dataset, r);
+		n.length >= 2 && this.ensureConfiguredIndexesReady();
+		let a = this.shouldTrackPreviousResult(r), { indices: o, lookup: s } = this.getSearchSource(n), c, l = () => (c === void 0 && (c = n.length >= 2 ? this.getQueryGrams(n) : null), c);
+		if (o !== null) {
+			let e = l();
+			if (e !== null && (this.flatIndexes.size > 0 || this.nestedCollection.hasIndexes())) {
+				this.recordIndexedQuery();
+				let t = this.searchAllFieldsIndexed(n, e, r, s, o);
+				return this.persistSearchResult(t, n, a), t.items;
+			}
+			this.recordFallbackQuery(i);
+			let t = this.searchLinearAllFields(this.dataset, n, o, r);
+			return this.persistSearchResult(t, n, a), t.items;
+		}
+		if (!this.flatIndexes.size && !this.nestedCollection.hasIndexes()) {
+			this.warnAboutFallback(i, n, this.indexedFields.size > 0 ? "configured indexes are not currently built" : "no indexed fields are configured"), this.recordFallbackQuery(i);
+			let e = this.searchLinearAllFields(this.dataset, n, null, r);
+			return this.persistSearchResult(e, n, a), e.items;
+		}
+		let u = l();
+		if (u === null) {
+			this.recordFallbackQuery(i);
+			let e = this.searchLinearAllFields(this.dataset, n, null, r);
+			return this.persistSearchResult(e, n, a), e.items;
+		}
+		this.recordIndexedQuery();
+		let d = this.searchAllFieldsIndexed(n, u, r, null);
+		return this.persistSearchResult(d, n, a), d.items;
+	}
+	searchAllFieldsIndexed(e, t, n, r, i = null) {
+		if (i !== null && !this.nestedCollection.hasRegisteredFields() && this.flatIndexes.size > 0) return this.searchAllFieldsIndexedInCandidates(e, t, n, r, i);
+		let a = this.dataset, o = new Uint8Array(a.length), s = [], c = 0;
+		for (let a of this.flatIndexes.keys()) {
+			let l = this.searchFieldWithPreparedQueryIndices(a, e, t, r, i);
+			for (let e = 0; e < l.length; e++) {
+				let t = l[e];
+				if (!o[t]) {
+					if (o[t] = 1, c < n.offset) {
+						c += 1;
+						continue;
+					}
+					if (s.push(t), c += 1, this.hasReachedWindowLimit(n, s.length)) return this.materializeIndicesResult(s);
+				}
+			}
+		}
+		for (let a of this.nestedCollection.searchAllIndexedFieldIndices(e, t, r, i)) if (!o[a]) {
+			if (o[a] = 1, c < n.offset) {
+				c += 1;
+				continue;
+			}
+			if (s.push(a), c += 1, this.hasReachedWindowLimit(n, s.length)) return this.materializeIndicesResult(s);
+		}
+		return this.materializeIndicesResult(s);
+	}
+	searchAllFieldsIndexedInCandidates(e, t, n, r, a) {
+		let o = [];
+		for (let n of this.flatIndexes.keys()) {
+			let r = this.getResolvedFlatIndex(n);
+			if (!r) continue;
+			let a = i(r.ngramMap, t, r.normalizedValues, e);
+			a !== null && o.push(a.matches);
+		}
+		if (o.length === 0) return {
+			items: [],
+			indices: []
+		};
+		let s = [], c = 0;
+		for (let e = 0; e < a.length; e++) {
+			let t = a[e];
+			if (r !== null && !r[t]) continue;
+			let i = !1;
+			for (let e = 0; e < o.length; e++) if (o[e](t)) {
+				i = !0;
+				break;
+			}
+			if (i) {
+				if (c < n.offset) {
+					c += 1;
+					continue;
+				}
+				if (s.push(t), c += 1, this.hasReachedWindowLimit(n, s.length)) break;
+			}
+		}
+		return this.materializeIndicesResult(s);
+	}
+	searchField(e, t, n) {
+		let r = this.normalizeQuery(t), i = this.normalizeSearchWindow(n), a = `field "${e}"`;
+		if (i.limit === 0) return [];
+		if (!r || r.length < this.minQueryLength) return this.sliceItems(this.dataset, i);
+		r.length >= 2 && this.ensureConfiguredIndexesReady();
+		let o = this.shouldTrackPreviousResult(i), { indices: s, lookup: c } = this.getSearchSource(r), l = this.nestedCollection.hasField(e), u, d = () => (u === void 0 && (u = r.length >= 2 ? this.getQueryGrams(r) : null), u);
+		if (s !== null) {
+			let t = d();
+			if (l) {
+				if (t !== null && this.nestedCollection.hasIndexes()) {
+					this.recordIndexedQuery();
+					let n = this.nestedCollection.searchIndexedFieldIndices(e, r, t, c, s, i.take), a = this.collectItemsFromIndices(n, i);
+					return this.persistSearchResult(a, r, o), a.items;
+				}
+				this.recordFallbackQuery(a);
+				let n = this.searchLinearSingleField(this.dataset, e, r, s, i);
+				return this.persistSearchResult(n, r, o), n.items;
+			}
+			if (t !== null && this.flatIndexes.has(e)) {
+				this.recordIndexedQuery();
+				let n = this.searchFieldWithPreparedQuery(e, r, t, i, c, s);
+				return this.persistSearchResult(n, r, o), n.items;
+			}
+			this.recordFallbackQuery(a);
+			let n = this.searchLinearSingleField(this.dataset, e, r, s, i);
+			return this.persistSearchResult(n, r, o), n.items;
+		}
+		if (l) {
+			if (r.length >= 2 && this.nestedCollection.hasIndexes()) {
+				let t = this.getQueryGrams(r);
+				if (t === null) return [];
+				this.recordIndexedQuery();
+				let n = this.nestedCollection.searchIndexedFieldIndices(e, r, t, null, null, i.take), a = this.collectItemsFromIndices(n, i);
+				return this.persistSearchResult(a, r, o), a.items;
+			}
+			this.recordFallbackQuery(a);
+			let t = this.searchLinearSingleField(this.dataset, e, r, null, i);
+			return this.persistSearchResult(t, r, o), t.items;
+		}
+		this.flatIndexes.size || this.warnAboutFallback(a, r, this.indexedFields.size > 0 ? `field "${e}" is not backed by an active index` : "no indexed fields are configured");
+		let f = d();
+		if (this.flatIndexes.size > 0 && f !== null) {
+			if (!this.flatIndexes.has(e)) return [];
+			this.recordIndexedQuery();
+			let t = this.searchFieldWithPreparedQuery(e, r, f, i);
+			return this.persistSearchResult(t, r, o), t.items;
+		}
+		this.recordFallbackQuery(a);
+		let p = this.searchLinearSingleField(this.dataset, e, r, null, i);
+		return this.persistSearchResult(p, r, o), p.items;
+	}
+	searchFieldWithPreparedQuery(e, t, n, r, i = null, a = null) {
+		let o = this.searchFieldWithPreparedQueryIndices(e, t, n, i, a, r.take);
+		return this.collectItemsFromIndices(o, r);
+	}
+	searchFieldWithPreparedQueryIndices(e, t, n, r = null, i = null, a = Infinity) {
+		let c = this.getResolvedFlatIndex(e);
+		if (!c) return [];
+		let { ngramMap: l, normalizedValues: u } = c;
+		return i === null ? o(l, n, u, t, {
+			restrictionLookup: r,
+			take: a
+		}) : s(l, n, u, t, {
+			candidateIndices: i,
+			restrictionLookup: r,
+			take: a
+		});
+	}
+	getIndexedFieldsList() {
+		return this.cachedIndexedFieldsList === null && (this.cachedIndexedFieldsList = Array.from(this.indexedFields)), this.cachedIndexedFieldsList;
+	}
+	materializeIndicesResult(e) {
+		let t = [];
+		for (let n = 0; n < e.length; n++) {
+			let r = this.dataset[e[n]];
+			r && t.push(r);
+		}
+		return {
+			items: t,
+			indices: e
+		};
+	}
+	getLinearSearchFields(e) {
+		let t = this.getIndexedFieldsList();
+		return t.length > 0 ? t : (this.cachedLinearSearchFieldsList === null && (this.cachedLinearSearchFieldsList = e.length ? Object.keys(e[0]).filter((t) => typeof e[0][t] == "string") : []), this.cachedLinearSearchFieldsList);
+	}
+	buildNormalizedValuesOnly(e, t) {
+		let n = Array(e.length);
+		for (let r = 0, i = e.length; r < i; r++) {
+			let i = e[r][t];
+			typeof i == "string" && (n[r] = i.toLowerCase());
+		}
+		return this.normalizedValuesCache.set(t, n), n;
+	}
+	buildCombinedNormalizedValues(e, t) {
+		let n = Array(e.length);
+		for (let r = 0; r < e.length; r++) n[r] = this.buildCombinedNormalizedValue(e[r], t);
+		return this.combinedNormalizedValuesCache = {
+			fieldsKey: t.join("\0"),
+			values: n
+		}, n;
+	}
+	buildCombinedNormalizedValue(e, t) {
+		let n = "";
+		for (let r = 0; r < t.length; r++) {
+			let i = e[t[r]];
+			typeof i == "string" && (n && (n += "\n"), n += i.toLowerCase());
+		}
+		return n;
+	}
+	getCombinedNormalizedValues(e, t) {
+		if (e !== this.dataset) return null;
+		let n = t.join("\0");
+		return this.combinedNormalizedValuesCache?.fieldsKey === n ? this.combinedNormalizedValuesCache.values : this.buildCombinedNormalizedValues(e, t);
+	}
+	invalidateNormalizedValuesCacheEntry(e, t) {
+		for (let [n, r] of this.normalizedValuesCache) {
+			let i = t[n];
+			r[e] = typeof i == "string" ? i.toLowerCase() : "";
+		}
+		if (this.combinedNormalizedValuesCache !== null) {
+			let n = this.combinedNormalizedValuesCache.fieldsKey.split("\0");
+			this.combinedNormalizedValuesCache.values[e] = this.buildCombinedNormalizedValue(t, n);
+		}
+	}
+	searchLinearAllFields(e, t, n, r) {
+		if (!e.length) return {
+			items: [],
+			indices: []
+		};
+		let i = this.getLinearSearchFields(e), a = e === this.dataset, o = i.length, s = Array(o);
+		for (let t = 0; t < o; t++) {
+			let n = i[t], r = this.flatIndexes.get(n);
+			if (r) s[t] = r.normalizedValues;
+			else {
+				let r = this.normalizedValuesCache.get(n);
+				r ? s[t] = r : a ? s[t] = this.buildNormalizedValuesOnly(e, n) : s[t] = null;
+			}
+		}
+		let c = this.nestedCollection.hasRegisteredFields(), l = c ? null : this.getCombinedNormalizedValues(e, i), u = !c && s.every((e) => e !== null), d = [], f = 0;
+		if (n !== null) {
+			let e = this.dataset;
+			if (l !== null) {
+				for (let e = 0; e < n.length; e++) {
+					let i = n[e];
+					if (l[i]?.includes(t)) {
+						if (f < r.offset) {
+							f += 1;
+							continue;
+						}
+						if (d.push(i), f += 1, this.hasReachedWindowLimit(r, d.length)) break;
+					}
+				}
+				return this.materializeIndicesResult(d);
+			}
+			if (u) {
+				for (let e = 0; e < n.length; e++) {
+					let i = n[e], a = !1;
+					for (let e = 0; e < o; e++) {
+						let n = s[e][i];
+						if (n && n.includes(t)) {
+							a = !0;
+							break;
+						}
+					}
+					if (a) {
+						if (f < r.offset) {
+							f += 1;
+							continue;
+						}
+						if (d.push(i), f += 1, this.hasReachedWindowLimit(r, d.length)) break;
+					}
+				}
+				return this.materializeIndicesResult(d);
+			}
+			for (let a = 0; a < n.length; a++) {
+				let l = n[a], u = e[l], p = !1;
+				for (let e = 0; e < o; e++) {
+					let n = s[e];
+					if (n) {
+						let e = n[l];
+						if (e && e.includes(t)) {
+							p = !0;
+							break;
+						}
+					} else {
+						let n = u[i[e]];
+						if (typeof n == "string" && n.toLowerCase().includes(t)) {
+							p = !0;
+							break;
+						}
+					}
+				}
+				if (!p && c && (p = this.nestedCollection.matchesAnyField(u, t)), p) {
+					if (f < r.offset) {
+						f += 1;
+						continue;
+					}
+					if (d.push(l), f += 1, this.hasReachedWindowLimit(r, d.length)) break;
+				}
+			}
+			return this.materializeIndicesResult(d);
+		}
+		if (l !== null) {
+			for (let n = 0; n < e.length; n++) if (l[n]?.includes(t)) {
+				if (f < r.offset) {
+					f += 1;
+					continue;
+				}
+				if (d.push(n), f += 1, this.hasReachedWindowLimit(r, d.length)) break;
+			}
+			return this.materializeIndicesResult(d);
+		}
+		if (u) {
+			for (let n = 0; n < e.length; n++) {
+				let e = !1;
+				for (let r = 0; r < o; r++) {
+					let i = s[r][n];
+					if (i && i.includes(t)) {
+						e = !0;
+						break;
+					}
+				}
+				if (e) {
+					if (f < r.offset) {
+						f += 1;
+						continue;
+					}
+					if (d.push(n), f += 1, this.hasReachedWindowLimit(r, d.length)) break;
+				}
+			}
+			return this.materializeIndicesResult(d);
+		}
+		for (let n = 0; n < e.length; n++) {
+			let a = e[n], l = !1;
+			for (let e = 0; e < o; e++) {
+				let r = s[e];
+				if (r) {
+					let e = r[n];
+					if (e && e.includes(t)) {
+						l = !0;
+						break;
+					}
+				} else {
+					let n = a[i[e]];
+					if (typeof n == "string" && n.toLowerCase().includes(t)) {
+						l = !0;
+						break;
+					}
+				}
+			}
+			if (!l && c && (l = this.nestedCollection.matchesAnyField(a, t)), l) {
+				if (f < r.offset) {
+					f += 1;
+					continue;
+				}
+				if (d.push(n), f += 1, this.hasReachedWindowLimit(r, d.length)) break;
+			}
+		}
+		return this.materializeIndicesResult(d);
+	}
+	searchLinearSingleField(e, t, n, r, i) {
+		if (!e.length) return {
+			items: [],
+			indices: []
+		};
+		if (this.nestedCollection.hasField(t)) {
+			let a = this.nestedCollection.searchFieldLinearIndices(e, t, n, r ?? void 0);
+			return this.collectItemsFromIndices(a, i);
+		}
+		let a = [], o = this.flatIndexes.get(t), s = o ? o.normalizedValues : this.normalizedValuesCache.get(t) ?? (e === this.dataset ? this.buildNormalizedValuesOnly(e, t) : null), c = 0;
+		if (r !== null) {
+			let e = this.dataset;
+			if (s) {
+				for (let e = 0; e < r.length; e++) {
+					let t = r[e];
+					if (s[t]?.includes(n)) {
+						if (c < i.offset) {
+							c += 1;
+							continue;
+						}
+						if (a.push(t), c += 1, this.hasReachedWindowLimit(i, a.length)) break;
+					}
+				}
+				return this.materializeIndicesResult(a);
+			}
+			for (let o = 0; o < r.length; o++) {
+				let s = r[o], l = e[s];
+				if (typeof l[t] == "string" && l[t].toLowerCase().includes(n)) {
+					if (c < i.offset) {
+						c += 1;
+						continue;
+					}
+					if (a.push(s), c += 1, this.hasReachedWindowLimit(i, a.length)) break;
+				}
+			}
+			return this.materializeIndicesResult(a);
+		}
+		if (s) {
+			for (let t = 0; t < e.length; t++) if (s[t]?.includes(n)) {
+				if (c < i.offset) {
+					c += 1;
+					continue;
+				}
+				if (a.push(t), c += 1, this.hasReachedWindowLimit(i, a.length)) break;
+			}
+			return this.materializeIndicesResult(a);
+		}
+		for (let r = 0; r < e.length; r++) if (typeof e[r][t] == "string" && e[r][t].toLowerCase().includes(n)) {
+			if (c < i.offset) {
+				c += 1;
+				continue;
+			}
+			if (a.push(r), c += 1, this.hasReachedWindowLimit(i, a.length)) break;
+		}
+		return this.materializeIndicesResult(a);
+	}
+	clearIndexes() {
+		return this.flatIndexes.clear(), this.nestedCollection.clearIndexes(), this.normalizedValuesCache.clear(), this.combinedNormalizedValuesCache = null, this;
+	}
+	getOriginData() {
+		return this.state.getOriginData();
+	}
+	data(e) {
+		return this.state.data(e), this;
+	}
+	add(e) {
+		return this.state.add(e), this;
+	}
+	update(e) {
+		return this.state.update(e), this;
+	}
+	applyAddedItems(e, t) {
+		if (e.length === 0) return this;
+		for (let n of this.indexedFields) this.addItemsToField(n, e, t);
+		return this.nestedCollection.addItems(e, t), this;
+	}
+	clearData() {
+		return this.state.clearData(), this;
+	}
+	handleStateMutation(e) {
+		if (this.shouldDeferMutationIndexUpdates() && (e.type === "add" || e.type === "update")) {
+			this.markDeferredMutationState();
+			return;
+		}
+		switch (e.type) {
+			case "add":
+				this.applyAddedItems(e.items, e.startIndex);
+				for (let [t, n] of this.normalizedValuesCache) for (let r = 0; r < e.items.length; r++) {
+					let i = e.items[r][t];
+					n[e.startIndex + r] = typeof i == "string" ? i.toLowerCase() : "";
+				}
+				this.combinedNormalizedValuesCache = null, this.clearPreviousSearchState();
+				return;
+			case "update":
+				this.applyUpdatedItem(e.index, e.previousItem, e.nextItem), this.invalidateNormalizedValuesCacheEntry(e.index, e.nextItem), this.clearPreviousSearchState();
+				return;
+			case "data":
+				this.runtime.deferredMutationVersion = null, this.rebuildConfiguredIndexes(), this.combinedNormalizedValuesCache = null, this.clearPreviousSearchState();
+				return;
+			case "clearData":
+				this.runtime.deferredMutationVersion = null, this.flatIndexes.clear(), this.nestedCollection.clearIndexes(), this.cachedLinearSearchFieldsList = null, this.normalizedValuesCache.clear(), this.combinedNormalizedValuesCache = null, this.clearPreviousSearchState();
+				return;
+			case "remove":
+				this.applyRemovedItem(e.removedItem, e.removedIndex, e.movedItem, e.movedFromIndex), this.cachedLinearSearchFieldsList = null, this.normalizedValuesCache.clear(), this.combinedNormalizedValuesCache = null, this.clearPreviousSearchState();
+				return;
+			case "removeMany":
+				for (let t = 0; t < e.entries.length; t++) {
+					let n = e.entries[t];
+					this.applyRemovedItem(n.removedItem, n.removedIndex, n.movedItem, n.movedFromIndex);
+				}
+				this.cachedLinearSearchFieldsList = null, this.normalizedValuesCache.clear(), this.combinedNormalizedValuesCache = null, this.clearPreviousSearchState();
+				return;
+		}
+	}
+	addItemsToField(e, t, n) {
+		let r = this.flatIndexes.get(e);
+		if (!r) return;
+		let { ngramMap: i, normalizedValues: o } = r;
+		for (let r = 0; r < t.length; r++) {
+			let s = t[r][e];
+			if (typeof s != "string") continue;
+			let c = s.toLowerCase(), l = n + r;
+			o[l] = c, a(i, c, l);
+		}
+		r.version = this.state.getMutationVersion();
+	}
+	applyUpdatedItem(e, t, n) {
+		for (let r of this.indexedFields) this.updateIndexedField(r, e, t, n);
+		this.nestedCollection.updateItem(n, t, e);
+	}
+	applyRemovedItem(e, t, n, r) {
+		for (let i of this.indexedFields) this.removeIndexedFieldValue(i, e, t), n !== null && r !== null && this.moveIndexedFieldValue(i, n, r, t);
+		this.nestedCollection.removeItem(e, t), n !== null && r !== null && this.nestedCollection.moveItem(n, r, t);
+	}
+	updateIndexedField(e, t, n, r) {
+		let i = this.flatIndexes.get(e);
+		if (!i) return;
+		if (n[e] === r[e]) {
+			i.version = this.state.getMutationVersion();
+			return;
+		}
+		let { ngramMap: o, normalizedValues: s } = i, l = this.getNormalizedFieldValue(n, e);
+		l && c(o, l, t);
+		let u = this.getNormalizedFieldValue(r, e);
+		if (!u) {
+			delete s[t], i.version = this.state.getMutationVersion();
+			return;
+		}
+		s[t] = u, a(o, u, t), i.version = this.state.getMutationVersion();
+	}
+	removeIndexedFieldValue(e, t, n) {
+		let r = this.flatIndexes.get(e);
+		if (!r) return;
+		let { ngramMap: i, normalizedValues: a } = r, o = this.getNormalizedFieldValue(t, e);
+		o && c(i, o, n), delete a[n], r.version = this.state.getMutationVersion();
+	}
+	moveIndexedFieldValue(e, t, n, r) {
+		if (n === r) return;
+		let i = this.flatIndexes.get(e);
+		if (!i) return;
+		let { ngramMap: o, normalizedValues: s } = i, l = s[n] ?? this.getNormalizedFieldValue(t, e);
+		if (!l) {
+			delete s[n], i.version = this.state.getMutationVersion();
+			return;
+		}
+		c(o, l, n), a(o, l, r), s[r] = l, delete s[n], i.version = this.state.getMutationVersion();
+	}
+	getNormalizedFieldValue(e, t) {
+		let n = e[t];
+		return typeof n == "string" ? n.toLowerCase() : null;
+	}
+};
+//#endregion
+export { d as TextSearchEngine };