@warlock.js/web 5.0.0

package/esm/routing/query-string.d.mts

@@ -0,0 +1,250 @@
+//#region ../web/src/routing/query-string.d.ts
+/**
+ * The query string: BOTH directions, one grammar, one file.
+ *
+ * ── The rule this module exists to obey ──────────────────────────────────────
+ *
+ * `queryStringOf` is what `href(name, params, query)` appends, and therefore
+ * what every `<Link>` puts in the document; `queryString.parse` is what reads it
+ * back. They live together because a second, independently-written
+ * query-string implementation would mean one thing writes URLs and a different
+ * thing reads them. Query-string libraries genuinely disagree about arrays,
+ * nested objects and space escaping, so the moment the two drift the round trip
+ * loses data SILENTLY — the wrong value renders and no error is raised
+ * anywhere. That is the two-route-matchers failure class (canon 9c8f878b) one
+ * layer down.
+ *
+ * Escaping is not two rules that agree today. Both directions stand on
+ * `URLSearchParams`: the encoder builds one and calls `.toString()`, the decoder
+ * hands the string back to `new URLSearchParams(...)`. `+`-for-space and every
+ * percent-encoding rule are therefore ONE rule and cannot drift.
+ *
+ * ── The grammar, and why it is not ours to choose ────────────────────────────
+ *
+ * Structure — arrays and nested objects — is the part `URLSearchParams` has no
+ * opinion about, so it was read off the SERVER rather than invented. Warlock is
+ * a backend framework and core already parses query strings for list endpoints
+ * and filters; a client that emitted anything else would not have fixed this
+ * module's bug, it would have moved it across the wire where it is harder to
+ * see. Measured, with file:line, in
+ * `reports/query-grammar-findings-2026-08-24.md`:
+ *
+ *   - `core/src/http/server.ts:14-36` configures Fastify with NO
+ *     `querystringParser`, so find-my-way's `fast-querystring` default applies:
+ *     flat keys, `+` is a space, a repeated key collapses to an array.
+ *   - `core/src/http/request.ts:491` then runs `request.query` through
+ *     `parseBody` — the SAME bracket-aware parser as the request body.
+ *   - `core/src/http/request.ts:516-520` reads `key[]` as an array marker, and
+ *     `:568-575` wraps a single `key[]=a` into the one-element array `["a"]`.
+ *   - `core/src/http/request.ts:557-561` turns `key[sub]=v` into
+ *     `{key: {sub: v}}`, one level deep.
+ *
+ * So: `tags[]=a&tags[]=b` for arrays, `filter[status]=active` for objects,
+ * `filter[tags][]=a` for an array inside an object. Bare repeated keys
+ * (`tags=a&tags=b`) would also reach core as an array, but only at cardinality
+ * two or more — `tags=a` comes back as the scalar `"a"`, and a shape that
+ * changes with the number of matches is a `TypeError` waiting for the day a
+ * filter matches one item. `[]` is the form core wrote a branch for.
+ *
+ * ── What is REFUSED, and why refusing is the safe answer ─────────────────────
+ *
+ * Two levels of nesting is not a gap in core, it is measured data loss:
+ * `a[b][c]=x` takes the `][` branch at `core/src/http/request.ts:528-551`,
+ * computes `Number("b")` as `NaN`, and the value lands on a `NaN` index and
+ * vanishes — core answers `{a: []}`. So the encoder throws
+ * {@link UnserializableQueryValueError} rather than write it. `href()` already
+ * throws on a missing route parameter rather than emit a link that renders
+ * correctly and 404s; this is the same call.
+ *
+ * ── What the encoder still normalises, and what that costs ───────────────────
+ *
+ * Leaf values are serialised with `String(value)`, so every value arrives back
+ * as a `string`: `href("p", {}, { page: 2 })` writes `?page=2`, and `2` and
+ * `"2"` are the same URL. The round-trip law that can actually hold is
+ * `parse(encode(query)) === query with String() applied to its leaves and
+ * undefined dropped`, and that is what the spec asserts. Asserting anything
+ * stronger would be asserting a decoder that guesses types, which is how
+ * `?zip=01234` becomes the number `1234`.
+ *
+ * The decoder does NOT split values on `,`: that would turn the legitimate
+ * string `"Doe, John"` into `["Doe", " John"]`, trading a visible limitation for
+ * a silent corruption of ordinary data. Arrays are carried by `[]`, which is
+ * unambiguous, so there is nothing left to guess at.
+ *
+ * ── Universal by requirement, not by accident ────────────────────────────────
+ *
+ * `web` renders on the server first, so every export here is safe to import and
+ * to CALL with no DOM. `@mongez/react-router`'s equivalent reads
+ * `window.location.search` unguarded (query-string.ts:22) and throws under SSR.
+ * Here the browser-only readers return their empty answer instead — see
+ * `queryString.all` for the hydration caveat that comes with that.
+ *
+ * ── Still NOT here: `toQueryString` and `update` ─────────────────────────────
+ *
+ * MRR exposes `toQueryString(params)` and `update(params)`, which SERIALISE.
+ * The serialiser they need is no longer module-private — `queryStringOf` is
+ * exported from here — so the old blocker is gone. What remains is that
+ * `web/src/index.ts` does not re-export it yet, and the barrel is owned
+ * elsewhere. That is a one-line follow-up, not a redesign.
+ */
+/** A decoded leaf. Always a `string` — see the header on `String(value)`. */
+type QueryStringLeaf = string;
+/**
+ * The inside of a `key[sub]` bag: one level deep, exactly as far as core parses.
+ *
+ * There is no deeper case to model. `key[sub][deeper]` is refused by the encoder
+ * and carried verbatim as a literal key by the decoder, so a nested bag only
+ * ever holds a leaf or an array of leaves.
+ */
+type QueryStringNested = Record<string, QueryStringLeaf | QueryStringLeaf[]>;
+/** A decoded value: a leaf, a `key[]` array, or a `key[sub]` bag. */
+type QueryStringValue = QueryStringLeaf | QueryStringLeaf[] | QueryStringNested;
+/** A decoded query string. */
+type QueryStringObject = Record<string, QueryStringValue>;
+/** What {@link queryStringOf} accepts. Values are validated, not trusted. */
+type QueryStringInput = Readonly<Record<string, unknown>>;
+/**
+ * Thrown when a query value has a shape the wire format cannot carry.
+ *
+ * Deliberately LOUD. The alternative is emitting something core silently
+ * mangles — `a[b][c]=x` arrives as `{a: []}` — which is this defect all over
+ * again, one layer further from where anyone would look for it.
+ */
+declare class UnserializableQueryValueError extends Error {
+  readonly queryKey: string;
+  readonly shape: string;
+  constructor(queryKey: string, shape: string);
+}
+/**
+ * Serialise a query object to a search string, INCLUDING the leading `?`.
+ *
+ * Returns `""` — not `"?"` — when there is nothing to write, so the result can
+ * always be concatenated onto a path. `href()` is the primary caller; the
+ * grammar it emits is the one core parses, and the whole justification is in the
+ * module header.
+ *
+ * @throws {UnserializableQueryValueError} when a value nests deeper than the
+ * wire format can carry.
+ */
+declare function queryStringOf(query: QueryStringInput | undefined): string;
+/**
+ * What to do when the same PLAIN key appears more than once, e.g. `?tag=a&tag=b`.
+ *
+ * - `"last"` — keep the final occurrence. Matches `URLSearchParams.get()`, the
+ *   read side of the primitive the encoder writes with, and keeps every value a
+ *   `string`.
+ * - `"first"` — keep the earliest occurrence.
+ * - `"array"` — collect every occurrence. Under this strategy a key that occurs
+ *   ONCE is still an array of one, because a shape that changes with the number
+ *   of values is a `TypeError` waiting for the day a filter matches a single
+ *   item.
+ *
+ * It does NOT govern `key[]` or `key[sub]`; those are shapes the encoder writes
+ * deliberately, and their meaning is fixed. See {@link QueryStringOptions}.
+ */
+type RepeatedKeyStrategy = "last" | "first" | "array";
+/**
+ * The whole option surface.
+ *
+ * ── Why this is one flag and not MRR's pluggable parsers ─────────────────────
+ *
+ * MRR's `setQueryStringOptions` swaps `objectParser` and `stringParser`
+ * (query-string.ts:10-15). Neither survives contact with a fixed, shared
+ * encoder:
+ *
+ *   - A pluggable `objectParser` is a licence to install a READER that disagrees
+ *     with the writer. It is precisely the silent round-trip break this module
+ *     was written to prevent, offered as a supported API.
+ *   - A pluggable `stringParser` would be worse: it cannot reach `href()`, which
+ *     calls `queryStringOf` directly with no hook. Setting it would change what
+ *     this module emits while every `<Link>` on the page kept emitting the old
+ *     format — two writers, disagreeing, by configuration.
+ *
+ * `repeatedKeys` is safe for one specific reason, and the reason survived the
+ * move to bracket notation: `queryStringOf` iterates `Object.entries`, so it can
+ * never emit a duplicate PLAIN key. It now does emit duplicate `key[]` pairs —
+ * that is how an array is written — but those go down the array branch of the
+ * decoder, which this flag does not touch. Were the flag to govern the bracket
+ * forms as well, `repeatedKeys: "array"` would decode `filter[x]=1` as
+ * `{filter: {x: ["1"]}}` and break the round trip BY CONFIGURATION.
+ *
+ * So the flag still decides only something the encoder has no opinion about: a
+ * repeated plain key, which can only arrive from a URL this package did not
+ * write — hand-typed, external links, `GET` forms.
+ *
+ * Set it at BOOT, not per request: this is process-global config, and a
+ * request-scoped write would be read by whatever request happens to be
+ * rendering (the defect catalogued at route-table.ts:10-25).
+ */
+type QueryStringOptions = {
+  readonly repeatedKeys?: RepeatedKeyStrategy;
+};
+/**
+ * Merge query-string options over the current ones.
+ *
+ * Named for `@mongez/react-router`'s function so migrating call sites keep
+ * compiling; the OPTIONS are deliberately narrower, and `QueryStringOptions`
+ * explains exactly which ones were refused and why.
+ */
+declare function setQueryStringOptions(options: QueryStringOptions): void;
+/**
+ * Drop back to the defaults.
+ *
+ * Exists because the options are process-global: a test that set one would
+ * otherwise leak it into every later test in the same worker, passing in file
+ * order and failing under `--shuffle`. Same reasoning as `resetRouteTable`.
+ */
+declare function resetQueryStringOptions(): void;
+/**
+ * Reading the current query string, and any query string.
+ *
+ * Named for `@mongez/react-router`'s object so the familiar calls keep working;
+ * the implementation is not ported — see the module header for what changed and
+ * why.
+ */
+declare const queryString: {
+  /**
+   * The current document's query string, decoded.
+   *
+   * On the server this is `{}`, because the browser location is the only source
+   * this module has and a per-request one would be module state two concurrent
+   * requests could race over (route-table.ts:10-25).
+   *
+   * That makes it a HYDRATION HAZARD in a component: the server renders `{}`
+   * and the browser renders the real values, so the two trees differ. In a
+   * component, take the query from the page's own props and hand it to
+   * {@link queryString.parse}, which is universal. `all()` is for browser-only
+   * code — an event handler, an effect, a client-side helper.
+   */
+  all(): QueryStringObject;
+  /**
+   * Decode a query string that was handed to you.
+   *
+   * Universal: it reads no globals, so this is the entry point that is safe on
+   * the server. Accepts a bare pair list, a leading `?`, a path, or a full URL.
+   */
+  parse(search: string): QueryStringObject;
+  /**
+   * One key from the current query string.
+   *
+   * PRESENCE, not truthiness. MRR returns `all[key] || defaultValue`
+   * (query-string.ts:43), which hands back the default for `?a=` — so a
+   * deliberately-cleared filter reads as though it was never set, and the page
+   * shows the default instead of the empty state. Here `?a=` returns `""`, and
+   * only an absent key returns the default.
+   *
+   * @param defaultValue returned only when the key is absent. Defaults to
+   * `null`, as MRR's does.
+   */
+  get<T = null>(key: string, defaultValue?: T): QueryStringValue | T;
+  /**
+   * The current query string verbatim, without the leading `?`.
+   *
+   * `""` on the server, and `""` when there is no query — the same two cases
+   * `queryStringOf` collapses when it writes.
+   */
+  toString(): string;
+};
+//#endregion
+export { QueryStringInput, QueryStringLeaf, QueryStringNested, QueryStringObject, QueryStringOptions, QueryStringValue, RepeatedKeyStrategy, UnserializableQueryValueError, queryString, queryStringOf, resetQueryStringOptions, setQueryStringOptions };
+//# sourceMappingURL=query-string.d.mts.map

