typerighter 0.3.0 → 0.4.0

package/dist/es-ClqUVRJn.js

@@ -0,0 +1,705 @@
+//#region ../../node_modules/.pnpm/minisearch@7.2.0/node_modules/minisearch/dist/es/index.js
+var e = "KEYS", t = "VALUES", n = class {
+	constructor(e, t) {
+		let n = e._tree, r = Array.from(n.keys());
+		this.set = e, this._type = t, this._path = r.length > 0 ? [{
+			node: n,
+			keys: r
+		}] : [];
+	}
+	next() {
+		let e = this.dive();
+		return this.backtrack(), e;
+	}
+	dive() {
+		if (this._path.length === 0) return {
+			done: !0,
+			value: void 0
+		};
+		let { node: e, keys: t } = r(this._path);
+		if (r(t) === "") return {
+			done: !1,
+			value: this.result()
+		};
+		let n = e.get(r(t));
+		return this._path.push({
+			node: n,
+			keys: Array.from(n.keys())
+		}), this.dive();
+	}
+	backtrack() {
+		if (this._path.length === 0) return;
+		let e = r(this._path).keys;
+		e.pop(), !(e.length > 0) && (this._path.pop(), this.backtrack());
+	}
+	key() {
+		return this.set._prefix + this._path.map(({ keys: e }) => r(e)).filter((e) => e !== "").join("");
+	}
+	value() {
+		return r(this._path).node.get("");
+	}
+	result() {
+		switch (this._type) {
+			case t: return this.value();
+			case e: return this.key();
+			default: return [this.key(), this.value()];
+		}
+	}
+	[Symbol.iterator]() {
+		return this;
+	}
+}, r = (e) => e[e.length - 1], i = (e, t, n) => {
+	let r = /* @__PURE__ */ new Map();
+	if (t === void 0) return r;
+	let i = t.length + 1, o = i + n, s = new Uint8Array(o * i).fill(n + 1);
+	for (let e = 0; e < i; ++e) s[e] = e;
+	for (let e = 1; e < o; ++e) s[e * i] = e;
+	return a(e, t, n, r, s, 1, i, ""), r;
+}, a = (e, t, n, r, i, o, s, c) => {
+	let l = o * s;
+	key: for (let u of e.keys()) if (u === "") {
+		let t = i[l - 1];
+		t <= n && r.set(c, [e.get(u), t]);
+	} else {
+		let l = o;
+		for (let e = 0; e < u.length; ++e, ++l) {
+			let r = u[e], a = s * l, o = a - s, c = i[a], d = Math.max(0, l - n - 1), f = Math.min(s - 1, l + n);
+			for (let e = d; e < f; ++e) {
+				let n = r !== t[e], s = i[o + e] + +n, l = i[o + e + 1] + 1, u = i[a + e] + 1, d = i[a + e + 1] = Math.min(s, l, u);
+				d < c && (c = d);
+			}
+			if (c > n) continue key;
+		}
+		a(e.get(u), t, n, r, i, l, s, c + u);
+	}
+}, o = class r {
+	constructor(e = /* @__PURE__ */ new Map(), t = "") {
+		this._size = void 0, this._tree = e, this._prefix = t;
+	}
+	atPrefix(e) {
+		if (!e.startsWith(this._prefix)) throw Error("Mismatched prefix");
+		let [t, n] = s(this._tree, e.slice(this._prefix.length));
+		if (t === void 0) {
+			let [t, i] = p(n);
+			for (let n of t.keys()) if (n !== "" && n.startsWith(i)) {
+				let a = /* @__PURE__ */ new Map();
+				return a.set(n.slice(i.length), t.get(n)), new r(a, e);
+			}
+		}
+		return new r(t, e);
+	}
+	clear() {
+		this._size = void 0, this._tree.clear();
+	}
+	delete(e) {
+		return this._size = void 0, u(this._tree, e);
+	}
+	entries() {
+		return new n(this, "ENTRIES");
+	}
+	forEach(e) {
+		for (let [t, n] of this) e(t, n, this);
+	}
+	fuzzyGet(e, t) {
+		return i(this._tree, e, t);
+	}
+	get(e) {
+		let t = c(this._tree, e);
+		return t === void 0 ? void 0 : t.get("");
+	}
+	has(e) {
+		let t = c(this._tree, e);
+		return t !== void 0 && t.has("");
+	}
+	keys() {
+		return new n(this, e);
+	}
+	set(e, t) {
+		if (typeof e != "string") throw Error("key must be a string");
+		return this._size = void 0, l(this._tree, e).set("", t), this;
+	}
+	get size() {
+		if (this._size) return this._size;
+		this._size = 0;
+		let e = this.entries();
+		for (; !e.next().done;) this._size += 1;
+		return this._size;
+	}
+	update(e, t) {
+		if (typeof e != "string") throw Error("key must be a string");
+		this._size = void 0;
+		let n = l(this._tree, e);
+		return n.set("", t(n.get(""))), this;
+	}
+	fetch(e, t) {
+		if (typeof e != "string") throw Error("key must be a string");
+		this._size = void 0;
+		let n = l(this._tree, e), r = n.get("");
+		return r === void 0 && n.set("", r = t()), r;
+	}
+	values() {
+		return new n(this, t);
+	}
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+	static from(e) {
+		let t = new r();
+		for (let [n, r] of e) t.set(n, r);
+		return t;
+	}
+	static fromObject(e) {
+		return r.from(Object.entries(e));
+	}
+}, s = (e, t, n = []) => {
+	if (t.length === 0 || e == null) return [e, n];
+	for (let r of e.keys()) if (r !== "" && t.startsWith(r)) return n.push([e, r]), s(e.get(r), t.slice(r.length), n);
+	return n.push([e, t]), s(void 0, "", n);
+}, c = (e, t) => {
+	if (t.length === 0 || e == null) return e;
+	for (let n of e.keys()) if (n !== "" && t.startsWith(n)) return c(e.get(n), t.slice(n.length));
+}, l = (e, t) => {
+	let n = t.length;
+	outer: for (let r = 0; e && r < n;) {
+		for (let i of e.keys()) if (i !== "" && t[r] === i[0]) {
+			let a = Math.min(n - r, i.length), o = 1;
+			for (; o < a && t[r + o] === i[o];) ++o;
+			let s = e.get(i);
+			if (o === i.length) e = s;
+			else {
+				let n = /* @__PURE__ */ new Map();
+				n.set(i.slice(o), s), e.set(t.slice(r, r + o), n), e.delete(i), e = n;
+			}
+			r += o;
+			continue outer;
+		}
+		let i = /* @__PURE__ */ new Map();
+		return e.set(t.slice(r), i), i;
+	}
+	return e;
+}, u = (e, t) => {
+	let [n, r] = s(e, t);
+	if (n !== void 0) {
+		if (n.delete(""), n.size === 0) d(r);
+		else if (n.size === 1) {
+			let [e, t] = n.entries().next().value;
+			f(r, e, t);
+		}
+	}
+}, d = (e) => {
+	if (e.length === 0) return;
+	let [t, n] = p(e);
+	if (t.delete(n), t.size === 0) d(e.slice(0, -1));
+	else if (t.size === 1) {
+		let [n, r] = t.entries().next().value;
+		n !== "" && f(e.slice(0, -1), n, r);
+	}
+}, f = (e, t, n) => {
+	if (e.length === 0) return;
+	let [r, i] = p(e);
+	r.set(i + t, n), r.delete(i);
+}, p = (e) => e[e.length - 1], m = "or", h = "and", g = "and_not", _ = class e {
+	constructor(e) {
+		if (e?.fields == null) throw Error("MiniSearch: option \"fields\" must be provided");
+		let t = e.autoVacuum == null || e.autoVacuum === !0 ? O : e.autoVacuum;
+		this._options = {
+			...C,
+			...e,
+			autoVacuum: t,
+			searchOptions: {
+				...w,
+				...e.searchOptions || {}
+			},
+			autoSuggestOptions: {
+				...T,
+				...e.autoSuggestOptions || {}
+			}
+		}, this._index = new o(), this._documentCount = 0, this._documentIds = /* @__PURE__ */ new Map(), this._idToShortId = /* @__PURE__ */ new Map(), this._fieldIds = {}, this._fieldLength = /* @__PURE__ */ new Map(), this._avgFieldLength = [], this._nextId = 0, this._storedFields = /* @__PURE__ */ new Map(), this._dirtCount = 0, this._currentVacuum = null, this._enqueuedVacuum = null, this._enqueuedVacuumConditions = D, this.addFields(this._options.fields);
+	}
+	add(e) {
+		let { extractField: t, stringifyField: n, tokenize: r, processTerm: i, fields: a, idField: o } = this._options, s = t(e, o);
+		if (s == null) throw Error(`MiniSearch: document does not have ID field "${o}"`);
+		if (this._idToShortId.has(s)) throw Error(`MiniSearch: duplicate ID ${s}`);
+		let c = this.addDocumentId(s);
+		this.saveStoredFields(c, e);
+		for (let o of a) {
+			let a = t(e, o);
+			if (a == null) continue;
+			let s = r(n(a, o), o), l = this._fieldIds[o], u = new Set(s).size;
+			this.addFieldLength(c, l, this._documentCount - 1, u);
+			for (let e of s) {
+				let t = i(e, o);
+				if (Array.isArray(t)) for (let e of t) this.addTerm(l, c, e);
+				else t && this.addTerm(l, c, t);
+			}
+		}
+	}
+	addAll(e) {
+		for (let t of e) this.add(t);
+	}
+	addAllAsync(e, t = {}) {
+		let { chunkSize: n = 10 } = t, r = {
+			chunk: [],
+			promise: Promise.resolve()
+		}, { chunk: i, promise: a } = e.reduce(({ chunk: e, promise: t }, r, i) => (e.push(r), (i + 1) % n === 0 ? {
+			chunk: [],
+			promise: t.then(() => new Promise((e) => setTimeout(e, 0))).then(() => this.addAll(e))
+		} : {
+			chunk: e,
+			promise: t
+		}), r);
+		return a.then(() => this.addAll(i));
+	}
+	remove(e) {
+		let { tokenize: t, processTerm: n, extractField: r, stringifyField: i, fields: a, idField: o } = this._options, s = r(e, o);
+		if (s == null) throw Error(`MiniSearch: document does not have ID field "${o}"`);
+		let c = this._idToShortId.get(s);
+		if (c == null) throw Error(`MiniSearch: cannot remove document with ID ${s}: it is not in the index`);
+		for (let o of a) {
+			let a = r(e, o);
+			if (a == null) continue;
+			let s = t(i(a, o), o), l = this._fieldIds[o], u = new Set(s).size;
+			this.removeFieldLength(c, l, this._documentCount, u);
+			for (let e of s) {
+				let t = n(e, o);
+				if (Array.isArray(t)) for (let e of t) this.removeTerm(l, c, e);
+				else t && this.removeTerm(l, c, t);
+			}
+		}
+		this._storedFields.delete(c), this._documentIds.delete(c), this._idToShortId.delete(s), this._fieldLength.delete(c), --this._documentCount;
+	}
+	removeAll(e) {
+		if (e) for (let t of e) this.remove(t);
+		else if (arguments.length > 0) throw Error("Expected documents to be present. Omit the argument to remove all documents.");
+		else this._index = new o(), this._documentCount = 0, this._documentIds = /* @__PURE__ */ new Map(), this._idToShortId = /* @__PURE__ */ new Map(), this._fieldLength = /* @__PURE__ */ new Map(), this._avgFieldLength = [], this._storedFields = /* @__PURE__ */ new Map(), this._nextId = 0;
+	}
+	discard(e) {
+		let t = this._idToShortId.get(e);
+		if (t == null) throw Error(`MiniSearch: cannot discard document with ID ${e}: it is not in the index`);
+		this._idToShortId.delete(e), this._documentIds.delete(t), this._storedFields.delete(t), (this._fieldLength.get(t) || []).forEach((e, n) => {
+			this.removeFieldLength(t, n, this._documentCount, e);
+		}), this._fieldLength.delete(t), --this._documentCount, this._dirtCount += 1, this.maybeAutoVacuum();
+	}
+	maybeAutoVacuum() {
+		if (this._options.autoVacuum === !1) return;
+		let { minDirtFactor: e, minDirtCount: t, batchSize: n, batchWait: r } = this._options.autoVacuum;
+		this.conditionalVacuum({
+			batchSize: n,
+			batchWait: r
+		}, {
+			minDirtCount: t,
+			minDirtFactor: e
+		});
+	}
+	discardAll(e) {
+		let t = this._options.autoVacuum;
+		try {
+			this._options.autoVacuum = !1;
+			for (let t of e) this.discard(t);
+		} finally {
+			this._options.autoVacuum = t;
+		}
+		this.maybeAutoVacuum();
+	}
+	replace(e) {
+		let { idField: t, extractField: n } = this._options, r = n(e, t);
+		this.discard(r), this.add(e);
+	}
+	vacuum(e = {}) {
+		return this.conditionalVacuum(e);
+	}
+	conditionalVacuum(e, t) {
+		return this._currentVacuum ? (this._enqueuedVacuumConditions = this._enqueuedVacuumConditions && t, this._enqueuedVacuum ??= this._currentVacuum.then(() => {
+			let t = this._enqueuedVacuumConditions;
+			return this._enqueuedVacuumConditions = D, this.performVacuuming(e, t);
+		}), this._enqueuedVacuum) : this.vacuumConditionsMet(t) === !1 ? Promise.resolve() : (this._currentVacuum = this.performVacuuming(e), this._currentVacuum);
+	}
+	async performVacuuming(e, t) {
+		let n = this._dirtCount;
+		if (this.vacuumConditionsMet(t)) {
+			let t = e.batchSize || E.batchSize, r = e.batchWait || E.batchWait, i = 1;
+			for (let [e, n] of this._index) {
+				for (let [e, t] of n) for (let [r] of t) this._documentIds.has(r) || (t.size <= 1 ? n.delete(e) : t.delete(r));
+				this._index.get(e).size === 0 && this._index.delete(e), i % t === 0 && await new Promise((e) => setTimeout(e, r)), i += 1;
+			}
+			this._dirtCount -= n;
+		}
+		await null, this._currentVacuum = this._enqueuedVacuum, this._enqueuedVacuum = null;
+	}
+	vacuumConditionsMet(e) {
+		if (e == null) return !0;
+		let { minDirtCount: t, minDirtFactor: n } = e;
+		return t ||= O.minDirtCount, n ||= O.minDirtFactor, this.dirtCount >= t && this.dirtFactor >= n;
+	}
+	get isVacuuming() {
+		return this._currentVacuum != null;
+	}
+	get dirtCount() {
+		return this._dirtCount;
+	}
+	get dirtFactor() {
+		return this._dirtCount / (1 + this._documentCount + this._dirtCount);
+	}
+	has(e) {
+		return this._idToShortId.has(e);
+	}
+	getStoredFields(e) {
+		let t = this._idToShortId.get(e);
+		if (t != null) return this._storedFields.get(t);
+	}
+	search(t, n = {}) {
+		let { searchOptions: r } = this._options, i = {
+			...r,
+			...n
+		}, a = this.executeQuery(t, n), o = [];
+		for (let [e, { score: t, terms: n, match: r }] of a) {
+			let a = n.length || 1, s = {
+				id: this._documentIds.get(e),
+				score: t * a,
+				terms: Object.keys(r),
+				queryTerms: n,
+				match: r
+			};
+			Object.assign(s, this._storedFields.get(e)), (i.filter == null || i.filter(s)) && o.push(s);
+		}
+		return t === e.wildcard && i.boostDocument == null || o.sort(j), o;
+	}
+	autoSuggest(e, t = {}) {
+		t = {
+			...this._options.autoSuggestOptions,
+			...t
+		};
+		let n = /* @__PURE__ */ new Map();
+		for (let { score: r, terms: i } of this.search(e, t)) {
+			let e = i.join(" "), t = n.get(e);
+			t == null ? n.set(e, {
+				score: r,
+				terms: i,
+				count: 1
+			}) : (t.score += r, t.count += 1);
+		}
+		let r = [];
+		for (let [e, { score: t, terms: i, count: a }] of n) r.push({
+			suggestion: e,
+			terms: i,
+			score: t / a
+		});
+		return r.sort(j), r;
+	}
+	get documentCount() {
+		return this._documentCount;
+	}
+	get termCount() {
+		return this._index.size;
+	}
+	static loadJSON(e, t) {
+		if (t == null) throw Error("MiniSearch: loadJSON should be given the same options used when serializing the index");
+		return this.loadJS(JSON.parse(e), t);
+	}
+	static async loadJSONAsync(e, t) {
+		if (t == null) throw Error("MiniSearch: loadJSON should be given the same options used when serializing the index");
+		return this.loadJSAsync(JSON.parse(e), t);
+	}
+	static getDefault(e) {
+		if (C.hasOwnProperty(e)) return v(C, e);
+		throw Error(`MiniSearch: unknown option "${e}"`);
+	}
+	static loadJS(e, t) {
+		let { index: n, documentIds: r, fieldLength: i, storedFields: a, serializationVersion: o } = e, s = this.instantiateMiniSearch(e, t);
+		s._documentIds = N(r), s._fieldLength = N(i), s._storedFields = N(a);
+		for (let [e, t] of s._documentIds) s._idToShortId.set(t, e);
+		for (let [e, t] of n) {
+			let n = /* @__PURE__ */ new Map();
+			for (let e of Object.keys(t)) {
+				let r = t[e];
+				o === 1 && (r = r.ds), n.set(parseInt(e, 10), N(r));
+			}
+			s._index.set(e, n);
+		}
+		return s;
+	}
+	static async loadJSAsync(e, t) {
+		let { index: n, documentIds: r, fieldLength: i, storedFields: a, serializationVersion: o } = e, s = this.instantiateMiniSearch(e, t);
+		s._documentIds = await P(r), s._fieldLength = await P(i), s._storedFields = await P(a);
+		for (let [e, t] of s._documentIds) s._idToShortId.set(t, e);
+		let c = 0;
+		for (let [e, t] of n) {
+			let n = /* @__PURE__ */ new Map();
+			for (let e of Object.keys(t)) {
+				let r = t[e];
+				o === 1 && (r = r.ds), n.set(parseInt(e, 10), await P(r));
+			}
+			++c % 1e3 == 0 && await F(0), s._index.set(e, n);
+		}
+		return s;
+	}
+	static instantiateMiniSearch(t, n) {
+		let { documentCount: r, nextId: i, fieldIds: a, averageFieldLength: s, dirtCount: c, serializationVersion: l } = t;
+		if (l !== 1 && l !== 2) throw Error("MiniSearch: cannot deserialize an index created with an incompatible version");
+		let u = new e(n);
+		return u._documentCount = r, u._nextId = i, u._idToShortId = /* @__PURE__ */ new Map(), u._fieldIds = a, u._avgFieldLength = s, u._dirtCount = c || 0, u._index = new o(), u;
+	}
+	executeQuery(t, n = {}) {
+		if (t === e.wildcard) return this.executeWildcardQuery(n);
+		if (typeof t != "string") {
+			let e = {
+				...n,
+				...t,
+				queries: void 0
+			}, r = t.queries.map((t) => this.executeQuery(t, e));
+			return this.combineResults(r, e.combineWith);
+		}
+		let { tokenize: r, processTerm: i, searchOptions: a } = this._options, o = {
+			tokenize: r,
+			processTerm: i,
+			...a,
+			...n
+		}, { tokenize: s, processTerm: c } = o, l = s(t).flatMap((e) => c(e)).filter((e) => !!e).map(S(o)).map((e) => this.executeQuerySpec(e, o));
+		return this.combineResults(l, o.combineWith);
+	}
+	executeQuerySpec(e, t) {
+		let n = {
+			...this._options.searchOptions,
+			...t
+		}, r = (n.fields || this._options.fields).reduce((e, t) => ({
+			...e,
+			[t]: v(n.boost, t) || 1
+		}), {}), { boostDocument: i, weights: a, maxFuzzy: o, bm25: s } = n, { fuzzy: c, prefix: l } = {
+			...w.weights,
+			...a
+		}, u = this._index.get(e.term), d = this.termResults(e.term, e.term, 1, e.termBoost, u, r, i, s), f, p;
+		if (e.prefix && (f = this._index.atPrefix(e.term)), e.fuzzy) {
+			let t = e.fuzzy === !0 ? .2 : e.fuzzy, n = t < 1 ? Math.min(o, Math.round(e.term.length * t)) : t;
+			n && (p = this._index.fuzzyGet(e.term, n));
+		}
+		if (f) for (let [t, n] of f) {
+			let a = t.length - e.term.length;
+			if (!a) continue;
+			p?.delete(t);
+			let o = l * t.length / (t.length + .3 * a);
+			this.termResults(e.term, t, o, e.termBoost, n, r, i, s, d);
+		}
+		if (p) for (let t of p.keys()) {
+			let [n, a] = p.get(t);
+			if (!a) continue;
+			let o = c * t.length / (t.length + a);
+			this.termResults(e.term, t, o, e.termBoost, n, r, i, s, d);
+		}
+		return d;
+	}
+	executeWildcardQuery(e) {
+		let t = /* @__PURE__ */ new Map(), n = {
+			...this._options.searchOptions,
+			...e
+		};
+		for (let [e, r] of this._documentIds) {
+			let i = n.boostDocument ? n.boostDocument(r, "", this._storedFields.get(e)) : 1;
+			t.set(e, {
+				score: i,
+				terms: [],
+				match: {}
+			});
+		}
+		return t;
+	}
+	combineResults(e, t = m) {
+		if (e.length === 0) return /* @__PURE__ */ new Map();
+		let n = y[t.toLowerCase()];
+		if (!n) throw Error(`Invalid combination operator: ${t}`);
+		return e.reduce(n) || /* @__PURE__ */ new Map();
+	}
+	toJSON() {
+		let e = [];
+		for (let [t, n] of this._index) {
+			let r = {};
+			for (let [e, t] of n) r[e] = Object.fromEntries(t);
+			e.push([t, r]);
+		}
+		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: e,
+			serializationVersion: 2
+		};
+	}
+	termResults(e, t, n, r, i, a, o, s, c = /* @__PURE__ */ new Map()) {
+		if (i == null) return c;
+		for (let l of Object.keys(a)) {
+			let u = a[l], d = this._fieldIds[l], f = i.get(d);
+			if (f == null) continue;
+			let p = f.size, m = this._avgFieldLength[d];
+			for (let i of f.keys()) {
+				if (!this._documentIds.has(i)) {
+					this.removeTerm(d, i, t), --p;
+					continue;
+				}
+				let a = o ? o(this._documentIds.get(i), t, this._storedFields.get(i)) : 1;
+				if (!a) continue;
+				let h = f.get(i), g = this._fieldLength.get(i)[d], _ = x(h, p, this._documentCount, g, m, s), y = n * r * u * a * _, b = c.get(i);
+				if (b) {
+					b.score += y, k(b.terms, e);
+					let n = v(b.match, t);
+					n ? n.push(l) : b.match[t] = [l];
+				} else c.set(i, {
+					score: y,
+					terms: [e],
+					match: { [t]: [l] }
+				});
+			}
+		}
+		return c;
+	}
+	addTerm(e, t, n) {
+		let r = this._index.fetch(n, M), i = r.get(e);
+		if (i == null) i = /* @__PURE__ */ new Map(), i.set(t, 1), r.set(e, i);
+		else {
+			let e = i.get(t);
+			i.set(t, (e || 0) + 1);
+		}
+	}
+	removeTerm(e, t, n) {
+		if (!this._index.has(n)) {
+			this.warnDocumentChanged(t, e, n);
+			return;
+		}
+		let r = this._index.fetch(n, M), i = r.get(e);
+		i == null || i.get(t) == null ? this.warnDocumentChanged(t, e, n) : i.get(t) <= 1 ? i.size <= 1 ? r.delete(e) : i.delete(t) : i.set(t, i.get(t) - 1), this._index.get(n).size === 0 && this._index.delete(n);
+	}
+	warnDocumentChanged(e, t, n) {
+		for (let r of Object.keys(this._fieldIds)) if (this._fieldIds[r] === t) {
+			this._options.logger("warn", `MiniSearch: document with ID ${this._documentIds.get(e)} has changed before removal: term "${n}" was not present in field "${r}". Removing a document after it has changed can corrupt the index!`, "version_conflict");
+			return;
+		}
+	}
+	addDocumentId(e) {
+		let t = this._nextId;
+		return this._idToShortId.set(e, t), this._documentIds.set(t, e), this._documentCount += 1, this._nextId += 1, t;
+	}
+	addFields(e) {
+		for (let t = 0; t < e.length; t++) this._fieldIds[e[t]] = t;
+	}
+	addFieldLength(e, t, n, r) {
+		let i = this._fieldLength.get(e);
+		i ?? this._fieldLength.set(e, i = []), i[t] = r;
+		let a = (this._avgFieldLength[t] || 0) * n + r;
+		this._avgFieldLength[t] = a / (n + 1);
+	}
+	removeFieldLength(e, t, n, r) {
+		if (n === 1) {
+			this._avgFieldLength[t] = 0;
+			return;
+		}
+		let i = this._avgFieldLength[t] * n - r;
+		this._avgFieldLength[t] = i / (n - 1);
+	}
+	saveStoredFields(e, t) {
+		let { storeFields: n, extractField: r } = this._options;
+		if (n == null || n.length === 0) return;
+		let i = this._storedFields.get(e);
+		i ?? this._storedFields.set(e, i = {});
+		for (let e of n) {
+			let n = r(t, e);
+			n !== void 0 && (i[e] = n);
+		}
+	}
+};
+_.wildcard = Symbol("*");
+var v = (e, t) => Object.prototype.hasOwnProperty.call(e, t) ? e[t] : void 0, y = {
+	[m]: (e, t) => {
+		for (let n of t.keys()) {
+			let r = e.get(n);
+			if (r == null) e.set(n, t.get(n));
+			else {
+				let { score: e, terms: i, match: a } = t.get(n);
+				r.score += e, r.match = Object.assign(r.match, a), A(r.terms, i);
+			}
+		}
+		return e;
+	},
+	[h]: (e, t) => {
+		let n = /* @__PURE__ */ new Map();
+		for (let r of t.keys()) {
+			let i = e.get(r);
+			if (i == null) continue;
+			let { score: a, terms: o, match: s } = t.get(r);
+			A(i.terms, o), n.set(r, {
+				score: i.score + a,
+				terms: i.terms,
+				match: Object.assign(i.match, s)
+			});
+		}
+		return n;
+	},
+	[g]: (e, t) => {
+		for (let n of t.keys()) e.delete(n);
+		return e;
+	}
+}, b = {
+	k: 1.2,
+	b: .7,
+	d: .5
+}, x = (e, t, n, r, i, a) => {
+	let { k: o, b: s, d: c } = a;
+	return Math.log(1 + (n - t + .5) / (t + .5)) * (c + e * (o + 1) / (e + o * (1 - s + s * r / i)));
+}, S = (e) => (t, n, r) => ({
+	term: t,
+	fuzzy: typeof e.fuzzy == "function" ? e.fuzzy(t, n, r) : e.fuzzy || !1,
+	prefix: typeof e.prefix == "function" ? e.prefix(t, n, r) : e.prefix === !0,
+	termBoost: typeof e.boostTerm == "function" ? e.boostTerm(t, n, r) : 1
+}), C = {
+	idField: "id",
+	extractField: (e, t) => e[t],
+	stringifyField: (e, t) => e.toString(),
+	tokenize: (e) => e.split(I),
+	processTerm: (e) => e.toLowerCase(),
+	fields: void 0,
+	searchOptions: void 0,
+	storeFields: [],
+	logger: (e, t) => {
+		typeof (console == null ? void 0 : console[e]) == "function" && console[e](t);
+	},
+	autoVacuum: !0
+}, w = {
+	combineWith: m,
+	prefix: !1,
+	fuzzy: !1,
+	maxFuzzy: 6,
+	boost: {},
+	weights: {
+		fuzzy: .45,
+		prefix: .375
+	},
+	bm25: b
+}, T = {
+	combineWith: h,
+	prefix: (e, t, n) => t === n.length - 1
+}, E = {
+	batchSize: 1e3,
+	batchWait: 10
+}, D = {
+	minDirtFactor: .1,
+	minDirtCount: 20
+}, O = {
+	...E,
+	...D
+}, k = (e, t) => {
+	e.includes(t) || e.push(t);
+}, A = (e, t) => {
+	for (let n of t) e.includes(n) || e.push(n);
+}, j = ({ score: e }, { score: t }) => t - e, M = () => /* @__PURE__ */ new Map(), N = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of Object.keys(e)) t.set(parseInt(n, 10), e[n]);
+	return t;
+}, P = async (e) => {
+	let t = /* @__PURE__ */ new Map(), n = 0;
+	for (let r of Object.keys(e)) t.set(parseInt(r, 10), e[r]), ++n % 1e3 == 0 && await F(0);
+	return t;
+}, F = (e) => new Promise((t) => setTimeout(t, e)), I = /[\n\r\p{Z}\p{P}]+/u;
+//#endregion
+export { _ as t };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { n as e, t } from "./cli-CoyGXgR1.js";
-import { t as n } from "./vite-BxXQPieu.js";
-import "./plugin-D2xuSVM4.js";
-export { e as buildSite, t as cli, n as typedown };
+import { n as e, t } from "./vite-nzhkELg7.js";
+import "./vite.js";
+import { n, t as r } from "./cli-s44ly0MH.js";
+export { n as buildSite, r as cli, t as generateClientAppEntry, e as typedown };