@mx-space/cli 0.6.8 → 0.7.0

package/dist/{mxs-CCNd5SIa.mjs → mxs-CWdGhWtj.mjs}

@@ -1,4 +1,4 @@
-import { $ as drain, $a as identity, $i as reduce$1, $n as try_, $r as get$11, $t as either, A as compose, Aa as pipeArguments, Ai as empty$11, An as orElse$3, Ar as Scope, At as encodeSync, B as ensuring$1, Ba as cached, Bi as head$2, Bn as scope, Br as set$3, Bt as async, C as Number$, Ca as some, Ci as isConfigError, Cn as match$2, Ct as currentContext, D as String$, Da as left, Di as appendAll, Dn as onError, Dr as taggedEnum, Dt as unsafeMake, Ea as string$1, Ei as append$2, En as negate, Er as tagged, Et as get$15, Fa as redact$1, Fi as findFirstIndex, Fn as retry, Fr as isFailure, Ft as addFinalizer, G as mapError$1, Gi as join$1, Gn as suspend, Gr as updateAs, Gt as catchIf, H as fromChannel, Ha as hash, Hi as isArray$1, Hn as serviceFunctions, Hr as updateAndGet, Ht as catchAll, I as make$21, Ia as symbolRedactable, Ii as findLast, In as runFork$1, Ir as void_$1, It as all$5, J as splitLines, Ja as globalValue, Ji as match$1, Jn as tapError, Jr as cons$1, Jt as catchTags, K as run$5, Ka as isObject, Ki as make$22, Kn as sync, Kr as CommitPrototype, Kt as catchSome, L as isConfig, La as toStringUnknown, Li as flatMap$4, Ln as runPromise, Lr as ParentSpan, Lt as annotateLogs, M as decodeUnknown, Ma as Class, Mi as filter$2, Mn as provide$1, Mr as isInterrupted, Mt as _void, N as int, Na as NodeInspectSymbol, Ni as filterMap, Nn as provideService, Nr as isInterruptedOnly, Nt as acquireRelease, O as TaggedError, Oa as merge$1, Oi as contains, On as onInterrupt, Or as error$1, Ot as nominal, P as optional$7, Pa as format$3, Pi as findFirst, Pn as repeatN, Pr as fail$5, Pt as acquireUseRelease$1, Q as unwrapScoped, Qa as dual, Qi as prepend$1, Qn as tryPromise, Qr as fromIterable$2, Qt as dieMessage, R as asyncScoped, Ra as equals, Ri as fromIterable$1, Rn as runSync, Rr as get$10, Rt as as, S as Literal, Sa as orElse$2, Si as omit, Sn as mapInputContext, Sr as unsafeDone, St as succeed$3, Ta as mapInput, Ti as allocate, Tn as matchEffect, Tr as TaggedError$1, Tt as currentTracerEnabled, Ua as string, Ui as isEmptyReadonlyArray, Un as serviceOption, Ur as allLevels, Ut as catchAllCause, Va as combine$2, Vi as headNonEmpty, Vn as scoped, Vr as update$6, Vt as cached$1, W as mapChunks, Wa as symbol, Wi as isNonEmptyReadonlyArray, Wn as succeed$1, Wr as getOrDefault, Wt as catchAllDefect, X as transduce, Xa as constUndefined, Xi as matchRight, Xn as timeout, Xr as of$3, Xt as contextWithEffect, Y as suspend$1, Ya as constFalse, Yi as matchLeft, Yn as tapErrorCause, Yr as isNil, Yt as context, Z as unwrap$5, Za as constVoid, Zi as of$2, Zn as tryMap, Zr as empty$12, Zt as die, _ as fromString, _a as isOption, _i as Reference, _n as logError, _r as failCause$1, _t as effect, a as make$27, aa as tailNonEmpty, ai as add$1, an as filterOrDieMessage, ar as useSpan, at as embedInput, b as Defect, ba as match, bi as getOption, bn as mapBoth, br as make$26, bt as provideMerge, c as make$25, ci as remove$3, cn as fnUntraced, cr as withParentSpan, ct as fromEffect, d as defaultLogger, da as flatMap$3, di as map$10, dn as forkScoped, dr as zipRight, dt as write, ea as reduceRight, ei as has, en as ensuring, eo as pipe, er as uninterruptible, et as foldLeftChunks, f as prettyLoggerDefault, fa as fromNullable, fi as of$1, fn as gen, fr as zipWith, ft as spaced, g as when, ga as isNone, gi as GenericTag, gn as locally, gr as fail$4, gt as make$30, h as value$1, ha as getOrUndefined, hi as unsafeFromArray, hn as isEffect, hr as complete, ht as get$14, i as isMailbox, ia as splitAt, ii as make$29, in as filter$1, io as __toESM, ir as unsafeMakeSemaphore, it as acquireUseRelease, ja as BaseProto, ji as every, jn as orElseFail, jr as addFinalizer$1, jt as is$2, k as Union, ka as right, ki as drop, kn as orDie, kr as log, kt as decodeSync, l as updateEffect, la as map$9, li as seconds, ln as forEach$1, lr as zip, lt as suspend$2, m as orElse$1, ma as getOrThrow, mi as toArray, mn as interruptible, mr as _await, mt as updateContext, n as make$28, na as sort$2, ni as make$24, nn as failCause, no as __exportAll, nr as unlessEffect, nt as fromChannel$1, o as toChannel, oa as take, oi as fromIterable$3, on as flatMap$1, or as when$1, ot as ensuring$2, p as withMinimumLogLevel, pa as getOrElse, pi as reduce$2, pn as ignore, pr as DeferredTypeId, pt as runFork, q as runCollect, qa as isTagged, qi as map$7, qn as tap, qr as round, qt as catchTag, r as unsafeAdd, ra as span, ri as set$2, rn as failSync, ro as __require, rr as unsafeMakeLatch, rt as unwrapScoped$1, s as get$12, sa as unsafeGet, si as has$1, sn as flatten$3, sr as withFiberRuntime, st as flatMap$2, t as join$2, ta as some$1, ti as isEmpty$5, tn as fail$2, to as __commonJSMin, tr as uninterruptibleMask, tt as forEach, u as unify, ua as filter$3, ui as appendAll$1, un as forkDaemon, ur as zipLeft, ut as void_, v as Cause, va as isSome, vi as Tag$2, vn as logWarning, vr as interrupt, vt as mergeAll, w as NumberFromString, wa as boolean$3, wi as isMissingDataOnly, wn as matchCauseEffect, wr as Error$1, wt as currentLoggers, x as Int, xa as none$3, xi as merge$2, xn as mapError, xr as succeed$2, xt as scoped$1, y as Date$, ya as map$8, yi as get$13, yn as map$6, yr as isDone, yt as provide, z as bufferChunks, za as symbol$1, zi as getSomes, zn as runtime, zr as make$23, zt as asVoid } from "./esm-CK9m5JKX.mjs";
+import { $ as drain, $a as identity, $i as reduce$1, $n as try_, $r as get$11, $t as either, A as compose, Aa as pipeArguments, Ai as empty$11, An as orElse$3, Ar as Scope, At as encodeSync, B as ensuring$1, Ba as cached, Bi as head$2, Bn as scope, Br as set$3, Bt as async, C as Number$, Ca as some, Ci as isConfigError, Cn as match$2, Ct as currentContext, D as String$, Da as left, Di as appendAll, Dn as onError, Dr as taggedEnum, Dt as unsafeMake, Ea as string$1, Ei as append$2, En as negate, Er as tagged, Et as get$15, Fa as redact$1, Fi as findFirstIndex, Fn as retry, Fr as isFailure, Ft as addFinalizer, G as mapError$1, Gi as join$1, Gn as suspend, Gr as updateAs, Gt as catchIf, H as fromChannel, Ha as hash, Hi as isArray$1, Hn as serviceFunctions, Hr as updateAndGet, Ht as catchAll, I as make$21, Ia as symbolRedactable, Ii as findLast, In as runFork$1, Ir as void_$1, It as all$5, J as splitLines, Ja as globalValue, Ji as match$1, Jn as tapError, Jr as cons$1, Jt as catchTags, K as run$5, Ka as isObject, Ki as make$22, Kn as sync, Kr as CommitPrototype, Kt as catchSome, L as isConfig, La as toStringUnknown, Li as flatMap$4, Ln as runPromise, Lr as ParentSpan, Lt as annotateLogs, M as decodeUnknown, Ma as Class, Mi as filter$2, Mn as provide$1, Mr as isInterrupted, Mt as _void, N as int, Na as NodeInspectSymbol, Ni as filterMap, Nn as provideService, Nr as isInterruptedOnly, Nt as acquireRelease, O as TaggedError, Oa as merge$2, Oi as contains, On as onInterrupt, Or as error$1, Ot as nominal, P as optional$7, Pa as format$3, Pi as findFirst, Pn as repeatN, Pr as fail$5, Pt as acquireUseRelease$1, Q as unwrapScoped, Qa as dual, Qi as prepend$1, Qn as tryPromise, Qr as fromIterable$2, Qt as dieMessage, R as asyncScoped, Ra as equals, Ri as fromIterable$1, Rn as runSync, Rr as get$10, Rt as as, S as Literal, Sa as orElse$2, Si as omit, Sn as mapInputContext, Sr as unsafeDone, St as succeed$3, Ta as mapInput, Ti as allocate, Tn as matchEffect, Tr as TaggedError$1, Tt as currentTracerEnabled, Ua as string, Ui as isEmptyReadonlyArray, Un as serviceOption, Ur as allLevels, Ut as catchAllCause, Va as combine$2, Vi as headNonEmpty, Vn as scoped, Vr as update$6, Vt as cached$1, W as mapChunks, Wa as symbol, Wi as isNonEmptyReadonlyArray, Wn as succeed$1, Wr as getOrDefault, Wt as catchAllDefect, X as transduce, Xa as constUndefined, Xi as matchRight, Xn as timeout, Xr as of$3, Xt as contextWithEffect, Y as suspend$1, Ya as constFalse, Yi as matchLeft, Yn as tapErrorCause, Yr as isNil, Yt as context, Z as unwrap$5, Za as constVoid, Zi as of$2, Zn as tryMap, Zr as empty$12, Zt as die, _ as fromString, _a as isOption, _i as Reference, _n as logError, _r as failCause$1, _t as effect, a as make$27, aa as tailNonEmpty, ai as add$1, an as filterOrDieMessage, ar as useSpan, at as embedInput, b as Defect, ba as match, bi as getOption, bn as mapBoth, br as make$26, bt as provideMerge, c as make$25, ci as remove$4, cn as fnUntraced, cr as withParentSpan, ct as fromEffect, d as defaultLogger, da as flatMap$3, di as map$10, dn as forkScoped, dr as zipRight, dt as write, ea as reduceRight, ei as has, en as ensuring, eo as pipe, er as uninterruptible, et as foldLeftChunks, f as prettyLoggerDefault, fa as fromNullable, fi as of$1, fn as gen, fr as zipWith, ft as spaced, g as when, ga as isNone, gi as GenericTag, gn as locally, gr as fail$4, gt as make$30, h as value$1, ha as getOrUndefined, hi as unsafeFromArray, hn as isEffect, hr as complete, ht as get$14, i as isMailbox, ia as splitAt, ii as make$29, in as filter$1, io as __toESM, ir as unsafeMakeSemaphore, it as acquireUseRelease, ja as BaseProto, ji as every, jn as orElseFail, jr as addFinalizer$1, jt as is$2, k as Union, ka as right, ki as drop, kn as orDie, kr as log, kt as decodeSync, l as updateEffect, la as map$9, li as seconds, ln as forEach$1, lr as zip, lt as suspend$2, m as orElse$1, ma as getOrThrow, mi as toArray, mn as interruptible, mr as _await, mt as updateContext, n as make$28, na as sort$2, ni as make$24, nn as failCause, no as __exportAll, nr as unlessEffect, nt as fromChannel$1, o as toChannel, oa as take, oi as fromIterable$3, on as flatMap$1, or as when$1, ot as ensuring$2, p as withMinimumLogLevel, pa as getOrElse, pi as reduce$2, pn as ignore, pr as DeferredTypeId, pt as runFork, q as runCollect, qa as isTagged, qi as map$7, qn as tap, qr as round, qt as catchTag, r as unsafeAdd, ra as span, ri as set$2, rn as failSync, ro as __require, rr as unsafeMakeLatch, rt as unwrapScoped$1, s as get$12, sa as unsafeGet, si as has$1, sn as flatten$3, sr as withFiberRuntime, st as flatMap$2, t as join$2, ta as some$1, ti as isEmpty$5, tn as fail$2, to as __commonJSMin, tr as uninterruptibleMask, tt as forEach, u as unify, ua as filter$3, ui as appendAll$1, un as forkDaemon, ur as zipLeft, ut as void_, v as Cause, va as isSome, vi as Tag$2, vn as logWarning, vr as interrupt, vt as mergeAll, w as NumberFromString, wa as boolean$3, wi as isMissingDataOnly, wn as matchCauseEffect, wr as Error$1, wt as currentLoggers, x as Int, xa as none$3, xi as merge$3, xn as mapError, xr as succeed$2, xt as scoped$1, y as Date$, ya as map$8, yi as get$13, yn as map$6, yr as isDone, yt as provide, z as bufferChunks, za as symbol$1, zi as getSomes, zn as runtime, zr as make$23, zt as asVoid } from "./esm-CK9m5JKX.mjs";
 import { _ as LinkNode, a as HeadingNode, b as CodeHighlightNode, d as ListItemNode, f as ListNode, g as AutoLinkNode, o as QuoteNode, x as CodeNode } from "./LexicalRichText.node-DDpwfE-P.mjs";
 import { t as HorizontalRuleNode } from "./LexicalExtension.node-CF3EAPN7.mjs";
 import { Ht as ElementNode, Vt as DecoratorNode } from "./Lexical.node-BUsI9gWr.mjs";