package/esm/routing/query-string.mjs

@@ -0,0 +1,340 @@
+//#region ../web/src/routing/query-string.ts
+/**
+* Thrown when a query value has a shape the wire format cannot carry.
+*
+* Deliberately LOUD. The alternative is emitting something core silently
+* mangles — `a[b][c]=x` arrives as `{a: []}` — which is this defect all over
+* again, one layer further from where anyone would look for it.
+*/
+var UnserializableQueryValueError = class extends Error {
+	queryKey;
+	shape;
+	constructor(queryKey, shape) {
+		super(`Warlock cannot put ${shape} in a query string at "${queryKey}". The wire format is the one @warlock.js/core parses (core/src/http/request.ts:503-591): a value may be a scalar, an array of scalars (\`key[]=a&key[]=b\`), or an object one level deep whose values are scalars or arrays of scalars (\`key[sub]=a\`, \`key[sub][]=a\`). Anything deeper is refused rather than written, because core reads \`a[b][c]=x\` back as \`{a: []}\` — the value is destroyed on arrival with no error. Flatten the value, or JSON.stringify it into a single scalar and parse it on the server.`);
+		this.queryKey = queryKey;
+		this.shape = shape;
+		this.name = "UnserializableQueryValueError";
+	}
+};
+/**
+* Is this a BAG of query keys, as opposed to a value with its own string form?
+*
+* A `Date`, a `URL` or anything else carrying its own `toString` is a scalar
+* here — `String(value)` is meaningful for it, and turning it into
+* `since[getTime]=...` would be absurd. A plain object, or a class instance that
+* would otherwise stringify to the useless `"[object Object]"`, is a bag and
+* gets enumerated.
+*
+* The `typeof` check matters for null-prototype objects: they have no
+* `toString` at all, and `String()` on one THROWS.
+*/
+function isKeyBag(value) {
+	const stringForm = value.toString;
+	return typeof stringForm !== "function" || stringForm === Object.prototype.toString;
+}
+/** Refuse anything that is not a leaf. Used everywhere a leaf is the only legal shape. */
+function requireLeaf(key, value) {
+	if (Array.isArray(value)) throw new UnserializableQueryValueError(key, "a nested array");
+	if (typeof value === "object" && value !== null && isKeyBag(value)) throw new UnserializableQueryValueError(key, "a nested object");
+}
+/**
+* Append `key[]=element` per element.
+*
+* An `undefined` element is skipped, matching the top-level rule. Because the
+* `[]` form carries no indices, skipping shortens the array rather than leaving
+* a hole — there is no hole to leave.
+*
+* An EMPTY array appends nothing, so the key is absent from the URL. The format
+* has no way to say "an array with no elements": `key[]=` means the one-element
+* array `[""]`, which is a different value. A visible limitation beats a guess.
+*/
+function appendArray(search, key, value) {
+	const arrayKey = `${key}[]`;
+	for (const element of value) {
+		if (element === void 0) continue;
+		requireLeaf(arrayKey, element);
+		search.append(arrayKey, String(element));
+	}
+}
+/** Append `key[sub]=value`, or `key[sub][]=value` when the member is an array. */
+function appendBag(search, key, value) {
+	for (const [subKey, subValue] of Object.entries(value)) {
+		if (subValue === void 0) continue;
+		const nestedKey = `${key}[${subKey}]`;
+		if (Array.isArray(subValue)) {
+			appendArray(search, nestedKey, subValue);
+			continue;
+		}
+		requireLeaf(nestedKey, subValue);
+		search.append(nestedKey, String(subValue));
+	}
+}
+/**
+* Serialise a query object to a search string, INCLUDING the leading `?`.
+*
+* Returns `""` — not `"?"` — when there is nothing to write, so the result can
+* always be concatenated onto a path. `href()` is the primary caller; the
+* grammar it emits is the one core parses, and the whole justification is in the
+* module header.
+*
+* @throws {UnserializableQueryValueError} when a value nests deeper than the
+* wire format can carry.
+*/
+function queryStringOf(query) {
+	if (query === void 0) return "";
+	const search = new URLSearchParams();
+	for (const [key, value] of Object.entries(query)) {
+		if (value === void 0) continue;
+		if (Array.isArray(value)) {
+			appendArray(search, key, value);
+			continue;
+		}
+		if (typeof value === "object" && value !== null && isKeyBag(value)) {
+			appendBag(search, key, value);
+			continue;
+		}
+		search.append(key, String(value));
+	}
+	const serialized = search.toString();
+	return serialized === "" ? "" : `?${serialized}`;
+}
+const DEFAULT_OPTIONS = { repeatedKeys: "last" };
+/**
+* Held on `globalThis`, not in a module binding, for the reason measured and
+* written up at route-table.ts:43-65: in dev the process runs two module graphs
+* over these files (tsx/Node and Vite's SSR runner), so a `let` written by boot
+* code is not the `let` a component reads. A split here would be quiet — the
+* second graph would silently fall back to the defaults and decode a repeated
+* key the other way.
+*/
+const OPTIONS_SLOT = Symbol.for("warlock.web.queryStringOptions");
+function currentOptions() {
+	return globalThis[OPTIONS_SLOT] ?? DEFAULT_OPTIONS;
+}
+/**
+* Merge query-string options over the current ones.
+*
+* Named for `@mongez/react-router`'s function so migrating call sites keep
+* compiling; the OPTIONS are deliberately narrower, and `QueryStringOptions`
+* explains exactly which ones were refused and why.
+*/
+function setQueryStringOptions(options) {
+	globalThis[OPTIONS_SLOT] = {
+		...currentOptions(),
+		...options
+	};
+}
+/**
+* Drop back to the defaults.
+*
+* Exists because the options are process-global: a test that set one would
+* otherwise leak it into every later test in the same worker, passing in file
+* order and failing under `--shuffle`. Same reasoning as `resetRouteTable`.
+*/
+function resetQueryStringOptions() {
+	delete globalThis[OPTIONS_SLOT];
+}
+/**
+* The search string of the current document, or `""` when there is no document.
+*
+* The `typeof` guard is the SSR contract: no export in this module may touch a
+* DOM global without one.
+*/
+function browserSearch() {
+	if (typeof window === "undefined") return "";
+	return window.location?.search ?? "";
+}
+/**
+* Reduce anything search-shaped to the pairs themselves.
+*
+* Accepts `"?a=1"`, `"a=1"`, `"/path?a=1"` and a full URL, because
+* `location.href`, `location.search` and a hand-written literal all turn up at
+* this door and `new URLSearchParams("/path?a=1")` would answer with the key
+* `"/path?a"` — a wrong answer with no error. Cutting at the first `?` and the
+* first `#` is safe rather than heuristic: `queryStringOf` percent-encodes both
+* characters inside values (`%3F`, `%23`), so a literal one is always a
+* delimiter.
+*/
+function searchPairsOf(source) {
+	const withoutHash = source.split("#", 1)[0];
+	const questionMark = withoutHash.indexOf("?");
+	return questionMark === -1 ? withoutHash : withoutHash.slice(questionMark + 1);
+}
+/**
+* The three key shapes the encoder writes. Everything else is a literal key.
+*
+* The character classes exclude brackets, so each pattern matches exactly one
+* shape: `tags[]` cannot satisfy `NESTED`, and `a[b][c]` satisfies none of them.
+*/
+const ARRAY_KEY = /^([^[\]]+)\[\]$/;
+const NESTED_KEY = /^([^[\]]+)\[([^[\]]+)\]$/;
+const NESTED_ARRAY_KEY = /^([^[\]]+)\[([^[\]]+)\]\[\]$/;
+/**
+* Classify a decoded key.
+*
+* A shape neither side produces — `a[b][c]`, `items[0][name]`, an unbalanced
+* `a[` — falls through to `"plain"` and is carried VERBATIM. Those can only come
+* from a URL warlock did not write, and guessing at them is exactly how a
+* decoder drifts from its writer. Carrying the key as text loses nothing.
+*/
+function parseKey(key) {
+	const nestedArray = NESTED_ARRAY_KEY.exec(key);
+	if (nestedArray) return {
+		kind: "nestedArray",
+		name: nestedArray[1],
+		subKey: nestedArray[2]
+	};
+	const array = ARRAY_KEY.exec(key);
+	if (array) return {
+		kind: "array",
+		name: array[1]
+	};
+	const nested = NESTED_KEY.exec(key);
+	if (nested) return {
+		kind: "nested",
+		name: nested[1],
+		subKey: nested[2]
+	};
+	return {
+		kind: "plain",
+		name: key
+	};
+}
+/** A fresh bag with NO prototype. See {@link decode} for why that is not optional. */
+function emptyBag() {
+	return Object.create(null);
+}
+function isBag(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* The array living at `container[name]`, created if it is not there yet.
+*
+* A conflicting earlier shape is REPLACED rather than written into. `?a=1&a[]=2`
+* is not something the encoder can emit, so it is a foreign URL contradicting
+* itself; appending to a string would be a silent no-op, and last-shape-wins at
+* least matches how `repeatedKeys: "last"` resolves the scalar version.
+*/
+function arrayAt(container, name) {
+	const existing = container[name];
+	if (Array.isArray(existing)) return existing;
+	const created = [];
+	container[name] = created;
+	return created;
+}
+/** The bag living at `result[name]`, created if absent. Same last-shape-wins rule. */
+function bagAt(result, name) {
+	const existing = result[name];
+	if (isBag(existing)) return existing;
+	const created = emptyBag();
+	result[name] = created;
+	return created;
+}
+/**
+* The single decode path. Every reader below goes through here.
+*
+* Every container has a NULL PROTOTYPE — the result and each `key[sub]` bag.
+* Query keys are attacker-controlled, and assigning `?__proto__=x` onto a `{}`
+* literal hits the inherited setter, which DISCARDS the key: data loss with no
+* error. Bracket parsing makes this sharper than it was when this decoder was
+* flat, because `?filter[__proto__]=x` now reaches a nested container too —
+* which is why `bagAt` builds with `Object.create(null)` rather than `{}`.
+* MRR's parser walks `key.split("[")` onto plain objects and needs the blocklist
+* at query-string-parsers.ts:7 as a result; with no prototype there is no setter
+* to hit and the key is stored as the ordinary data it is.
+*/
+function decode(source) {
+	const pairs = searchPairsOf(source);
+	const result = emptyBag();
+	if (pairs === "") return result;
+	const { repeatedKeys } = currentOptions();
+	for (const [key, value] of new URLSearchParams(pairs)) {
+		const parsed = parseKey(key);
+		if (parsed.kind === "array") {
+			arrayAt(result, parsed.name).push(value);
+			continue;
+		}
+		if (parsed.kind === "nestedArray") {
+			arrayAt(bagAt(result, parsed.name), parsed.subKey).push(value);
+			continue;
+		}
+		if (parsed.kind === "nested") {
+			bagAt(result, parsed.name)[parsed.subKey] = value;
+			continue;
+		}
+		if (!(parsed.name in result)) {
+			result[parsed.name] = repeatedKeys === "array" ? [value] : value;
+			continue;
+		}
+		if (repeatedKeys === "first") continue;
+		if (repeatedKeys === "last") {
+			result[parsed.name] = value;
+			continue;
+		}
+		arrayAt(result, parsed.name).push(value);
+	}
+	return result;
+}
+/**
+* Reading the current query string, and any query string.
+*
+* Named for `@mongez/react-router`'s object so the familiar calls keep working;
+* the implementation is not ported — see the module header for what changed and
+* why.
+*/
+const queryString = {
+	/**
+	* The current document's query string, decoded.
+	*
+	* On the server this is `{}`, because the browser location is the only source
+	* this module has and a per-request one would be module state two concurrent
+	* requests could race over (route-table.ts:10-25).
+	*
+	* That makes it a HYDRATION HAZARD in a component: the server renders `{}`
+	* and the browser renders the real values, so the two trees differ. In a
+	* component, take the query from the page's own props and hand it to
+	* {@link queryString.parse}, which is universal. `all()` is for browser-only
+	* code — an event handler, an effect, a client-side helper.
+	*/
+	all() {
+		return decode(browserSearch());
+	},
+	/**
+	* Decode a query string that was handed to you.
+	*
+	* Universal: it reads no globals, so this is the entry point that is safe on
+	* the server. Accepts a bare pair list, a leading `?`, a path, or a full URL.
+	*/
+	parse(search) {
+		return decode(search);
+	},
+	/**
+	* One key from the current query string.
+	*
+	* PRESENCE, not truthiness. MRR returns `all[key] || defaultValue`
+	* (query-string.ts:43), which hands back the default for `?a=` — so a
+	* deliberately-cleared filter reads as though it was never set, and the page
+	* shows the default instead of the empty state. Here `?a=` returns `""`, and
+	* only an absent key returns the default.
+	*
+	* @param defaultValue returned only when the key is absent. Defaults to
+	* `null`, as MRR's does.
+	*/
+	get(key, defaultValue = null) {
+		const all = decode(browserSearch());
+		return key in all ? all[key] : defaultValue;
+	},
+	/**
+	* The current query string verbatim, without the leading `?`.
+	*
+	* `""` on the server, and `""` when there is no query — the same two cases
+	* `queryStringOf` collapses when it writes.
+	*/
+	toString() {
+		return searchPairsOf(browserSearch());
+	}
+};
+
+//#endregion
+export { UnserializableQueryValueError, queryString, queryStringOf, resetQueryStringOptions, setQueryStringOptions };
+//# sourceMappingURL=query-string.mjs.map

package/esm/routing/query-string.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-string.mjs","names":[],"sources":["../../../../../../../web/src/routing/query-string.ts"],"sourcesContent":["/**\n * The query string: BOTH directions, one grammar, one file.\n *\n * ── The rule this module exists to obey ──────────────────────────────────────\n *\n * `queryStringOf` is what `href(name, params, query)` appends, and therefore\n * what every `<Link>` puts in the document; `queryString.parse` is what reads it\n * back. They live together because a second, independently-written\n * query-string implementation would mean one thing writes URLs and a different\n * thing reads them. Query-string libraries genuinely disagree about arrays,\n * nested objects and space escaping, so the moment the two drift the round trip\n * loses data SILENTLY — the wrong value renders and no error is raised\n * anywhere. That is the two-route-matchers failure class (canon 9c8f878b) one\n * layer down.\n *\n * Escaping is not two rules that agree today. Both directions stand on\n * `URLSearchParams`: the encoder builds one and calls `.toString()`, the decoder\n * hands the string back to `new URLSearchParams(...)`. `+`-for-space and every\n * percent-encoding rule are therefore ONE rule and cannot drift.\n *\n * ── The grammar, and why it is not ours to choose ────────────────────────────\n *\n * Structure — arrays and nested objects — is the part `URLSearchParams` has no\n * opinion about, so it was read off the SERVER rather than invented. Warlock is\n * a backend framework and core already parses query strings for list endpoints\n * and filters; a client that emitted anything else would not have fixed this\n * module's bug, it would have moved it across the wire where it is harder to\n * see. Measured, with file:line, in\n * `reports/query-grammar-findings-2026-08-24.md`:\n *\n *   - `core/src/http/server.ts:14-36` configures Fastify with NO\n *     `querystringParser`, so find-my-way's `fast-querystring` default applies:\n *     flat keys, `+` is a space, a repeated key collapses to an array.\n *   - `core/src/http/request.ts:491` then runs `request.query` through\n *     `parseBody` — the SAME bracket-aware parser as the request body.\n *   - `core/src/http/request.ts:516-520` reads `key[]` as an array marker, and\n *     `:568-575` wraps a single `key[]=a` into the one-element array `[\"a\"]`.\n *   - `core/src/http/request.ts:557-561` turns `key[sub]=v` into\n *     `{key: {sub: v}}`, one level deep.\n *\n * So: `tags[]=a&tags[]=b` for arrays, `filter[status]=active` for objects,\n * `filter[tags][]=a` for an array inside an object. Bare repeated keys\n * (`tags=a&tags=b`) would also reach core as an array, but only at cardinality\n * two or more — `tags=a` comes back as the scalar `\"a\"`, and a shape that\n * changes with the number of matches is a `TypeError` waiting for the day a\n * filter matches one item. `[]` is the form core wrote a branch for.\n *\n * ── What is REFUSED, and why refusing is the safe answer ─────────────────────\n *\n * Two levels of nesting is not a gap in core, it is measured data loss:\n * `a[b][c]=x` takes the `][` branch at `core/src/http/request.ts:528-551`,\n * computes `Number(\"b\")` as `NaN`, and the value lands on a `NaN` index and\n * vanishes — core answers `{a: []}`. So the encoder throws\n * {@link UnserializableQueryValueError} rather than write it. `href()` already\n * throws on a missing route parameter rather than emit a link that renders\n * correctly and 404s; this is the same call.\n *\n * ── What the encoder still normalises, and what that costs ───────────────────\n *\n * Leaf values are serialised with `String(value)`, so every value arrives back\n * as a `string`: `href(\"p\", {}, { page: 2 })` writes `?page=2`, and `2` and\n * `\"2\"` are the same URL. The round-trip law that can actually hold is\n * `parse(encode(query)) === query with String() applied to its leaves and\n * undefined dropped`, and that is what the spec asserts. Asserting anything\n * stronger would be asserting a decoder that guesses types, which is how\n * `?zip=01234` becomes the number `1234`.\n *\n * The decoder does NOT split values on `,`: that would turn the legitimate\n * string `\"Doe, John\"` into `[\"Doe\", \" John\"]`, trading a visible limitation for\n * a silent corruption of ordinary data. Arrays are carried by `[]`, which is\n * unambiguous, so there is nothing left to guess at.\n *\n * ── Universal by requirement, not by accident ────────────────────────────────\n *\n * `web` renders on the server first, so every export here is safe to import and\n * to CALL with no DOM. `@mongez/react-router`'s equivalent reads\n * `window.location.search` unguarded (query-string.ts:22) and throws under SSR.\n * Here the browser-only readers return their empty answer instead — see\n * `queryString.all` for the hydration caveat that comes with that.\n *\n * ── Still NOT here: `toQueryString` and `update` ─────────────────────────────\n *\n * MRR exposes `toQueryString(params)` and `update(params)`, which SERIALISE.\n * The serialiser they need is no longer module-private — `queryStringOf` is\n * exported from here — so the old blocker is gone. What remains is that\n * `web/src/index.ts` does not re-export it yet, and the barrel is owned\n * elsewhere. That is a one-line follow-up, not a redesign.\n */\n\n/** A decoded leaf. Always a `string` — see the header on `String(value)`. */\nexport type QueryStringLeaf = string;\n\n/**\n * The inside of a `key[sub]` bag: one level deep, exactly as far as core parses.\n *\n * There is no deeper case to model. `key[sub][deeper]` is refused by the encoder\n * and carried verbatim as a literal key by the decoder, so a nested bag only\n * ever holds a leaf or an array of leaves.\n */\nexport type QueryStringNested = Record<string, QueryStringLeaf | QueryStringLeaf[]>;\n\n/** A decoded value: a leaf, a `key[]` array, or a `key[sub]` bag. */\nexport type QueryStringValue = QueryStringLeaf | QueryStringLeaf[] | QueryStringNested;\n\n/** A decoded query string. */\nexport type QueryStringObject = Record<string, QueryStringValue>;\n\n/** What {@link queryStringOf} accepts. Values are validated, not trusted. */\nexport type QueryStringInput = Readonly<Record<string, unknown>>;\n\n/**\n * Thrown when a query value has a shape the wire format cannot carry.\n *\n * Deliberately LOUD. The alternative is emitting something core silently\n * mangles — `a[b][c]=x` arrives as `{a: []}` — which is this defect all over\n * again, one layer further from where anyone would look for it.\n */\nexport class UnserializableQueryValueError extends Error {\n  public constructor(\n    public readonly queryKey: string,\n    public readonly shape: string,\n  ) {\n    super(\n      `Warlock cannot put ${shape} in a query string at \"${queryKey}\". The wire format is the ` +\n        \"one @warlock.js/core parses (core/src/http/request.ts:503-591): a value may be a \" +\n        \"scalar, an array of scalars (`key[]=a&key[]=b`), or an object one level deep whose \" +\n        \"values are scalars or arrays of scalars (`key[sub]=a`, `key[sub][]=a`). Anything \" +\n        \"deeper is refused rather than written, because core reads `a[b][c]=x` back as \" +\n        \"`{a: []}` — the value is destroyed on arrival with no error. Flatten the value, or \" +\n        \"JSON.stringify it into a single scalar and parse it on the server.\",\n    );\n    this.name = \"UnserializableQueryValueError\";\n  }\n}\n\n/**\n * Is this a BAG of query keys, as opposed to a value with its own string form?\n *\n * A `Date`, a `URL` or anything else carrying its own `toString` is a scalar\n * here — `String(value)` is meaningful for it, and turning it into\n * `since[getTime]=...` would be absurd. A plain object, or a class instance that\n * would otherwise stringify to the useless `\"[object Object]\"`, is a bag and\n * gets enumerated.\n *\n * The `typeof` check matters for null-prototype objects: they have no\n * `toString` at all, and `String()` on one THROWS.\n */\nfunction isKeyBag(value: object): boolean {\n  const stringForm = (value as { toString?: unknown }).toString;\n\n  return typeof stringForm !== \"function\" || stringForm === Object.prototype.toString;\n}\n\n/** Refuse anything that is not a leaf. Used everywhere a leaf is the only legal shape. */\nfunction requireLeaf(key: string, value: unknown): void {\n  if (Array.isArray(value)) {\n    throw new UnserializableQueryValueError(key, \"a nested array\");\n  }\n\n  if (typeof value === \"object\" && value !== null && isKeyBag(value)) {\n    throw new UnserializableQueryValueError(key, \"a nested object\");\n  }\n}\n\n/**\n * Append `key[]=element` per element.\n *\n * An `undefined` element is skipped, matching the top-level rule. Because the\n * `[]` form carries no indices, skipping shortens the array rather than leaving\n * a hole — there is no hole to leave.\n *\n * An EMPTY array appends nothing, so the key is absent from the URL. The format\n * has no way to say \"an array with no elements\": `key[]=` means the one-element\n * array `[\"\"]`, which is a different value. A visible limitation beats a guess.\n */\nfunction appendArray(search: URLSearchParams, key: string, value: readonly unknown[]): void {\n  const arrayKey = `${key}[]`;\n\n  for (const element of value) {\n    if (element === undefined) continue;\n\n    requireLeaf(arrayKey, element);\n\n    search.append(arrayKey, String(element));\n  }\n}\n\n/** Append `key[sub]=value`, or `key[sub][]=value` when the member is an array. */\nfunction appendBag(search: URLSearchParams, key: string, value: object): void {\n  for (const [subKey, subValue] of Object.entries(value)) {\n    if (subValue === undefined) continue;\n\n    const nestedKey = `${key}[${subKey}]`;\n\n    if (Array.isArray(subValue)) {\n      appendArray(search, nestedKey, subValue);\n      continue;\n    }\n\n    requireLeaf(nestedKey, subValue);\n\n    search.append(nestedKey, String(subValue));\n  }\n}\n\n/**\n * Serialise a query object to a search string, INCLUDING the leading `?`.\n *\n * Returns `\"\"` — not `\"?\"` — when there is nothing to write, so the result can\n * always be concatenated onto a path. `href()` is the primary caller; the\n * grammar it emits is the one core parses, and the whole justification is in the\n * module header.\n *\n * @throws {UnserializableQueryValueError} when a value nests deeper than the\n * wire format can carry.\n */\nexport function queryStringOf(query: QueryStringInput | undefined): string {\n  if (query === undefined) return \"\";\n\n  const search = new URLSearchParams();\n\n  for (const [key, value] of Object.entries(query)) {\n    if (value === undefined) continue;\n\n    if (Array.isArray(value)) {\n      appendArray(search, key, value);\n      continue;\n    }\n\n    if (typeof value === \"object\" && value !== null && isKeyBag(value)) {\n      appendBag(search, key, value);\n      continue;\n    }\n\n    search.append(key, String(value));\n  }\n\n  const serialized = search.toString();\n\n  return serialized === \"\" ? \"\" : `?${serialized}`;\n}\n\n/**\n * What to do when the same PLAIN key appears more than once, e.g. `?tag=a&tag=b`.\n *\n * - `\"last\"` — keep the final occurrence. Matches `URLSearchParams.get()`, the\n *   read side of the primitive the encoder writes with, and keeps every value a\n *   `string`.\n * - `\"first\"` — keep the earliest occurrence.\n * - `\"array\"` — collect every occurrence. Under this strategy a key that occurs\n *   ONCE is still an array of one, because a shape that changes with the number\n *   of values is a `TypeError` waiting for the day a filter matches a single\n *   item.\n *\n * It does NOT govern `key[]` or `key[sub]`; those are shapes the encoder writes\n * deliberately, and their meaning is fixed. See {@link QueryStringOptions}.\n */\nexport type RepeatedKeyStrategy = \"last\" | \"first\" | \"array\";\n\n/**\n * The whole option surface.\n *\n * ── Why this is one flag and not MRR's pluggable parsers ─────────────────────\n *\n * MRR's `setQueryStringOptions` swaps `objectParser` and `stringParser`\n * (query-string.ts:10-15). Neither survives contact with a fixed, shared\n * encoder:\n *\n *   - A pluggable `objectParser` is a licence to install a READER that disagrees\n *     with the writer. It is precisely the silent round-trip break this module\n *     was written to prevent, offered as a supported API.\n *   - A pluggable `stringParser` would be worse: it cannot reach `href()`, which\n *     calls `queryStringOf` directly with no hook. Setting it would change what\n *     this module emits while every `<Link>` on the page kept emitting the old\n *     format — two writers, disagreeing, by configuration.\n *\n * `repeatedKeys` is safe for one specific reason, and the reason survived the\n * move to bracket notation: `queryStringOf` iterates `Object.entries`, so it can\n * never emit a duplicate PLAIN key. It now does emit duplicate `key[]` pairs —\n * that is how an array is written — but those go down the array branch of the\n * decoder, which this flag does not touch. Were the flag to govern the bracket\n * forms as well, `repeatedKeys: \"array\"` would decode `filter[x]=1` as\n * `{filter: {x: [\"1\"]}}` and break the round trip BY CONFIGURATION.\n *\n * So the flag still decides only something the encoder has no opinion about: a\n * repeated plain key, which can only arrive from a URL this package did not\n * write — hand-typed, external links, `GET` forms.\n *\n * Set it at BOOT, not per request: this is process-global config, and a\n * request-scoped write would be read by whatever request happens to be\n * rendering (the defect catalogued at route-table.ts:10-25).\n */\nexport type QueryStringOptions = {\n  readonly repeatedKeys?: RepeatedKeyStrategy;\n};\n\ntype ResolvedQueryStringOptions = Required<QueryStringOptions>;\n\nconst DEFAULT_OPTIONS: ResolvedQueryStringOptions = {\n  repeatedKeys: \"last\",\n};\n\n/**\n * Held on `globalThis`, not in a module binding, for the reason measured and\n * written up at route-table.ts:43-65: in dev the process runs two module graphs\n * over these files (tsx/Node and Vite's SSR runner), so a `let` written by boot\n * code is not the `let` a component reads. A split here would be quiet — the\n * second graph would silently fall back to the defaults and decode a repeated\n * key the other way.\n */\nconst OPTIONS_SLOT = Symbol.for(\"warlock.web.queryStringOptions\");\n\ntype OptionsHost = typeof globalThis & {\n  [OPTIONS_SLOT]?: ResolvedQueryStringOptions;\n};\n\nfunction currentOptions(): ResolvedQueryStringOptions {\n  return (globalThis as OptionsHost)[OPTIONS_SLOT] ?? DEFAULT_OPTIONS;\n}\n\n/**\n * Merge query-string options over the current ones.\n *\n * Named for `@mongez/react-router`'s function so migrating call sites keep\n * compiling; the OPTIONS are deliberately narrower, and `QueryStringOptions`\n * explains exactly which ones were refused and why.\n */\nexport function setQueryStringOptions(options: QueryStringOptions): void {\n  (globalThis as OptionsHost)[OPTIONS_SLOT] = { ...currentOptions(), ...options };\n}\n\n/**\n * Drop back to the defaults.\n *\n * Exists because the options are process-global: a test that set one would\n * otherwise leak it into every later test in the same worker, passing in file\n * order and failing under `--shuffle`. Same reasoning as `resetRouteTable`.\n */\nexport function resetQueryStringOptions(): void {\n  delete (globalThis as OptionsHost)[OPTIONS_SLOT];\n}\n\n/**\n * The search string of the current document, or `\"\"` when there is no document.\n *\n * The `typeof` guard is the SSR contract: no export in this module may touch a\n * DOM global without one.\n */\nfunction browserSearch(): string {\n  if (typeof window === \"undefined\") return \"\";\n\n  return window.location?.search ?? \"\";\n}\n\n/**\n * Reduce anything search-shaped to the pairs themselves.\n *\n * Accepts `\"?a=1\"`, `\"a=1\"`, `\"/path?a=1\"` and a full URL, because\n * `location.href`, `location.search` and a hand-written literal all turn up at\n * this door and `new URLSearchParams(\"/path?a=1\")` would answer with the key\n * `\"/path?a\"` — a wrong answer with no error. Cutting at the first `?` and the\n * first `#` is safe rather than heuristic: `queryStringOf` percent-encodes both\n * characters inside values (`%3F`, `%23`), so a literal one is always a\n * delimiter.\n */\nfunction searchPairsOf(source: string): string {\n  const withoutHash = source.split(\"#\", 1)[0];\n  const questionMark = withoutHash.indexOf(\"?\");\n\n  return questionMark === -1 ? withoutHash : withoutHash.slice(questionMark + 1);\n}\n\n/**\n * The three key shapes the encoder writes. Everything else is a literal key.\n *\n * The character classes exclude brackets, so each pattern matches exactly one\n * shape: `tags[]` cannot satisfy `NESTED`, and `a[b][c]` satisfies none of them.\n */\nconst ARRAY_KEY = /^([^[\\]]+)\\[\\]$/;\nconst NESTED_KEY = /^([^[\\]]+)\\[([^[\\]]+)\\]$/;\nconst NESTED_ARRAY_KEY = /^([^[\\]]+)\\[([^[\\]]+)\\]\\[\\]$/;\n\ntype ParsedKey =\n  | { kind: \"plain\"; name: string }\n  | { kind: \"array\"; name: string }\n  | { kind: \"nested\"; name: string; subKey: string }\n  | { kind: \"nestedArray\"; name: string; subKey: string };\n\n/**\n * Classify a decoded key.\n *\n * A shape neither side produces — `a[b][c]`, `items[0][name]`, an unbalanced\n * `a[` — falls through to `\"plain\"` and is carried VERBATIM. Those can only come\n * from a URL warlock did not write, and guessing at them is exactly how a\n * decoder drifts from its writer. Carrying the key as text loses nothing.\n */\nfunction parseKey(key: string): ParsedKey {\n  const nestedArray = NESTED_ARRAY_KEY.exec(key);\n\n  if (nestedArray) {\n    return { kind: \"nestedArray\", name: nestedArray[1], subKey: nestedArray[2] };\n  }\n\n  const array = ARRAY_KEY.exec(key);\n\n  if (array) return { kind: \"array\", name: array[1] };\n\n  const nested = NESTED_KEY.exec(key);\n\n  if (nested) return { kind: \"nested\", name: nested[1], subKey: nested[2] };\n\n  return { kind: \"plain\", name: key };\n}\n\n/** A fresh bag with NO prototype. See {@link decode} for why that is not optional. */\nfunction emptyBag<T extends object>(): T {\n  return Object.create(null) as T;\n}\n\nfunction isBag(value: unknown): value is QueryStringNested {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\n/**\n * The array living at `container[name]`, created if it is not there yet.\n *\n * A conflicting earlier shape is REPLACED rather than written into. `?a=1&a[]=2`\n * is not something the encoder can emit, so it is a foreign URL contradicting\n * itself; appending to a string would be a silent no-op, and last-shape-wins at\n * least matches how `repeatedKeys: \"last\"` resolves the scalar version.\n */\nfunction arrayAt(container: Record<string, unknown>, name: string): string[] {\n  const existing = container[name];\n\n  if (Array.isArray(existing)) return existing;\n\n  const created: string[] = [];\n\n  container[name] = created;\n\n  return created;\n}\n\n/** The bag living at `result[name]`, created if absent. Same last-shape-wins rule. */\nfunction bagAt(result: QueryStringObject, name: string): QueryStringNested {\n  const existing = result[name];\n\n  if (isBag(existing)) return existing;\n\n  const created = emptyBag<QueryStringNested>();\n\n  result[name] = created;\n\n  return created;\n}\n\n/**\n * The single decode path. Every reader below goes through here.\n *\n * Every container has a NULL PROTOTYPE — the result and each `key[sub]` bag.\n * Query keys are attacker-controlled, and assigning `?__proto__=x` onto a `{}`\n * literal hits the inherited setter, which DISCARDS the key: data loss with no\n * error. Bracket parsing makes this sharper than it was when this decoder was\n * flat, because `?filter[__proto__]=x` now reaches a nested container too —\n * which is why `bagAt` builds with `Object.create(null)` rather than `{}`.\n * MRR's parser walks `key.split(\"[\")` onto plain objects and needs the blocklist\n * at query-string-parsers.ts:7 as a result; with no prototype there is no setter\n * to hit and the key is stored as the ordinary data it is.\n */\nfunction decode(source: string): QueryStringObject {\n  const pairs = searchPairsOf(source);\n  const result = emptyBag<QueryStringObject>();\n\n  if (pairs === \"\") return result;\n\n  const { repeatedKeys } = currentOptions();\n\n  for (const [key, value] of new URLSearchParams(pairs)) {\n    const parsed = parseKey(key);\n\n    if (parsed.kind === \"array\") {\n      arrayAt(result, parsed.name).push(value);\n      continue;\n    }\n\n    if (parsed.kind === \"nestedArray\") {\n      arrayAt(bagAt(result, parsed.name), parsed.subKey).push(value);\n      continue;\n    }\n\n    if (parsed.kind === \"nested\") {\n      // Last wins. The encoder cannot repeat a `key[sub]` pair — `Object.entries`\n      // yields each sub-key once — so this only arises from a foreign URL, and\n      // `repeatedKeys` deliberately does not reach here (QueryStringOptions).\n      bagAt(result, parsed.name)[parsed.subKey] = value;\n      continue;\n    }\n\n    if (!(parsed.name in result)) {\n      result[parsed.name] = repeatedKeys === \"array\" ? [value] : value;\n      continue;\n    }\n\n    if (repeatedKeys === \"first\") continue;\n\n    if (repeatedKeys === \"last\") {\n      result[parsed.name] = value;\n      continue;\n    }\n\n    arrayAt(result, parsed.name).push(value);\n  }\n\n  return result;\n}\n\n/**\n * Reading the current query string, and any query string.\n *\n * Named for `@mongez/react-router`'s object so the familiar calls keep working;\n * the implementation is not ported — see the module header for what changed and\n * why.\n */\nexport const queryString = {\n  /**\n   * The current document's query string, decoded.\n   *\n   * On the server this is `{}`, because the browser location is the only source\n   * this module has and a per-request one would be module state two concurrent\n   * requests could race over (route-table.ts:10-25).\n   *\n   * That makes it a HYDRATION HAZARD in a component: the server renders `{}`\n   * and the browser renders the real values, so the two trees differ. In a\n   * component, take the query from the page's own props and hand it to\n   * {@link queryString.parse}, which is universal. `all()` is for browser-only\n   * code — an event handler, an effect, a client-side helper.\n   */\n  all(): QueryStringObject {\n    return decode(browserSearch());\n  },\n\n  /**\n   * Decode a query string that was handed to you.\n   *\n   * Universal: it reads no globals, so this is the entry point that is safe on\n   * the server. Accepts a bare pair list, a leading `?`, a path, or a full URL.\n   */\n  parse(search: string): QueryStringObject {\n    return decode(search);\n  },\n\n  /**\n   * One key from the current query string.\n   *\n   * PRESENCE, not truthiness. MRR returns `all[key] || defaultValue`\n   * (query-string.ts:43), which hands back the default for `?a=` — so a\n   * deliberately-cleared filter reads as though it was never set, and the page\n   * shows the default instead of the empty state. Here `?a=` returns `\"\"`, and\n   * only an absent key returns the default.\n   *\n   * @param defaultValue returned only when the key is absent. Defaults to\n   * `null`, as MRR's does.\n   */\n  get<T = null>(key: string, defaultValue: T = null as T): QueryStringValue | T {\n    const all = decode(browserSearch());\n\n    return key in all ? all[key] : defaultValue;\n  },\n\n  /**\n   * The current query string verbatim, without the leading `?`.\n   *\n   * `\"\"` on the server, and `\"\"` when there is no query — the same two cases\n   * `queryStringOf` collapses when it writes.\n   */\n  toString(): string {\n    return searchPairsOf(browserSearch());\n  },\n};\n"],"mappings":";;;;;;;;AAqHA,IAAa,gCAAb,cAAmD,MAAM;CAErC;CACA;CAFlB,AAAO,YACL,AAAgB,UAChB,AAAgB,OAChB;EACA,MACE,sBAAsB,MAAM,yBAAyB,SAAS,6fAOhE;EAXgB;EACA;EAWhB,KAAK,OAAO;CACd;AACF;;;;;;;;;;;;;AAcA,SAAS,SAAS,OAAwB;CACxC,MAAM,aAAc,MAAiC;CAErD,OAAO,OAAO,eAAe,cAAc,eAAe,OAAO,UAAU;AAC7E;;AAGA,SAAS,YAAY,KAAa,OAAsB;CACtD,IAAI,MAAM,QAAQ,KAAK,GACrB,MAAM,IAAI,8BAA8B,KAAK,gBAAgB;CAG/D,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,SAAS,KAAK,GAC/D,MAAM,IAAI,8BAA8B,KAAK,iBAAiB;AAElE;;;;;;;;;;;;AAaA,SAAS,YAAY,QAAyB,KAAa,OAAiC;CAC1F,MAAM,WAAW,GAAG,IAAI;CAExB,KAAK,MAAM,WAAW,OAAO;EAC3B,IAAI,YAAY,QAAW;EAE3B,YAAY,UAAU,OAAO;EAE7B,OAAO,OAAO,UAAU,OAAO,OAAO,CAAC;CACzC;AACF;;AAGA,SAAS,UAAU,QAAyB,KAAa,OAAqB;CAC5E,KAAK,MAAM,CAAC,QAAQ,aAAa,OAAO,QAAQ,KAAK,GAAG;EACtD,IAAI,aAAa,QAAW;EAE5B,MAAM,YAAY,GAAG,IAAI,GAAG,OAAO;EAEnC,IAAI,MAAM,QAAQ,QAAQ,GAAG;GAC3B,YAAY,QAAQ,WAAW,QAAQ;GACvC;EACF;EAEA,YAAY,WAAW,QAAQ;EAE/B,OAAO,OAAO,WAAW,OAAO,QAAQ,CAAC;CAC3C;AACF;;;;;;;;;;;;AAaA,SAAgB,cAAc,OAA6C;CACzE,IAAI,UAAU,QAAW,OAAO;CAEhC,MAAM,SAAS,IAAI,gBAAgB;CAEnC,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,GAAG;EAChD,IAAI,UAAU,QAAW;EAEzB,IAAI,MAAM,QAAQ,KAAK,GAAG;GACxB,YAAY,QAAQ,KAAK,KAAK;GAC9B;EACF;EAEA,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,SAAS,KAAK,GAAG;GAClE,UAAU,QAAQ,KAAK,KAAK;GAC5B;EACF;EAEA,OAAO,OAAO,KAAK,OAAO,KAAK,CAAC;CAClC;CAEA,MAAM,aAAa,OAAO,SAAS;CAEnC,OAAO,eAAe,KAAK,KAAK,IAAI;AACtC;AA0DA,MAAM,kBAA8C,EAClD,cAAc,OAChB;;;;;;;;;AAUA,MAAM,eAAe,OAAO,IAAI,gCAAgC;AAMhE,SAAS,iBAA6C;CACpD,OAAQ,WAA2B,iBAAiB;AACtD;;;;;;;;AASA,SAAgB,sBAAsB,SAAmC;CACvE,AAAC,WAA2B,gBAAgB;EAAE,GAAG,eAAe;EAAG,GAAG;CAAQ;AAChF;;;;;;;;AASA,SAAgB,0BAAgC;CAC9C,OAAQ,WAA2B;AACrC;;;;;;;AAQA,SAAS,gBAAwB;CAC/B,IAAI,OAAO,WAAW,aAAa,OAAO;CAE1C,OAAO,OAAO,UAAU,UAAU;AACpC;;;;;;;;;;;;AAaA,SAAS,cAAc,QAAwB;CAC7C,MAAM,cAAc,OAAO,MAAM,KAAK,CAAC,CAAC,CAAC;CACzC,MAAM,eAAe,YAAY,QAAQ,GAAG;CAE5C,OAAO,iBAAiB,KAAK,cAAc,YAAY,MAAM,eAAe,CAAC;AAC/E;;;;;;;AAQA,MAAM,YAAY;AAClB,MAAM,aAAa;AACnB,MAAM,mBAAmB;;;;;;;;;AAgBzB,SAAS,SAAS,KAAwB;CACxC,MAAM,cAAc,iBAAiB,KAAK,GAAG;CAE7C,IAAI,aACF,OAAO;EAAE,MAAM;EAAe,MAAM,YAAY;EAAI,QAAQ,YAAY;CAAG;CAG7E,MAAM,QAAQ,UAAU,KAAK,GAAG;CAEhC,IAAI,OAAO,OAAO;EAAE,MAAM;EAAS,MAAM,MAAM;CAAG;CAElD,MAAM,SAAS,WAAW,KAAK,GAAG;CAElC,IAAI,QAAQ,OAAO;EAAE,MAAM;EAAU,MAAM,OAAO;EAAI,QAAQ,OAAO;CAAG;CAExE,OAAO;EAAE,MAAM;EAAS,MAAM;CAAI;AACpC;;AAGA,SAAS,WAAgC;CACvC,OAAO,OAAO,OAAO,IAAI;AAC3B;AAEA,SAAS,MAAM,OAA4C;CACzD,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;AAC5E;;;;;;;;;AAUA,SAAS,QAAQ,WAAoC,MAAwB;CAC3E,MAAM,WAAW,UAAU;CAE3B,IAAI,MAAM,QAAQ,QAAQ,GAAG,OAAO;CAEpC,MAAM,UAAoB,CAAC;CAE3B,UAAU,QAAQ;CAElB,OAAO;AACT;;AAGA,SAAS,MAAM,QAA2B,MAAiC;CACzE,MAAM,WAAW,OAAO;CAExB,IAAI,MAAM,QAAQ,GAAG,OAAO;CAE5B,MAAM,UAAU,SAA4B;CAE5C,OAAO,QAAQ;CAEf,OAAO;AACT;;;;;;;;;;;;;;AAeA,SAAS,OAAO,QAAmC;CACjD,MAAM,QAAQ,cAAc,MAAM;CAClC,MAAM,SAAS,SAA4B;CAE3C,IAAI,UAAU,IAAI,OAAO;CAEzB,MAAM,EAAE,iBAAiB,eAAe;CAExC,KAAK,MAAM,CAAC,KAAK,UAAU,IAAI,gBAAgB,KAAK,GAAG;EACrD,MAAM,SAAS,SAAS,GAAG;EAE3B,IAAI,OAAO,SAAS,SAAS;GAC3B,QAAQ,QAAQ,OAAO,IAAI,CAAC,CAAC,KAAK,KAAK;GACvC;EACF;EAEA,IAAI,OAAO,SAAS,eAAe;GACjC,QAAQ,MAAM,QAAQ,OAAO,IAAI,GAAG,OAAO,MAAM,CAAC,CAAC,KAAK,KAAK;GAC7D;EACF;EAEA,IAAI,OAAO,SAAS,UAAU;GAI5B,MAAM,QAAQ,OAAO,IAAI,CAAC,CAAC,OAAO,UAAU;GAC5C;EACF;EAEA,IAAI,EAAE,OAAO,QAAQ,SAAS;GAC5B,OAAO,OAAO,QAAQ,iBAAiB,UAAU,CAAC,KAAK,IAAI;GAC3D;EACF;EAEA,IAAI,iBAAiB,SAAS;EAE9B,IAAI,iBAAiB,QAAQ;GAC3B,OAAO,OAAO,QAAQ;GACtB;EACF;EAEA,QAAQ,QAAQ,OAAO,IAAI,CAAC,CAAC,KAAK,KAAK;CACzC;CAEA,OAAO;AACT;;;;;;;;AASA,MAAa,cAAc;;;;;;;;;;;;;;CAczB,MAAyB;EACvB,OAAO,OAAO,cAAc,CAAC;CAC/B;;;;;;;CAQA,MAAM,QAAmC;EACvC,OAAO,OAAO,MAAM;CACtB;;;;;;;;;;;;;CAcA,IAAc,KAAa,eAAkB,MAAiC;EAC5E,MAAM,MAAM,OAAO,cAAc,CAAC;EAElC,OAAO,OAAO,MAAM,IAAI,OAAO;CACjC;;;;;;;CAQA,WAAmB;EACjB,OAAO,cAAc,cAAc,CAAC;CACtC;AACF"}