@@ -24,7 +24,7 @@ import * as ChildProcess from "node:child_process";
 import childProcess, { execFile, spawn } from "node:child_process";
 import * as readline from "node:readline";
 import E from "node:readline";
-import V, { stdin, stdout } from "node:process";
+import process$1, { stdin, stdout } from "node:process";
 import "node:tty";
 //#region ../../node_modules/.pnpm/@effect+platform@0.96.1_effect@3.21.2/node_modules/@effect/platform/dist/esm/Error.js
 /**
@@ -4719,7 +4719,7 @@ const map$1 = /* @__PURE__ */ dual(2, (self, f) => makeMap(self, (a) => right(f(
 /** @internal */
 const optional$3 = (self) => withDefault(map$1(self, some), none$3());
 /** @internal */
-const orElse = /* @__PURE__ */ dual(2, (self, that) => orElseEither(self, that).pipe(map$1(merge$1)));
+const orElse = /* @__PURE__ */ dual(2, (self, that) => orElseEither(self, that).pipe(map$1(merge$2)));
 /** @internal */
 const orElseEither = /* @__PURE__ */ dual(2, (self, that) => makeOrElse(self, that));
 /** @internal */
@@ -5144,7 +5144,7 @@ const matchOptions = (input, options, config) => {
 		return matchOptions(otherArgs, otherOptions, config).pipe(map$6(([error, otherArgs, map2]) => [
 			error,
 			otherArgs,
-			merge(map1, fromIterable$1(map2))
+			merge$1(map1, fromIterable$1(map2))
 		]));
 	}), catchAll((e) => succeed$1([
 		some(e),
@@ -5483,7 +5483,7 @@ const matchUnclustered = (input, tail, options, config) => {
 			return matchUnclustered(otherFlags, tail, opts1, config).pipe(map$6(([_, opts2, map2]) => [
 				tail,
 				opts2,
-				merge(map1, fromIterable$1(map2))
+				merge$1(map1, fromIterable$1(map2))
 			]));
 		}));
 	}
@@ -5496,11 +5496,11 @@ const matchUnclustered = (input, tail, options, config) => {
 /**
 * Sums the list associated with the same key.
 */
-const merge = (map1, map2) => {
+const merge$1 = (map1, map2) => {
 	if (isNonEmptyReadonlyArray(map2)) {
 		const head = headNonEmpty(map2);
 		const tail = tailNonEmpty(map2);
-		return merge(match(get$11(map1, head[0]), {
+		return merge$1(match(get$11(map1, head[0]), {
 			onNone: () => set$2(map1, head[0], head[1]),
 			onSome: (elems) => set$2(map1, head[0], appendAll(elems, head[1]))
 		}), tail);
@@ -6866,7 +6866,7 @@ const setAll$1 = /* @__PURE__ */ dual(2, (self, headers) => make$12({
 * @since 1.0.0
 * @category combinators
 */
-const remove$2 = /* @__PURE__ */ dual(2, (self, key) => {
+const remove$3 = /* @__PURE__ */ dual(2, (self, key) => {
 	const out = make$12(self);
 	const modify = (key) => {
 		if (typeof key === "string") {
@@ -7232,7 +7232,7 @@ const setHash = /* @__PURE__ */ dual(2, (self, hash) => makeInternal(self.method
 /** @internal */
 const setBody = /* @__PURE__ */ dual(2, (self, body) => {
 	let headers = self.headers;
-	if (body._tag === "Empty" || body._tag === "FormData") headers = remove$2(headers, ["Content-type", "Content-length"]);
+	if (body._tag === "Empty" || body._tag === "FormData") headers = remove$3(headers, ["Content-type", "Content-length"]);
 	else {
 		const contentType = body.contentType;
 		if (contentType) headers = set$1(headers, "content-type", contentType);
@@ -7466,7 +7466,7 @@ const transformResponse = /* @__PURE__ */ dual(2, (self, f) => {
 	return makeWith((request) => f(client.postprocess(request)), client.preprocess);
 });
 /** @internal */
-const layerMergedContext$1 = (effect$1) => effect(tag, flatMap$1(context(), (context) => map$6(effect$1, (client) => transformResponse(client, mapInputContext((input) => merge$2(context, input))))));
+const layerMergedContext$1 = (effect$1) => effect(tag, flatMap$1(context(), (context) => map$6(effect$1, (client) => transformResponse(client, mapInputContext((input) => merge$3(context, input))))));
 //#endregion
 //#region ../../node_modules/.pnpm/@effect+platform@0.96.1_effect@3.21.2/node_modules/@effect/platform/dist/esm/HttpClient.js
 /**
@@ -7867,7 +7867,7 @@ const removeFactory = (method) => {
 		force: options?.force ?? false
 	});
 };
-const remove$1 = /* @__PURE__ */ removeFactory("remove");
+const remove$2 = /* @__PURE__ */ removeFactory("remove");
 const makeTempDirectoryScoped = /* @__PURE__ */ (() => {
 	const makeDirectory = /* @__PURE__ */ makeTempDirectoryFactory("makeTempDirectoryScoped");
 	const removeDirectory = /* @__PURE__ */ removeFactory("makeTempDirectoryScoped");
@@ -8112,7 +8112,7 @@ const layer$9 = /* @__PURE__ */ effect(FileSystem, /* @__PURE__ */ map$6(/* @__P
 	readFile,
 	readLink,
 	realPath,
-	remove: remove$1,
+	remove: remove$2,
 	rename,
 	stat,
 	symlink,
@@ -8942,7 +8942,7 @@ const addPrettyLogger = (refs, fiberId) => {
 	return updateAs(refs, {
 		fiberId,
 		fiberRef: currentLoggers,
-		value: loggers.pipe(remove$3(defaultLogger), add$1(prettyLoggerDefault))
+		value: loggers.pipe(remove$4(defaultLogger), add$1(prettyLoggerDefault))
 	});
 };
 /**
@@ -9042,7 +9042,7 @@ function isInsideContainer() {
 //#endregion
 //#region ../../node_modules/.pnpm/is-wsl@3.1.1/node_modules/is-wsl/index.js
 const isWsl = () => {
-	if (V.platform !== "linux") return false;
+	if (process$1.platform !== "linux") return false;
 	if (os.release().toLowerCase().includes("microsoft")) {
 		if (isInsideContainer()) return false;
 		return true;
@@ -9053,11 +9053,11 @@ const isWsl = () => {
 	if (fs.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || fs.existsSync("/run/WSL")) return !isInsideContainer();
 	return false;
 };
-var is_wsl_default = V.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+var is_wsl_default = process$1.env.__IS_WSL_TEST__ ? isWsl : isWsl();
 //#endregion
 //#region ../../node_modules/.pnpm/powershell-utils@0.1.0/node_modules/powershell-utils/index.js
 const execFile$2 = promisify(childProcess.execFile);
-const powerShellPath$1 = () => `${V.env.SYSTEMROOT || V.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+const powerShellPath$1 = () => `${process$1.env.SYSTEMROOT || process$1.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
 const executePowerShell = async (command, options = {}) => {
 	const { powerShellPath: psPath, ...execFileOptions } = options;
 	const encodedCommand = executePowerShell.encodeCommand(command);
@@ -9164,7 +9164,7 @@ function defineLazyProperty(object, propertyName, valueGetter) {
 //#region ../../node_modules/.pnpm/default-browser-id@5.0.1/node_modules/default-browser-id/index.js
 const execFileAsync$3 = promisify(execFile);
 async function defaultBrowserId() {
-	if (V.platform !== "darwin") throw new Error("macOS only");
+	if (process$1.platform !== "darwin") throw new Error("macOS only");
 	const { stdout } = await execFileAsync$3("defaults", [
 		"read",
 		"com.apple.LaunchServices/com.apple.launchservices.secure",
@@ -9178,7 +9178,7 @@ async function defaultBrowserId() {
 //#region ../../node_modules/.pnpm/run-applescript@7.1.0/node_modules/run-applescript/index.js
 const execFileAsync$2 = promisify(execFile);
 async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
-	if (V.platform !== "darwin") throw new Error("macOS only");
+	if (process$1.platform !== "darwin") throw new Error("macOS only");
 	const outputArguments = humanReadableOutput ? [] : ["-ss"];
 	const execOptions = {};
 	if (signal) execOptions.signal = signal;
@@ -9289,14 +9289,14 @@ async function defaultBrowser$1(_execFileAsync = execFileAsync$1) {
 const execFileAsync = promisify(execFile);
 const titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
 async function defaultBrowser() {
-	if (V.platform === "darwin") {
+	if (process$1.platform === "darwin") {
 		const id = await defaultBrowserId();
 		return {
 			name: await bundleName(id),
 			id
 		};
 	}
-	if (V.platform === "linux") {
+	if (process$1.platform === "linux") {
 		const { stdout } = await execFileAsync("xdg-mime", [
 			"query",
 			"default",
@@ -9308,18 +9308,18 @@ async function defaultBrowser() {
 			id
 		};
 	}
-	if (V.platform === "win32") return defaultBrowser$1();
+	if (process$1.platform === "win32") return defaultBrowser$1();
 	throw new Error("Only macOS, Linux, and Windows are supported");
 }
 //#endregion
 //#region ../../node_modules/.pnpm/is-in-ssh@1.0.0/node_modules/is-in-ssh/index.js
-const isInSsh = Boolean(V.env.SSH_CONNECTION || V.env.SSH_CLIENT || V.env.SSH_TTY);
+const isInSsh = Boolean(process$1.env.SSH_CONNECTION || process$1.env.SSH_CLIENT || process$1.env.SSH_TTY);
 //#endregion
 //#region ../../node_modules/.pnpm/open@11.0.0/node_modules/open/index.js
 const fallbackAttemptSymbol = Symbol("fallbackAttempt");
 const __dirname = import.meta.url ? path.dirname(fileURLToPath(import.meta.url)) : "";
 const localXdgOpenPath = path.join(__dirname, "xdg-open");
-const { platform: platform$1, arch: arch$1 } = V;
+const { platform: platform$1, arch: arch$1 } = process$1;
 const tryEachApp = async (apps, opener) => {
 	if (apps.length === 0) return;
 	const errors = [];
@@ -9432,7 +9432,7 @@ const baseOpen = async (options) => {
 				await fs$1.access(localXdgOpenPath, constants.X_OK);
 				exeLocalXdgOpen = true;
 			} catch {}
-			command = V.versions.electron ?? (platform$1 === "android" || isBundled || !exeLocalXdgOpen) ? "xdg-open" : localXdgOpenPath;
+			command = process$1.versions.electron ?? (platform$1 === "android" || isBundled || !exeLocalXdgOpen) ? "xdg-open" : localXdgOpenPath;
 		}
 		if (appArguments.length > 0) cliArguments.push(...appArguments);
 		if (!options.wait) {
@@ -11024,7 +11024,7 @@ var ht$1 = class extends m {
 //#endregion
 //#region ../../node_modules/.pnpm/@clack+prompts@1.4.0/node_modules/@clack/prompts/dist/index.mjs
 function ee() {
-	return V.platform !== "win32" ? V.env.TERM !== "linux" : !!V.env.CI || !!V.env.WT_SESSION || !!V.env.TERMINUS_SUBLIME || V.env.ConEmuTask === "{cmd::Cmder}" || V.env.TERM_PROGRAM === "Terminus-Sublime" || V.env.TERM_PROGRAM === "vscode" || V.env.TERM === "xterm-256color" || V.env.TERM === "alacritty" || V.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+	return process$1.platform !== "win32" ? process$1.env.TERM !== "linux" : !!process$1.env.CI || !!process$1.env.WT_SESSION || !!process$1.env.TERMINUS_SUBLIME || process$1.env.ConEmuTask === "{cmd::Cmder}" || process$1.env.TERM_PROGRAM === "Terminus-Sublime" || process$1.env.TERM_PROGRAM === "vscode" || process$1.env.TERM === "xterm-256color" || process$1.env.TERM === "alacritty" || process$1.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
 }
 const tt = ee(), w = (t, i) => tt ? t : i, Tt = w("◆", "*"), at = w("■", "x"), ut = w("▲", "x"), H = w("◇", "o");
 const $ = w("│", "|"), x = w("└", "—");
@@ -18214,7 +18214,7 @@ const replaceWith = (node, nodes) => {
 		node.remove();
 	}
 };
-const remove = (prev, current, next) => {
+const remove$1 = (prev, current, next) => {
 	const { parentNode, nodeType } = current;
 	if (prev || next) {
 		setAdjacent(prev, next);
@@ -18265,7 +18265,7 @@ var CharacterData$1 = class extends Node$1 {
 		replaceWith(this, nodes);
 	}
 	remove() {
-		remove(this[PREV], this, this[NEXT]);
+		remove$1(this[PREV], this, this[NEXT]);
 	}
 	/* c8 ignore start */
 	get data() {
@@ -19656,13 +19656,13 @@ function reduceRules(a, b) {
 //#endregion
 //#region ../../node_modules/.pnpm/css-select@5.2.2/node_modules/css-select/lib/esm/index.js
 const defaultEquals = (a, b) => a === b;
-const defaultOptions = {
+const defaultOptions$1 = {
 	adapter: esm_exports$1,
 	equals: defaultEquals
 };
 function convertOptionFormats(options) {
 	var _a, _b, _c, _d;
-	const opts = options !== null && options !== void 0 ? options : defaultOptions;
+	const opts = options !== null && options !== void 0 ? options : defaultOptions$1;
 	(_a = opts.adapter) !== null && _a !== void 0 || (opts.adapter = esm_exports$1);
 	(_b = opts.equals) !== null && _b !== void 0 || (opts.equals = (_d = (_c = opts.adapter) === null || _c === void 0 ? void 0 : _c.equals) !== null && _d !== void 0 ? _d : defaultEquals);
 	return opts;
@@ -20515,7 +20515,7 @@ var Element$1 = class extends ParentNode {
 		replaceWith(this, nodes);
 	}
 	remove() {
-		remove(this[PREV], this, this[END][NEXT]);
+		remove$1(this[PREV], this, this[END][NEXT]);
 	}
 	get id() {
 		return stringAttribute.get(this, "id");
@@ -28251,7 +28251,8 @@ const make$3 = (api, deps = {}) => {
 	const resolveCategoryRefs = (refs) => forEach$1(refs, (ref) => resolveCategory(ref), { concurrency: 1 });
 	const resolvePostReadPath = (slugOrId) => gen(function* () {
 		if (isSnowflakeId(slugOrId)) return `/posts/${slugOrId}`;
-		const path = (yield* api.raw(`/posts/get-url/${encodeURIComponent(slugOrId)}`).pipe(mapError(mapApiError)))?.path;
+		const env = yield* api.raw(`/posts/get-url/${encodeURIComponent(slugOrId)}`).pipe(mapError(mapApiError));
+		const path = env?.data?.path ?? env?.path;
 		if (!path) return yield* fail$2(new ResourceNotFound({
 			message: `post not found: ${slugOrId}`,
 			kind: "post",
@@ -28262,7 +28263,8 @@ const make$3 = (api, deps = {}) => {
 	const resolvePostId = (slugOrId) => gen(function* () {
 		if (isSnowflakeId(slugOrId)) return slugOrId;
 		const apiPath = yield* resolvePostReadPath(slugOrId);
-		const id = (yield* api.raw(apiPath).pipe(mapError(mapApiError)))?.id;
+		const env = yield* api.raw(apiPath).pipe(mapError(mapApiError));
+		const id = env?.data?.id ?? env?.id;
 		if (!id) return yield* fail$2(new ResourceNotFound({
 			message: `post not found: ${slugOrId}`,
 			kind: "post",
@@ -32224,6 +32226,1777 @@ const profileCmd = make$13("profile").pipe(withDescription(help$2.description),
 	rm
 ]));
 //#endregion
+//#region ../../node_modules/.pnpm/minisearch@7.2.0/node_modules/minisearch/dist/es/index.js
+/** @ignore */
+const ENTRIES = "ENTRIES";
+/** @ignore */
+const KEYS = "KEYS";
+/** @ignore */
+const VALUES = "VALUES";
+/** @ignore */
+const LEAF = "";
+/**
+* @private
+*/
+var TreeIterator = class {
+	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: void 0
+		};
+		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];
+};
+/**
+* @ignore
+*/
+const fuzzySearch = (node, query, maxDistance) => {
+	const results = /* @__PURE__ */ new Map();
+	if (query === void 0) return results;
+	const n = query.length + 1;
+	const m = n + maxDistance;
+	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;
+};
+const recurse = (node, query, maxDistance, results, matrix, m, n, prefix) => {
+	const offset = m * n;
+	key: for (const key of node.keys()) if (key === LEAF) {
+		const distance = matrix[offset - 1];
+		if (distance <= maxDistance) results.set(prefix, [node.get(key), distance]);
+	} else {
+		let i = m;
+		for (let pos = 0; pos < key.length; ++pos, ++i) {
+			const char = key[pos];
+			const thisRowOffset = n * i;
+			const prevRowOffset = thisRowOffset - n;
+			let minDistance = matrix[thisRowOffset];
+			const jmin = Math.max(0, i - maxDistance - 1);
+			const jmax = Math.min(n - 1, i + maxDistance);
+			for (let j = jmin; j < jmax; ++j) {
+				const different = char !== query[j];
+				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;
+			}
+			if (minDistance > maxDistance) continue key;
+		}
+		recurse(node.get(key), query, maxDistance, results, matrix, i, n, prefix + key);
+	}
+};
+/**
+* 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
+* exported by the `minisearch` package and can be imported (or required) as
+* `minisearch/SearchableMap`.
+*
+* @typeParam T  The type of the values stored in the map.
+*/
+var SearchableMap = 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 = /* @__PURE__ */ new Map(), prefix = "") {
+		this._size = void 0;
+		this._tree = tree;
+		this._prefix = prefix;
+	}
+	/**
+	* 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 === void 0) {
+			const [parentNode, key] = last(path);
+			for (const k of parentNode.keys()) if (k !== LEAF && k.startsWith(key)) {
+				const node = /* @__PURE__ */ 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 = void 0;
+		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 = void 0;
+		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 !== void 0 ? node.get(LEAF) : void 0;
+	}
+	/**
+	* @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 !== void 0 && 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 = void 0;
+		createPath(this._tree, key).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 = void 0;
+		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 = void 0;
+		const node = createPath(this._tree, key);
+		let value = node.get(LEAF);
+		if (value === void 0) 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]);
+		return trackDown(tree.get(k), key.slice(k.length), path);
+	}
+	path.push([tree, key]);
+	return trackDown(void 0, "", 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));
+};
+const createPath = (node, key) => {
+	const keyLength = key.length;
+	outer: for (let pos = 0; node && pos < keyLength;) {
+		for (const k of node.keys()) if (k !== LEAF && key[pos] === k[0]) {
+			const len = Math.min(keyLength - pos, k.length);
+			let offset = 1;
+			while (offset < len && key[pos + offset] === k[offset]) ++offset;
+			const child = node.get(k);
+			if (offset === k.length) node = child;
+			else {
+				const intermediate = /* @__PURE__ */ 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;
+		}
+		const child = /* @__PURE__ */ new Map();
+		node.set(key.slice(pos), child);
+		return child;
+	}
+	return node;
+};
+const remove = (tree, key) => {
+	const [node, path] = trackDown(tree, key);
+	if (node === void 0) 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";
+/**
+* {@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 }
+* // ]
+* ```
+*/
+var MiniSearch = 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 = /* @__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 = 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);
+		this.saveStoredFields(shortDocumentId, document);
+		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.addFieldLength(shortDocumentId, fieldId, this._documentCount - 1, uniqueTerms);
+			for (const term of tokens) {
+				const processedTerm = processTerm(term, field);
+				if (Array.isArray(processedTerm)) for (const t of processedTerm) this.addTerm(fieldId, shortDocumentId, t);
+				else if (processedTerm) this.addTerm(fieldId, shortDocumentId, processedTerm);
+			}
+		}
+	}
+	/**
+	* 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 = /* @__PURE__ */ new Map();
+			this._idToShortId = /* @__PURE__ */ new Map();
+			this._fieldLength = /* @__PURE__ */ new Map();
+			this._avgFieldLength = [];
+			this._storedFields = /* @__PURE__ */ 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 (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;
+		}
+		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;
+		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 results = [];
+		for (const [docId, { score, terms, match }] of rawResults) {
+			const quality = terms.length || 1;
+			const result = {
+				id: this._documentIds.get(docId),
+				score: score * quality,
+				terms: Object.keys(match),
+				queryTerms: terms,
+				match
+			};
+			Object.assign(result, this._storedFields.get(docId));
+			if (searchOptionsWithDefaults.filter == null || searchOptionsWithDefaults.filter(result)) results.push(result);
+		}
+		if (query === MiniSearch.wildcard && searchOptionsWithDefaults.boostDocument == null) return results;
+		results.sort(byScore);
+		return results;
+	}
+	/**
+	* 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ new Map();
+			for (const fieldId of Object.keys(data)) {
+				let indexEntry = data[fieldId];
+				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 = /* @__PURE__ */ new Map();
+			for (const fieldId of Object.keys(data)) {
+				let indexEntry = data[fieldId];
+				if (serializationVersion === 1) indexEntry = indexEntry.ds;
+				dataMap.set(parseInt(fieldId, 10), await objectToNumericMapAsync(indexEntry));
+			}
+			if (++count % 1e3 === 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 = /* @__PURE__ */ 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: void 0
+			};
+			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 results = searchTokenize(query).flatMap((term) => searchProcessTerm(term)).filter((term) => !!term).map(termToQuerySpec(options)).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 ? .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;
+			fuzzyMatches === null || fuzzyMatches === void 0 || fuzzyMatches.delete(term);
+			const weight = prefixWeight * term.length / (term.length + .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;
+			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 = /* @__PURE__ */ 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) {
+		if (results.length === 0) return /* @__PURE__ */ new Map();
+		const combinator = combinators[combineWith.toLowerCase()];
+		if (!combinator) throw new Error(`Invalid combination operator: ${combineWith}`);
+		return results.reduce(combinator) || /* @__PURE__ */ new Map();
+	}
+	/**
+	* 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 = /* @__PURE__ */ new Map()) {
+		if (fieldTermData == null) return results;
+		for (const field of Object.keys(fieldBoosts)) {
+			const fieldBoost = fieldBoosts[field];
+			const fieldId = this._fieldIds[field];
+			const fieldTermFreqs = fieldTermData.get(fieldId);
+			if (fieldTermFreqs == null) continue;
+			let matchingFields = fieldTermFreqs.size;
+			const avgFieldLength = this._avgFieldLength[fieldId];
+			for (const docId of fieldTermFreqs.keys()) {
+				if (!this._documentIds.has(docId)) {
+					this.removeTerm(fieldId, docId, derivedTerm);
+					matchingFields -= 1;
+					continue;
+				}
+				const docBoost = boostDocumentFn ? boostDocumentFn(this._documentIds.get(docId), derivedTerm, this._storedFields.get(docId)) : 1;
+				if (!docBoost) continue;
+				const termFreq = fieldTermFreqs.get(docId);
+				const fieldLength = this._fieldLength.get(docId)[fieldId];
+				const rawScore = calcBM25Score(termFreq, matchingFields, this._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;
+	}
+	/**
+	* @ignore
+	*/
+	addTerm(fieldId, documentId, term) {
+		const indexData = this._index.fetch(term, createMap);
+		let fieldIndex = indexData.get(fieldId);
+		if (fieldIndex == null) {
+			fieldIndex = /* @__PURE__ */ 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 totalFieldLength = (this._avgFieldLength[fieldId] || 0) * 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);
+	}
+	/**
+	* @ignore
+	*/
+	saveStoredFields(documentId, doc) {
+		const { storeFields, extractField } = this._options;
+		if (storeFields == null || storeFields.length === 0) return;
+		let documentFields = this._storedFields.get(documentId);
+		if (documentFields == null) this._storedFields.set(documentId, documentFields = {});
+		for (const fieldName of storeFields) {
+			const fieldValue = extractField(doc, fieldName);
+			if (fieldValue !== void 0) documentFields[fieldName] = fieldValue;
+		}
+	}
+};
+/**
+* The special wildcard symbol that can be passed to {@link MiniSearch#search}
+* to match all documents
+*/
+MiniSearch.wildcard = Symbol("*");
+const getOwnProperty = (object, property) => Object.prototype.hasOwnProperty.call(object, property) ? object[property] : void 0;
+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 = /* @__PURE__ */ 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;
+	}
+};
+const defaultBM25params = {
+	k: 1.2,
+	b: .7,
+	d: .5
+};
+const calcBM25Score = (termFreq, matchingCount, totalCount, fieldLength, avgFieldLength, bm25params) => {
+	const { k, b, d } = bm25params;
+	return Math.log(1 + (totalCount - matchingCount + .5) / (matchingCount + .5)) * (d + termFreq * (k + 1) / (termFreq + k * (1 - b + b * fieldLength / avgFieldLength)));
+};
+const termToQuerySpec = (options) => (term, i, terms) => {
+	return {
+		term,
+		fuzzy: typeof options.fuzzy === "function" ? options.fuzzy(term, i, terms) : options.fuzzy || false,
+		prefix: typeof options.prefix === "function" ? options.prefix(term, i, terms) : options.prefix === true,
+		termBoost: typeof options.boostTerm === "function" ? options.boostTerm(term, i, terms) : 1
+	};
+};
+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: void 0,
+	searchOptions: void 0,
+	storeFields: [],
+	logger: (level, message) => {
+		if (typeof (console === null || console === void 0 ? void 0 : console[level]) === "function") console[level](message);
+	},
+	autoVacuum: true
+};
+const defaultSearchOptions = {
+	combineWith: OR,
+	prefix: false,
+	fuzzy: false,
+	maxFuzzy: 6,
+	boost: {},
+	weights: {
+		fuzzy: .45,
+		prefix: .375
+	},
+	bm25: defaultBM25params
+};
+const defaultAutoSuggestOptions = {
+	combineWith: AND,
+	prefix: (term, i, terms) => i === terms.length - 1
+};
+const defaultVacuumOptions = {
+	batchSize: 1e3,
+	batchWait: 10
+};
+const defaultVacuumConditions = {
+	minDirtFactor: .1,
+	minDirtCount: 20
+};
+const defaultAutoVacuumOptions = {
+	...defaultVacuumOptions,
+	...defaultVacuumConditions
+};
+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;
+const createMap = () => /* @__PURE__ */ new Map();
+const objectToNumericMap = (object) => {
+	const map = /* @__PURE__ */ new Map();
+	for (const key of Object.keys(object)) map.set(parseInt(key, 10), object[key]);
+	return map;
+};
+const objectToNumericMapAsync = async (object) => {
+	const map = /* @__PURE__ */ new Map();
+	let count = 0;
+	for (const key of Object.keys(object)) {
+		map.set(parseInt(key, 10), object[key]);
+		if (++count % 1e3 === 0) await wait(0);
+	}
+	return map;
+};
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const SPACE_OR_PUNCTUATION = /[\n\r\p{Z}\p{P}]+/u;
+//#endregion
 //#region src/services/Skill.ts
 const requireFrom$2 = createRequire(import.meta.url);
 const findCliPackageRoot = () => {
@@ -32417,50 +34190,85 @@ const buildRegistry = (fs, path, cliDir, haklexDir) => gen(function* () {
 	}
 	return [...all].sort((a, b) => a.order - b.order);
 });
-const indexOfCaseInsensitive = (haystack, needle) => haystack.toLowerCase().indexOf(needle.toLowerCase());
-const buildSnippets = (body, keyword) => {
-	const out = [];
+const buildIndex = (chapters) => {
+	const mini = new MiniSearch({
+		fields: [
+			"title",
+			"description",
+			"body"
+		],
+		storeFields: ["slug"],
+		idField: "slug",
+		searchOptions: {
+			boost: {
+				title: 3,
+				description: 2
+			},
+			combineWith: "AND",
+			prefix: true,
+			fuzzy: .2
+		}
+	});
+	mini.addAll(chapters.map((c) => ({
+		slug: c.slug,
+		title: c.title,
+		description: c.description,
+		body: c.body
+	})));
+	return mini;
+};
+/**
+* Tokenize the user's query string the same way MiniSearch does for indexing,
+* so snippets can be located in the body. We use this lightweight tokenizer
+* rather than `r.terms` because fuzzy / prefix matches expose the indexed
+* term, not the substring that appears in the body verbatim.
+*/
+const tokenizeQuery = (s) => s.toLowerCase().split(/[\s\p{P}]+/u).filter((t) => t.length > 0);
+const buildSnippets = (body, terms) => {
+	if (terms.length === 0) return [];
 	const lower = body.toLowerCase();
-	const k = keyword.toLowerCase();
-	if (!k) return out;
-	let from = 0;
-	while (out.length < 3) {
-		const idx = lower.indexOf(k, from);
-		if (idx < 0) break;
-		const start = Math.max(0, idx - 60);
-		const end = Math.min(body.length, idx + keyword.length + 60);
-		let snippet = body.slice(start, end).replaceAll(/\s+/g, " ").trim();
-		if (start > 0) snippet = `…${snippet}`;
-		if (end < body.length) snippet = `${snippet}…`;
-		out.push(snippet);
-		from = idx + keyword.length;
+	const occs = terms.map((term) => {
+		const t = term.toLowerCase();
+		if (!t) return [];
+		const positions = [];
+		let from = 0;
+		while (positions.length < 5) {
+			const idx = lower.indexOf(t, from);
+			if (idx < 0) break;
+			positions.push(idx);
+			from = idx + t.length;
+		}
+		return positions;
+	});
+	const cursors = Array.from({ length: terms.length }).fill(0);
+	const out = [];
+	let progressed = true;
+	while (out.length < 3 && progressed) {
+		progressed = false;
+		for (let i = 0; i < terms.length && out.length < 3; i++) {
+			const c = cursors[i];
+			if (c >= occs[i].length) continue;
+			const idx = occs[i][c];
+			const tLen = terms[i].length;
+			cursors[i] = c + 1;
+			progressed = true;
+			const start = Math.max(0, idx - 60);
+			const end = Math.min(body.length, idx + tLen + 60);
+			let snippet = body.slice(start, end).replaceAll(/\s+/g, " ").trim();
+			if (start > 0) snippet = `…${snippet}`;
+			if (end < body.length) snippet = `${snippet}…`;
+			out.push(snippet);
+		}
 	}
 	return out;
 };
-const rank = (chapter, keyword) => {
-	if (!keyword) return 0;
-	let score = 0;
-	if (indexOfCaseInsensitive(chapter.title, keyword) >= 0) score += 3;
-	if (indexOfCaseInsensitive(chapter.description, keyword) >= 0) score += 2;
-	const bodyLower = chapter.body.toLowerCase();
-	const k = keyword.toLowerCase();
-	let from = 0;
-	let count = 0;
-	while (count < 10) {
-		const idx = bodyLower.indexOf(k, from);
-		if (idx < 0) break;
-		count += 1;
-		from = idx + k.length;
-	}
-	score += count;
-	return score;
-};
 const make$2 = gen(function* () {
 	const fs = yield* FileSystem;
 	const path = yield* Path$1;
 	const cliDir = resolveCliSkillsDir();
 	const haklexDir = resolveHaklexSkillsDir();
 	const cache = yield* make$23(null);
+	const indexCache = yield* make$23(null);
 	const load = gen(function* () {
 		const cached = yield* get$10(cache);
 		if (cached) return cached;
@@ -32468,6 +34276,13 @@ const make$2 = gen(function* () {
 		yield* set$3(cache, chapters);
 		return chapters;
 	});
+	const loadIndex = gen(function* () {
+		const cached = yield* get$10(indexCache);
+		if (cached) return cached;
+		const mini = buildIndex(yield* load);
+		yield* set$3(indexCache, mini);
+		return mini;
+	});
 	return {
 		list: load,
 		all: load,
@@ -32484,24 +34299,23 @@ const make$2 = gen(function* () {
 			return found;
 		}),
 		search: (keyword) => gen(function* () {
-			const chapters = yield* load;
 			const kw = keyword.trim();
 			if (!kw) return [];
-			const scored = [];
-			for (const c of chapters) {
-				const s = rank(c, kw);
-				if (s > 0) scored.push({
-					chapter: c,
-					score: s
-				});
-			}
-			scored.sort((a, b) => b.score - a.score || a.chapter.order - b.chapter.order);
-			return scored.map(({ chapter }) => ({
-				slug: chapter.slug,
-				title: chapter.title,
-				description: chapter.description,
-				snippets: buildSnippets(chapter.body, kw)
-			}));
+			const chapters = yield* load;
+			const mini = yield* loadIndex;
+			const tokens = tokenizeQuery(kw);
+			const results = mini.search(kw);
+			const bySlug = new Map(chapters.map((c) => [c.slug, c]));
+			return results.flatMap((r) => {
+				const chapter = bySlug.get(r.id);
+				if (!chapter) return [];
+				return [{
+					slug: chapter.slug,
+					title: chapter.title,
+					description: chapter.description,
+					snippets: buildSnippets(chapter.body, tokens)
+				}];
+			});
 		})
 	};
 });