@ogygia/devtools 0.0.0 → 0.11.0

package/dist/profiler/source-scan.js

@@ -0,0 +1,1724 @@
+// src/profiler/source-scan.ts
+const is_id_start = (c) => c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 36 || c === 95 || c > 127;
+const is_id_part = (c) => is_id_start(c) || c >= 48 && c <= 57;
+const PUNCT2 = /* @__PURE__ */ new Set([
+	"=>",
+	"+=",
+	"?.",
+	"&&",
+	"||",
+	"??",
+	"==",
+	"!=",
+	"<=",
+	">=",
+	"++",
+	"--"
+]);
+/** One line of JS/TS as tokens: identifiers and keywords as they are, every string literal as
+*  `""`, every number as `0`, punctuation one token each (`...`, `=>`, `+=`, `?.` kept whole).
+*  Comments are dropped. A template literal is one string token followed by each `${…}` part's
+*  own tokens in parentheses (`\`t${i + k}\`` → `""`, `(`, `i`, `+`, `k`, `)`), so the code inside
+*  it is seen. */
+function tokens(line) {
+	const out = [];
+	const n = line.length;
+	let i = 0;
+	while (i < n) {
+		const c = line.charCodeAt(i);
+		if (c === 32 || c === 9 || c === 13) {
+			i++;
+			continue;
+		}
+		if (c === 47 && line.charCodeAt(i + 1) === 47) break;
+		if (c === 47 && line.charCodeAt(i + 1) === 42) {
+			const e = line.indexOf("*/", i + 2);
+			if (e < 0) break;
+			i = e + 2;
+			continue;
+		}
+		if (c === 34 || c === 39 || c === 96) {
+			let j = i + 1;
+			/** a template literal's `${…}` parts: code, tokenized after the string's own token */
+			const parts = [];
+			while (j < n) {
+				const d = line.charCodeAt(j);
+				if (d === 92) {
+					j += 2;
+					continue;
+				}
+				if (d === c) break;
+				if (c === 96 && d === 36 && line.charCodeAt(j + 1) === 123) {
+					let depth = 1;
+					let k = j + 2;
+					while (k < n && depth > 0) {
+						const e = line.charCodeAt(k);
+						if (e === 123) depth++;
+						else if (e === 125) depth--;
+						if (depth > 0) k++;
+					}
+					parts.push(line.slice(j + 2, k));
+					j = k + 1;
+					continue;
+				}
+				j++;
+			}
+			out.push("\"\"");
+			for (const p of parts) out.push("(", ...tokens(p), ")");
+			i = j + 1;
+			continue;
+		}
+		if (is_id_start(c)) {
+			let j = i + 1;
+			while (j < n && is_id_part(line.charCodeAt(j))) j++;
+			out.push(line.slice(i, j));
+			i = j;
+			continue;
+		}
+		if (c >= 48 && c <= 57) {
+			let j = i + 1;
+			while (j < n && (is_id_part(line.charCodeAt(j)) || line.charCodeAt(j) === 46)) j++;
+			out.push("0");
+			i = j;
+			continue;
+		}
+		if (c === 46 && line.charCodeAt(i + 1) === 46 && line.charCodeAt(i + 2) === 46) {
+			out.push("...");
+			i += 3;
+			continue;
+		}
+		const two = line.slice(i, i + 2);
+		if (PUNCT2.has(two)) {
+			out.push(two);
+			i += 2;
+			continue;
+		}
+		out.push(line[i]);
+		i++;
+	}
+	return out;
+}
+/** The lines of a function from its first line to its closing brace (brace-balanced over tokens,
+*  so braces in strings and comments do not count); a braceless arrow is its one line. Capped. */
+function function_body(source, path, start, max = 400) {
+	const got = source(path, start, start + max);
+	if (!got) return void 0;
+	let depth = 0;
+	let opened = false;
+	for (let i = 0; i < got.lines.length; i++) {
+		for (const t of tokens(got.lines[i])) if (t === "{") {
+			depth++;
+			opened = true;
+		} else if (t === "}") depth--;
+		if (opened && depth <= 0) return {
+			start: got.start,
+			lines: got.lines.slice(0, i + 1)
+		};
+		if (!opened && i === 0 && got.lines[0].includes("=>")) return {
+			start: got.start,
+			lines: got.lines.slice(0, 1)
+		};
+	}
+	return got;
+}
+/** the first lines of a file, where its imports and top-level wrappers sit */
+const HEAD_LINES = 400;
+/** A module's import aliases: `import { renderToString as render } from 'x'` → renderToString → [render]. */
+function import_aliases(source, path) {
+	const out = /* @__PURE__ */ new Map();
+	const head = source(path, 1, HEAD_LINES);
+	if (!head) return out;
+	let inside = false;
+	for (const line of head.lines) {
+		const t = tokens(line);
+		for (let k = 0; k < t.length; k++) if (t[k] === "import") inside = true;
+		else if (t[k] === "from" || t[k] === ";") inside = false;
+		else if (inside && t[k] === "as" && t[k - 1] && t[k + 1] && t[k - 1] !== "*") push(out, t[k - 1], t[k + 1]);
+	}
+	return out;
+}
+/** The names a function also goes by in its module when it is WRAPPED:
+*  `const renderToString = instrument(render, 'ds.render')` → render → [renderToString].
+*  The shape is `const|let|var X = <call chain>(name` — the function is the wrapper's first argument. */
+function wrapper_aliases(source, path) {
+	const out = /* @__PURE__ */ new Map();
+	const head = source(path, 1, HEAD_LINES);
+	if (!head) return out;
+	for (const line of head.lines) {
+		const t = tokens(line);
+		for (let k = 0; k + 3 < t.length; k++) {
+			if (t[k] !== "const" && t[k] !== "let" && t[k] !== "var" || t[k + 2] !== "=") continue;
+			let j = k + 3;
+			while (j < t.length && (t[j] === "." || t[j] !== "(" && t[j] !== ")" && is_id_start(t[j].charCodeAt(0)))) j++;
+			if (j === k + 3 || t[j] !== "(" || !t[j + 1] || !is_id_start(t[j + 1].charCodeAt(0))) continue;
+			if (t[j + 2] !== "," && t[j + 2] !== ")") continue;
+			push(out, t[j + 1], t[k + 1]);
+		}
+	}
+	return out;
+}
+/** how V8 names a compiled regular expression's code in a CPU profile: `RegExp: ^(\w+\s?)*$` */
+const REGEXP_FRAME = "RegExp: ";
+/**
+* CAN THIS PATTERN BACKTRACK HARD? A repeated group that itself repeats something (`(\w+\s?)*`,
+* `(a+)+`, `(?:x*y?)+`): the engine can split the same text many ways and tries them all before a
+* match fails. (A repeated choice, `(a|aa)+`, can too, but `(foo|bar)+` is the usual one and
+* harmless: not claimed.) A character scan, not a parse: escapes and classes are skipped over.
+*/
+function backtracks(source) {
+	if (!source) return false;
+	/** what follows an atom at `i`: `'many'` (`*`, `+`, `{n,}`), `'maybe'` (`?`, `{0,1}`-ish), or
+	*  `'once'` (none, or a fixed `{n}`) */
+	const after = (i) => {
+		const c = source[i];
+		if (c === "*" || c === "+") return "many";
+		if (c === "?") return "maybe";
+		if (c === "{") {
+			const close = source.indexOf("}", i);
+			const comma = source.indexOf(",", i);
+			if (close !== -1 && comma !== -1 && comma < close) return "many";
+		}
+		return "once";
+	};
+	const stack = [{
+		repeats: false,
+		fixed: false,
+		choice: false
+	}];
+	const top = () => stack[stack.length - 1];
+	const atom = (q) => {
+		if (q === "many") top().repeats = true;
+		else if (q === "once") top().fixed = true;
+	};
+	for (let i = 0; i < source.length; i++) {
+		const c = source[i];
+		if (c === "\\") {
+			i++;
+			atom(after(i + 1));
+			continue;
+		}
+		if (c === "[") {
+			for (i++; i < source.length && source[i] !== "]"; i++) if (source[i] === "\\") i++;
+			atom(after(i + 1));
+			continue;
+		}
+		if (c === "(") {
+			stack.push({
+				repeats: false,
+				fixed: false,
+				choice: false
+			});
+			if (source[i + 1] === "?") {
+				i++;
+				if (source[i + 1] === "<" && source[i + 2] !== "=" && source[i + 2] !== "!") {
+					const end = source.indexOf(">", i);
+					if (end !== -1) i = end;
+				} else i++;
+			}
+			continue;
+		}
+		if (c === ")") {
+			if (stack.length < 2) continue;
+			const g = stack.pop();
+			const q = after(i + 1);
+			if (q === "many" && g.repeats && !g.fixed && !g.choice) return true;
+			if (q === "many" || g.repeats) top().repeats = true;
+			if (q === "once" && g.fixed) top().fixed = true;
+			continue;
+		}
+		if (c === "|") {
+			top().choice = true;
+			continue;
+		}
+		if (c === "{") {
+			const close = source.indexOf("}", i);
+			if (close !== -1) i = close;
+			continue;
+		}
+		if (c === "^" || c === "$" || c === "*" || c === "+" || c === "?" || c === "}") continue;
+		atom(after(i + 1));
+	}
+	return false;
+}
+/**
+* THE REGEX LITERALS WRITTEN ON A LINE (their source, without the slashes and flags): a `/` where
+* an expression starts (after `(`, `,`, `=`, `:`, `[`, `!`, `&`, `|`, `?`, `{`, `;`, `return`, or
+* at the start) opens one. Strings, template text and comments are skipped; a division is not a
+* literal (it follows a value).
+*/
+function regex_literals(code) {
+	const out = [];
+	let prev = "";
+	let word = "";
+	for (let i = 0; i < code.length; i++) {
+		const c = code[i];
+		if (c === "\"" || c === "'" || c === "`") {
+			for (i++; i < code.length && code[i] !== c; i++) if (code[i] === "\\") i++;
+			prev = c;
+			word = "";
+			continue;
+		}
+		if (c === "/" && code[i + 1] === "/") break;
+		if (c === "/" && code[i + 1] === "*") {
+			const end = code.indexOf("*/", i + 2);
+			if (end === -1) break;
+			i = end + 1;
+			continue;
+		}
+		if (c === "/") {
+			if (prev === "" || "(,=:[!&|?{};".includes(prev) || word === "return") {
+				let j = i + 1;
+				let in_class = false;
+				for (; j < code.length; j++) {
+					const d = code[j];
+					if (d === "\\") {
+						j++;
+						continue;
+					}
+					if (d === "[") in_class = true;
+					else if (d === "]") in_class = false;
+					else if (d === "/" && !in_class) break;
+				}
+				if (j < code.length && j > i + 1) {
+					out.push(code.slice(i + 1, j));
+					i = j;
+					while (i + 1 < code.length && ID_CHAR(code[i + 1])) i++;
+					prev = ")";
+					word = "";
+					continue;
+				}
+			}
+		}
+		if (c === " " || c === "	") continue;
+		word = ID_CHAR(c) ? ID_CHAR(prev) ? word + c : c : "";
+		prev = c;
+	}
+	return out;
+}
+const ID_CHAR = (c) => !!c && (c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c >= "0" && c <= "9" || c === "_" || c === "$");
+/** does this line call `name(` (plain or as a method), outside strings and comments? */
+function calls_name(line, names) {
+	const t = tokens(line);
+	for (let k = 0; k + 1 < t.length; k++) if (t[k + 1] === "(" && names.includes(t[k]) && t[k - 1] !== "function") return true;
+	return false;
+}
+/** The functions a hooks file's `handle` is made of, when they live in OTHER app modules:
+*  `export const handle = sequence(ds_ssr, auth)` with `import { ds_ssr } from '$lib/ds-ssr'` →
+*  ds_ssr → `ds-ssr`. The value is the module's file stem, so a CPU frame counts as that handle
+*  only when it is named so AND sits in that file. A handle written in the hooks file itself is
+*  not listed (its frames are in the hooks file already), and neither is one from a package (a
+*  library's frames say what they are) or one made by a call (`auth()`: what it returns has its
+*  own name). */
+function handle_parts(source, path) {
+	const out = /* @__PURE__ */ new Map();
+	const text = source(path, 1, 2e3);
+	if (!text) return out;
+	/** local name → the name it was exported under and the module's file stem */
+	const imported = /* @__PURE__ */ new Map();
+	let pending = [];
+	let inside = false;
+	const all = [];
+	for (const line of text.lines) {
+		const t = tokens(line);
+		for (let k = 0; k < t.length; k++) {
+			const w = t[k];
+			if (w === "import" && (k === 0 || t[k - 1] === ";")) {
+				inside = true;
+				pending = [];
+			} else if (inside && w === "from") {
+				const stem = app_module_stem(spec_after_from(line));
+				if (stem) for (const [name, local] of pending) imported.set(local, {
+					name,
+					stem
+				});
+				inside = false;
+			} else if (inside && w === "type") k++;
+			else if (inside && is_id_start(w.charCodeAt(0)) && w !== "as") {
+				if (t[k + 1] === "as" && t[k + 2]) {
+					pending.push([w, t[k + 2]]);
+					k += 2;
+				} else pending.push([w, w]);
+			}
+		}
+		for (const w of t) all.push(w);
+	}
+	for (let k = 0; k + 3 < all.length; k++) {
+		if (all[k] !== "export" || all[k + 1] !== "const" && all[k + 1] !== "let" || all[k + 2] !== "handle") continue;
+		let j = k + 3;
+		while (j < all.length && all[j] !== "=") j++;
+		j++;
+		const take = (name) => {
+			const hit = imported.get(name);
+			if (hit) out.set(hit.name, hit.stem);
+		};
+		if (all[j + 1] !== "(") {
+			take(all[j]);
+			break;
+		}
+		let depth = 0;
+		for (let i = j + 1; i < all.length; i++) {
+			const w = all[i];
+			if (w === "(" || w === "[" || w === "{") depth++;
+			else if (w === ")" || w === "]" || w === "}") {
+				if (--depth === 0) break;
+			} else if (depth === 1 && (all[i - 1] === "(" || all[i - 1] === ",") && (all[i + 1] === "," || all[i + 1] === ")")) take(w);
+		}
+		break;
+	}
+	return out;
+}
+/** the quoted module specifier after the last `from` on a line (`''` when there is none) */
+function spec_after_from(line) {
+	const at = line.lastIndexOf("from");
+	if (at === -1) return "";
+	let i = at + 4;
+	while (i < line.length && line[i] !== "'" && line[i] !== "\"") i++;
+	const end = line.indexOf(line[i], i + 1);
+	return end === -1 ? "" : line.slice(i + 1, end);
+}
+/** an app module's file stem (`$lib/hell/ds-ssr` → `ds-ssr`, `./auth.js` → `auth`); undefined for
+*  a package (`@sveltejs/kit/hooks`, `ogygia/server`) */
+function app_module_stem(spec) {
+	const c = spec[0];
+	if (c !== "." && c !== "/" && c !== "$" && c !== "~" && c !== "#") return void 0;
+	const leaf = spec.slice(spec.lastIndexOf("/") + 1);
+	const dot = leaf.indexOf(".");
+	const stem = dot === -1 ? leaf : leaf.slice(0, dot);
+	return stem && stem !== "index" ? stem : void 0;
+}
+function push(m, k, v) {
+	const list = m.get(k);
+	if (!list) m.set(k, [v]);
+	else if (!list.includes(v)) list.push(v);
+}
+/** a word that is not a variable: the language's own, and the ones a statement reads by */
+const NOT_A_NAME = /* @__PURE__ */ new Set([
+	"await",
+	"async",
+	"return",
+	"const",
+	"let",
+	"var",
+	"new",
+	"typeof",
+	"instanceof",
+	"in",
+	"of",
+	"if",
+	"else",
+	"for",
+	"while",
+	"do",
+	"function",
+	"true",
+	"false",
+	"null",
+	"undefined",
+	"this",
+	"as",
+	"satisfies",
+	"void",
+	"delete",
+	"yield",
+	"throw",
+	"try",
+	"catch",
+	"finally",
+	"switch",
+	"case",
+	"break",
+	"continue",
+	"default",
+	"class",
+	"extends",
+	"super",
+	"import",
+	"export"
+]);
+/** a method that fills the value it is called on: `list.push(x)` writes `list` */
+const FILLS = /* @__PURE__ */ new Set([
+	"push",
+	"unshift",
+	"set",
+	"add",
+	"splice",
+	"assign"
+]);
+/**
+* WHERE EACH RETURNED KEY COMES FROM: the lines of a `load` whose values end up in each key of its
+* `return { … }` — a key's expression, the variables it reads, the lines that declare or fill those
+* (`const live = await fetch(…)`, `stock.push(await stockOf(…))`), and so on back through what they
+* read. 1-based line numbers of `source`. A wait made on one of a key's lines is a wait for that
+* key. Tokens only (no regex); null when there is no `load` or its return is not an object literal.
+*/
+/**
+* WHERE A FILE'S `load` IS: its `export` line, and the lines its block body opens and closes on
+* (0-based). `export async function load(…): Promise<{ a: string }> {` — the return type's braces
+* are skipped; `export const load = async (…) => {` — the block after its arrow (a `satisfies`
+* wrapper around it too). An expression body (`=> ({ … })`) has no block: null, never the next
+* function in the file.
+*/
+function load_span(T) {
+	let head = -1;
+	let is_fn = false;
+	for (let i = 0; i < T.length && head < 0; i++) {
+		const t = T[i];
+		if (t[0] !== "export") continue;
+		for (let k = 1; k + 1 < t.length; k++) if (t[k + 1] === "load" && (t[k] === "const" || t[k] === "function")) {
+			head = i;
+			is_fn = t[k] === "function";
+		}
+	}
+	if (head < 0) return null;
+	const flat = [];
+	for (let i = head; i < T.length; i++) for (const t of T[i]) flat.push({
+		t,
+		line: i
+	});
+	let k = flat.findIndex((x) => x.t === "load");
+	let open = -1;
+	if (is_fn) {
+		while (k < flat.length && flat[k].t !== "(") k++;
+		let paren = 0;
+		for (; k < flat.length; k++) if (flat[k].t === "(") paren++;
+		else if (flat[k].t === ")" && --paren === 0) break;
+		let angle = 0;
+		for (k++; k < flat.length && open < 0; k++) {
+			const x = flat[k].t;
+			const prev = flat[k - 1].t;
+			if (x === "<") angle++;
+			else if (x === ">") angle--;
+			else if (x === "{" && angle === 0) {
+				if (prev === ":" || prev === "|" || prev === "&" || prev === "(") {
+					let d = 0;
+					for (; k < flat.length; k++) if (flat[k].t === "{") d++;
+					else if (flat[k].t === "}" && --d === 0) break;
+				} else open = k;
+			}
+		}
+	} else {
+		while (k < flat.length && flat[k].t !== "=>") k++;
+		if (k + 1 < flat.length && flat[k + 1].t === "{") open = k + 1;
+	}
+	if (open < 0) return null;
+	let d = 0;
+	for (let j = open; j < flat.length; j++) if (flat[j].t === "{") d++;
+	else if (flat[j].t === "}" && --d === 0) return {
+		head,
+		body0: flat[open].line,
+		body1: flat[j].line
+	};
+	return null;
+}
+function key_sources(source) {
+	const T = source.split("\n").map((l) => tokens(l));
+	const span = load_span(T);
+	if (!span) return null;
+	const { body0, body1 } = span;
+	const names = /* @__PURE__ */ new Map();
+	const name_of = (n) => names.get(n) ?? names.set(n, {
+		lines: /* @__PURE__ */ new Set(),
+		deps: /* @__PURE__ */ new Set(),
+		decl: []
+	}).get(n);
+	/** the variables a stretch of tokens reads — not a property (`x.p`), and not a callback's own
+	*  parameter (`(p) => …`, `p => …`: a local, whatever else is called `p`) */
+	const ids = (list) => {
+		const params = /* @__PURE__ */ new Set();
+		for (let m = 0; m < list.length; m++) {
+			if (list[m] !== "=>") continue;
+			if (list[m - 1] !== ")") {
+				if (list[m - 1]) params.add(list[m - 1]);
+				continue;
+			}
+			let d = 0;
+			for (let j = m - 1; j >= 0; j--) if (list[j] === ")") d++;
+			else if (list[j] === "(" && --d === 0) break;
+			else if (d >= 1 && is_id_start(list[j].charCodeAt(0)) && list[j - 1] !== ":") params.add(list[j]);
+		}
+		return list.filter((t, k) => is_id_start(t.charCodeAt(0)) && !NOT_A_NAME.has(t) && !params.has(t) && list[k - 1] !== "." && list[k - 1] !== "?.");
+	};
+	for (let i = body0; i <= body1; i++) {
+		const t = T[i];
+		for (let k = 0; k < t.length; k++) {
+			if (t[k] !== "const" && t[k] !== "let" && t[k] !== "var") continue;
+			const declared = [];
+			let j = k + 1;
+			let depth = 0;
+			let typed = false;
+			for (; j < t.length; j++) {
+				const x = t[j];
+				if (depth === 0 && (x === "=" || x === "of" || x === "in")) break;
+				if (x === "{" || x === "[" || x === "(" || x === "<") depth++;
+				else if (x === "}" || x === "]" || x === ")" || x === ">") depth--;
+				else if (x === ":" && depth === 0) typed = true;
+				else if (!typed && is_id_start(x.charCodeAt(0)) && !NOT_A_NAME.has(x) && (depth === 0 || t[j + 1] !== ":")) declared.push(x);
+			}
+			if (!declared.length) continue;
+			if (j >= t.length) {
+				for (const d of declared) {
+					const n = name_of(d);
+					n.decl.push(/* @__PURE__ */ new Set([i + 1]));
+					n.lines.add(i + 1);
+				}
+				break;
+			}
+			const rhs = t.slice(j + 1);
+			const at = /* @__PURE__ */ new Set([i + 1]);
+			let open = 0;
+			for (const x of rhs) open += x === "(" || x === "[" || x === "{" ? 1 : x === ")" || x === "]" || x === "}" ? -1 : 0;
+			for (let m = i + 1; open > 0 && m <= body1; m++) {
+				at.add(m + 1);
+				for (const x of T[m]) {
+					rhs.push(x);
+					open += x === "(" || x === "[" || x === "{" ? 1 : x === ")" || x === "]" || x === "}" ? -1 : 0;
+				}
+			}
+			const deps = ids(rhs);
+			for (const d of declared) {
+				const n = name_of(d);
+				n.decl.push(at);
+				for (const l of at) n.lines.add(l);
+				for (const x of deps) if (x !== d) n.deps.add(x);
+			}
+			break;
+		}
+	}
+	for (let i = body0; i <= body1; i++) {
+		const t = T[i];
+		for (let k = 0; k < t.length; k++) {
+			const n = names.get(t[k]);
+			if (!n || t[k - 1] === "." || t[k - 1] === "?.") continue;
+			const fills = t[k + 1] === "." && FILLS.has(t[k + 2]) && t[k + 3] === "(";
+			let after = k + 1;
+			if (t[after] === "[") {
+				let d = 0;
+				for (; after < t.length; after++) if (t[after] === "[") d++;
+				else if (t[after] === "]" && --d === 0) break;
+				after++;
+			} else if (t[after] === "." && t[after + 2] === "=") after += 2;
+			const assigns = (t[after] === "=" || t[after] === "+=") && (k === 0 || t[k - 1] === ";" || t[k - 1] === "{" || t[k - 1] === ")" || t[k - 1] === "else");
+			if (!fills && !assigns) continue;
+			n.lines.add(i + 1);
+			for (const x of ids(t)) if (x !== t[k]) n.deps.add(x);
+		}
+	}
+	for (const n of names.values()) for (const d of Array.from(n.deps)) if (names.get(d)?.decl.some((set) => [...set].every((l) => n.lines.has(l)))) n.deps.delete(d);
+	let ret = -1;
+	{
+		let depth = 0;
+		for (let i = body0; i <= body1; i++) {
+			const t = T[i];
+			for (let k = 0; k < t.length; k++) if (t[k] === "{") depth++;
+			else if (t[k] === "}") depth--;
+			else if (t[k] === "return" && depth === 1 && (t[k + 1] === "{" || t[k + 1] === "(" && t[k + 2] === "{")) ret = i;
+		}
+	}
+	if (ret < 0) return null;
+	const flat = [];
+	for (let i = ret; i <= body1; i++) for (const t of T[i]) flat.push({
+		t,
+		line: i + 1
+	});
+	let s = flat.findIndex((x) => x.t === "return");
+	while (s < flat.length && flat[s].t !== "{") s++;
+	const keys = /* @__PURE__ */ new Map();
+	{
+		let depth = 0;
+		let key = null;
+		let expect_key = true;
+		for (let i = s; i < flat.length; i++) {
+			const x = flat[i].t;
+			if (x === "{" || x === "[" || x === "(") {
+				depth++;
+				if (depth === 1) continue;
+			} else if (x === "}" || x === "]" || x === ")") {
+				depth--;
+				if (depth === 0) break;
+			}
+			if (depth === 1 && x === ",") {
+				key = null;
+				expect_key = true;
+				continue;
+			}
+			if (depth === 1 && expect_key) {
+				expect_key = false;
+				if (x === "...") continue;
+				if (!is_id_start(x.charCodeAt(0))) continue;
+				key = x;
+				const entry = {
+					reads: [],
+					lines: /* @__PURE__ */ new Set([flat[i].line]),
+					toks: []
+				};
+				keys.set(x, entry);
+				const next = flat[i + 1]?.t;
+				if (next === "," || next === "}") entry.reads.push(x);
+				continue;
+			}
+			if (key && x !== ":") {
+				const k = keys.get(key);
+				k.lines.add(flat[i].line);
+				k.toks.push(x);
+			}
+		}
+	}
+	if (!keys.size) return null;
+	for (const k of keys.values()) k.reads.push(...ids(k.toks));
+	const helpers = /* @__PURE__ */ new Map();
+	for (let i = 0; i < T.length; i++) {
+		if (i >= body0 && i <= body1) continue;
+		const t = T[i];
+		const f = t.indexOf("function");
+		const c = t.indexOf("const");
+		const name = f !== -1 && is_id_start((t[f + 1] ?? "").charCodeAt(0)) ? t[f + 1] : c !== -1 && t[c + 2] === "=" && t.includes("=>") ? t[c + 1] : void 0;
+		if (!name || name === "load") continue;
+		let depth = 0;
+		let opened = false;
+		const span = [];
+		for (let j = i; j < T.length; j++) {
+			span.push(j + 1);
+			for (const x of T[j]) if (x === "{") {
+				depth++;
+				opened = true;
+			} else if (x === "}") depth--;
+			if (opened && depth <= 0 || !opened && j === i) break;
+		}
+		helpers.set(name, span);
+	}
+	const calls_on = (line) => T[line - 1]?.filter((x, k, t) => helpers.has(x) && t[k + 1] === "(") ?? [];
+	const out = /* @__PURE__ */ new Map();
+	for (const [key, k] of keys) {
+		const lines_of = new Set(k.lines);
+		const seen = /* @__PURE__ */ new Set();
+		const stack = [...k.reads];
+		while (stack.length) {
+			const n = stack.pop();
+			if (seen.has(n)) continue;
+			seen.add(n);
+			const d = names.get(n);
+			if (!d) continue;
+			for (const l of d.lines) lines_of.add(l);
+			for (const x of d.deps) stack.push(x);
+		}
+		const todo = [...lines_of];
+		const took = /* @__PURE__ */ new Set();
+		while (todo.length) for (const h of calls_on(todo.pop())) {
+			if (took.has(h)) continue;
+			took.add(h);
+			for (const l of helpers.get(h)) if (!lines_of.has(l)) {
+				lines_of.add(l);
+				todo.push(l);
+			}
+		}
+		out.set(key, [...lines_of].sort((a, b) => a - b));
+	}
+	return out;
+}
+/** One line's reads and writes: the names it declares or assigns (`const a =`, `a =`, `a += `,
+*  `a[k] =`), the receivers it fills (`list.push(…)`), and the variables it reads (not a property,
+*  not a callback's own parameter, not a name it only writes). `declared`: written by a
+*  declaration (fresh each time the line runs: never carried from one loop turn to the next). */
+function line_rw(line) {
+	const t = tokens(line);
+	const writes = /* @__PURE__ */ new Set();
+	const declared = /* @__PURE__ */ new Set();
+	/** `x += …` targets: added to, in any order */
+	const accum = /* @__PURE__ */ new Set();
+	const params = /* @__PURE__ */ new Set();
+	for (let m = 0; m < t.length; m++) {
+		if (t[m] !== "=>") continue;
+		if (t[m - 1] !== ")") {
+			if (t[m - 1]) params.add(t[m - 1]);
+			continue;
+		}
+		let d = 0;
+		for (let j = m - 1; j >= 0; j--) if (t[j] === ")") d++;
+		else if (t[j] === "(" && --d === 0) break;
+		else if (d >= 1 && is_id_start(t[j].charCodeAt(0)) && t[j - 1] !== ":") params.add(t[j]);
+	}
+	/** token indexes that are written, not read */
+	const skip = /* @__PURE__ */ new Set();
+	for (let k = 0; k < t.length; k++) {
+		if (t[k] === "const" || t[k] === "let" || t[k] === "var") {
+			let depth = 0;
+			for (let j = k + 1; j < t.length; j++) {
+				const x = t[j];
+				if (depth === 0 && (x === "=" || x === "of" || x === "in" || x === ":")) break;
+				if (x === "{" || x === "[") depth++;
+				else if (x === "}" || x === "]") depth--;
+				else if (is_id_start(x.charCodeAt(0)) && !NOT_A_NAME.has(x)) {
+					skip.add(j);
+					if (depth === 0 || t[j + 1] !== ":") {
+						declared.add(x);
+						writes.add(x);
+					}
+				}
+			}
+			continue;
+		}
+		if (!is_id_start(t[k].charCodeAt(0)) || NOT_A_NAME.has(t[k]) || t[k - 1] === "." || t[k - 1] === "?.") continue;
+		if (t[k + 1] === "." && FILLS.has(t[k + 2]) && t[k + 3] === "(") {
+			writes.add(t[k]);
+			skip.add(k);
+			continue;
+		}
+		let after = k + 1;
+		if (t[after] === "[") {
+			let d = 0;
+			for (; after < t.length; after++) if (t[after] === "[") d++;
+			else if (t[after] === "]" && --d === 0) break;
+			after++;
+		} else if (t[after] === "." && t[after + 2] === "=") after += 2;
+		if (t[after] === "=" || t[after] === "+=") {
+			writes.add(t[k]);
+			if (t[after] === "=") skip.add(k);
+			else accum.add(t[k]);
+		}
+	}
+	const reads = /* @__PURE__ */ new Set();
+	for (let k = 0; k < t.length; k++) {
+		const x = t[k];
+		if (skip.has(k) || !is_id_start(x.charCodeAt(0)) || NOT_A_NAME.has(x) || params.has(x) || t[k - 1] === "." || t[k - 1] === "?.") continue;
+		if (t[k + 1] === ":" && (t[k - 1] === "{" || t[k - 1] === ",")) continue;
+		reads.add(x);
+	}
+	return {
+		reads: [...reads],
+		writes: [...writes],
+		declared: [...declared],
+		accum: [...accum]
+	};
+}
+/**
+* DOES THE LATER CALL NEED THE EARLIER ONE'S ANSWER? Two lines of one file: true when `to` reads a
+* name `from` wrote, directly or through the lines between (`const a = await x()` → `const id =
+* a.id` → `await y(id)`). One line (a loop making the calls): true when a turn feeds the next — a
+* name assigned (not declared) on it or the few lines after it, that it reads (`cursor = (await
+* get(cursor)).next`). Then the calls cannot run together, and "waits in a row" is not a fix.
+*/
+function needs_previous(source, path, from, to) {
+	if (from === to) {
+		const got = source(path, from, from + 3);
+		if (!got) return false;
+		const here = line_rw(got.lines[0]);
+		const carried = /* @__PURE__ */ new Set();
+		for (const l of got.lines) {
+			const rw = line_rw(l);
+			for (const w of rw.writes) if (!rw.declared.includes(w)) carried.add(w);
+		}
+		return here.reads.some((r) => carried.has(r) && !here.accum.includes(r));
+	}
+	if (to < from || to - from > 200) return false;
+	const got = source(path, from, to);
+	if (!got || got.lines.length < 2) return false;
+	const produced = new Set(line_rw(got.lines[0]).writes);
+	for (let i = 1; i < got.lines.length; i++) {
+		const rw = line_rw(got.lines[i]);
+		const hit = rw.reads.some((r) => produced.has(r));
+		if (i === got.lines.length - 1) return hit;
+		if (hit) for (const w of rw.writes) produced.add(w);
+	}
+	return false;
+}
+/**
+* WHAT THE PAGE WAITED ON THE LAYOUT FOR: in a load that does `await parent()`, the line doing it,
+* the names it sets (`const { session } = await parent()` → session), and the first line after it
+* that reads one of them (null: none does). The `await`s in between waited on the layout's loads
+* for data they never used. 1-based lines; null when there is no `await parent()`.
+*/
+function parent_use(source) {
+	const lines = source.split("\n");
+	let at = -1;
+	for (let i = 0; i < lines.length && at < 0; i++) {
+		const t = tokens(lines[i]);
+		for (let k = 0; k + 2 < t.length; k++) if (t[k] === "await" && t[k + 1] === "parent" && t[k + 2] === "(") at = i;
+	}
+	if (at < 0) return null;
+	const names = line_rw(lines[at]).writes;
+	if (!names.length) return null;
+	const set = new Set(names);
+	let awaits = 0;
+	let depth = 0;
+	for (let i = at + 1; i < lines.length; i++) {
+		const t = tokens(lines[i]);
+		if (line_rw(lines[i]).reads.some((r) => set.has(r))) return {
+			line: at + 1,
+			names,
+			first_use: i + 1,
+			awaits_before_use: awaits
+		};
+		if (t.includes("await")) awaits++;
+		for (const x of t) depth += x === "{" ? 1 : x === "}" ? -1 : 0;
+		if (depth < 0) break;
+	}
+	return {
+		line: at + 1,
+		names,
+		first_use: null,
+		awaits_before_use: awaits
+	};
+}
+/** globals whose calls give the same answer for the same input (a clock, a random or the network
+*  are not among them: `Date`, `Math`, `performance`, `crypto`, `fetch`) */
+const PURE_GLOBALS = /* @__PURE__ */ new Set([
+	"Object",
+	"Array",
+	"JSON",
+	"String",
+	"Number",
+	"Boolean",
+	"Map",
+	"Set",
+	"structuredClone",
+	"parseInt",
+	"parseFloat",
+	"encodeURIComponent",
+	"decodeURIComponent",
+	"RegExp",
+	"Intl"
+]);
+const NODE_MODULES = /* @__PURE__ */ new Set([
+	"crypto",
+	"fs",
+	"fs/promises",
+	"os",
+	"path",
+	"process",
+	"child_process",
+	"http",
+	"https",
+	"net",
+	"perf_hooks",
+	"worker_threads",
+	"async_hooks",
+	"util",
+	"timers",
+	"url",
+	"zlib",
+	"stream",
+	"buffer",
+	"events",
+	"dns",
+	"cluster",
+	"v8",
+	"vm"
+]);
+/** a module whose exports answer per call or per request, never a value to compute once: Node's own
+*  (`randomUUID`, `readFileSync`, `hrtime`) and the framework's request-bound ones (`getRequestEvent`,
+*  dynamic env) */
+function per_call_module(from) {
+	return from.startsWith("node:") || NODE_MODULES.has(from) || from.startsWith("$app/") || from.startsWith("$env/dynamic/");
+}
+/** the quoted module an `import … from '…'` line names ('' when it names none on this line) */
+function import_source(line) {
+	const f = line.lastIndexOf("from");
+	const at = f === -1 ? line.indexOf("import") + 6 : f + 4;
+	for (let i = at; i < line.length; i++) {
+		const q = line[i];
+		if (q !== "'" && q !== "\"") continue;
+		const e = line.indexOf(q, i + 1);
+		return e === -1 ? "" : line.slice(i + 1, e);
+	}
+	return "";
+}
+/** globals whose every use can answer differently: the network, a clock, the process, timers */
+const PER_CALL_GLOBALS = /* @__PURE__ */ new Set([
+	"fetch",
+	"performance",
+	"crypto",
+	"process",
+	"globalThis",
+	"setTimeout",
+	"setInterval",
+	"setImmediate",
+	"queueMicrotask",
+	"require"
+]);
+/** methods that change what their receiver holds */
+const MUTATORS = /* @__PURE__ */ new Set([
+	"push",
+	"pop",
+	"shift",
+	"unshift",
+	"splice",
+	"sort",
+	"reverse",
+	"fill",
+	"copyWithin",
+	"set",
+	"add",
+	"delete",
+	"clear"
+]);
+/** the names a line CHANGES without declaring: `x = …`, `x.a.b = …`, `x[k] += …`, `x.list.push(…)`,
+*  `x.n++`, `delete x.k`, `Object.assign(x, …)` — the root name of each changed chain */
+function changed_names(t) {
+	const out = /* @__PURE__ */ new Set();
+	for (let k = 0; k < t.length; k++) {
+		const x = t[k];
+		if (!is_id_start(x.charCodeAt(0)) || NOT_A_NAME.has(x) || t[k - 1] === "." || t[k - 1] === "?.") continue;
+		if (t[k - 1] === "const" || t[k - 1] === "let" || t[k - 1] === "var") continue;
+		if (x === "Object" && t[k + 1] === "." && t[k + 2] === "assign" && t[k + 3] === "(" && is_id_start((t[k + 4] ?? "").charCodeAt(0))) out.add(t[k + 4]);
+		if (t[k - 1] === "delete") out.add(x);
+		let j = k + 1;
+		let last = "";
+		while (j < t.length) if ((t[j] === "." || t[j] === "?.") && is_id_start((t[j + 1] ?? "").charCodeAt(0))) {
+			last = t[j + 1];
+			j += 2;
+		} else if (t[j] === "[") {
+			let d = 0;
+			for (; j < t.length; j++) if (t[j] === "[") d++;
+			else if (t[j] === "]" && --d === 0) break;
+			last = "";
+			j++;
+		} else break;
+		const after = t[j];
+		if (after === "=" || after === "+=" || after === "-=" || after === "*=" || after === "/=" || after === "||=" || after === "&&=" || after === "??=" || after === "++" || after === "--") out.add(x);
+		else if (after === "(" && j > k + 1 && MUTATORS.has(last)) out.add(x);
+		else if (t[k - 1] === "++" || t[k - 1] === "--") out.add(x);
+	}
+	return [...out];
+}
+function constant_work(source, spans = false) {
+	const lines = source.split("\n");
+	const T = lines.map((l) => tokens(l));
+	const span = load_span(T);
+	if (!span) return [];
+	const { head, body0, body1 } = span;
+	const module_names = /* @__PURE__ */ new Set();
+	/** what a per-call module gives (`randomUUID`, `readFileSync`) */
+	const per_call = /* @__PURE__ */ new Set();
+	/** the file's state: top-level `let` / `var`, and a `const` made with `new` (a cache) */
+	const state = /* @__PURE__ */ new Set();
+	/** the file's own helpers (a `function`, or a `const` holding one), each with its lines */
+	const helpers = [];
+	let file_depth = 0;
+	for (let i = 0; i < T.length; i++) {
+		const t = T[i];
+		const at_top = file_depth === 0;
+		for (const x of t) file_depth += x === "{" ? 1 : x === "}" ? -1 : 0;
+		if (!at_top || i >= head && i <= body1) continue;
+		if (t[0] === "import") {
+			let end = i;
+			let text = lines[i];
+			const all = [...t];
+			let open = 0;
+			for (const x of t) open += x === "{" ? 1 : x === "}" ? -1 : 0;
+			while (open > 0 && end + 1 < T.length) {
+				end++;
+				text += "\n" + lines[end];
+				for (const x of T[end]) {
+					all.push(x);
+					open += x === "{" ? 1 : x === "}" ? -1 : 0;
+				}
+			}
+			i = end;
+			file_depth = 0;
+			const into = per_call_module(import_source(text.split("\n").pop())) ? per_call : module_names;
+			const from = all.indexOf("from");
+			for (let k = 1; k < (from === -1 ? all.length : from); k++) if (is_id_start(all[k].charCodeAt(0)) && all[k] !== "type" && all[k] !== "as" && all[k + 1] !== "as") into.add(all[k]);
+			continue;
+		}
+		const j = t[0] === "export" ? 1 : 0;
+		const k = t[j] === "async" ? j + 1 : j;
+		const name = t[k + 1] ?? "";
+		if ((t[k] === "let" || t[k] === "var") && is_id_start(name.charCodeAt(0))) state.add(name);
+		if (t[k] === "const" && t.includes("new")) {
+			if (is_id_start(name.charCodeAt(0))) state.add(name);
+			continue;
+		}
+		if ((t[k] === "const" || t[k] === "function" || t[k] === "class") && is_id_start(name.charCodeAt(0))) {
+			module_names.add(name);
+			let to = i;
+			const opens = (x) => x === "{" || x === "(" || x === "[" ? 1 : x === "}" || x === ")" || x === "]" ? -1 : 0;
+			let d = 0;
+			for (const x of t) d += opens(x);
+			const continues = (row) => {
+				const last = row[row.length - 1];
+				return last === "=>" || last === "=" || last === "(" || last === "," || last === "?" || last === ":" || last === "&&" || last === "||" || last === "??";
+			};
+			while ((d > 0 || continues(T[to])) && to + 1 < T.length) {
+				to++;
+				for (const x of T[to]) d += opens(x);
+			}
+			if (t[k] !== "class" && (t[k] === "function" || t.includes("=>"))) helpers.push({
+				name,
+				from: i,
+				to
+			});
+		}
+	}
+	const impure = (t) => {
+		for (let k = 0; k < t.length; k++) {
+			const x = t[k];
+			if (t[k - 1] === "." || t[k - 1] === "?.") continue;
+			if (per_call.has(x) || PER_CALL_GLOBALS.has(x)) return true;
+			if (x === "Math" && t[k + 2] === "random") return true;
+			if (x === "Date" && (t[k + 2] === "now" || t[k - 1] === "new" && t[k + 1] === "(" && t[k + 2] === ")")) return true;
+			if (helpers.some((h) => h.name === x) && !module_names.has(x)) return true;
+		}
+		return changed_names(t).some((n) => state.has(n));
+	};
+	for (let dropped = true; dropped;) {
+		dropped = false;
+		for (const h of helpers) {
+			if (!module_names.has(h.name)) continue;
+			for (let i = h.from; i <= h.to; i++) if (impure(T[i])) {
+				module_names.delete(h.name);
+				dropped = true;
+				break;
+			}
+		}
+	}
+	const changed = /* @__PURE__ */ new Set();
+	for (let i = body0 + 1; i < body1; i++) for (const n of changed_names(T[i])) changed.add(n);
+	const local = /* @__PURE__ */ new Set();
+	for (let i = body0 + 1; i < body1; i++) for (const n of line_rw(lines[i]).declared) local.add(n);
+	for (let i = head; i <= body0; i++) for (const x of T[i]) if (is_id_start(x.charCodeAt(0)) && !NOT_A_NAME.has(x) && x !== "load" && x !== "export" && x !== "const" && x !== "async" && x !== "function") local.add(x);
+	/** a read the load can compute once: a constant line of its own, or the module's (or a pure
+	*  global) name that nothing in the load shadows */
+	const known = (r) => constant.has(r) || (module_names.has(r) || PURE_GLOBALS.has(r)) && !local.has(r);
+	let constant = /* @__PURE__ */ new Set();
+	let out = [];
+	/** every line (0-based) of the constant statements, continuation lines included */
+	let stmt_lines = /* @__PURE__ */ new Set();
+	for (let grew = true; grew;) {
+		grew = false;
+		constant = /* @__PURE__ */ new Set();
+		out = [];
+		stmt_lines = /* @__PURE__ */ new Set();
+		let depth = 0;
+		for (let i = body0 + 1; i < body1; i++) {
+			const t = T[i];
+			const top = depth === 0;
+			for (const x of t) depth += x === "{" || x === "(" || x === "[" ? 1 : x === "}" || x === ")" || x === "]" ? -1 : 0;
+			if (top && t[0] === "return" && t[1] === "{") {
+				let d = 0;
+				for (let j = i + 1; j < body1; j++) {
+					const e = T[j];
+					const at_top = d === 0;
+					for (const x of e) d += x === "{" || x === "(" || x === "[" ? 1 : x === ")" || x === "]" || x === "}" ? -1 : 0;
+					if (d < 0) break;
+					if (!at_top || d !== 0 || !is_id_start((e[0] ?? "").charCodeAt(0)) || e[1] !== ":" || e.includes("await")) continue;
+					const text = lines[j].slice(lines[j].indexOf(":") + 1);
+					const rw = line_rw(text);
+					if (!rw.reads.length || !rw.reads.every(known)) continue;
+					const et = tokens(text);
+					const calls = rw.reads.filter((r) => module_names.has(r) && et.some((x, k) => x === r && et[k + 1] === "("));
+					if (calls.length) {
+						if (!spans) out.push({
+							line: j + 1,
+							names: [e[0]],
+							calls
+						});
+						stmt_lines.add(j);
+					}
+				}
+				break;
+			}
+			if (!top || t[0] !== "const") continue;
+			let open = 0;
+			for (const x of t) open += x === "(" || x === "[" || x === "{" ? 1 : x === ")" || x === "]" || x === "}" ? -1 : 0;
+			let text = lines[i];
+			const all = [...t];
+			for (let j = i + 1; open > 0 && j < body1; j++) {
+				text += "\n" + lines[j];
+				for (const x of T[j]) {
+					all.push(x);
+					open += x === "(" || x === "[" || x === "{" ? 1 : x === ")" || x === "]" || x === "}" ? -1 : 0;
+				}
+			}
+			if (open !== 0 || all.includes("await")) continue;
+			const rw = line_rw(text.split("\n").join(" "));
+			if (!rw.declared.length || !rw.reads.length) continue;
+			if (!rw.reads.every(known)) continue;
+			if (rw.declared.some((n) => changed.has(n))) {
+				for (const r of rw.reads) if (constant.has(r) && !changed.has(r)) {
+					changed.add(r);
+					grew = true;
+				}
+				continue;
+			}
+			const calls = rw.reads.filter((r) => module_names.has(r) && all.some((x, k) => x === r && all[k + 1] === "("));
+			for (const n of rw.declared) constant.add(n);
+			const end = i + text.split("\n").length;
+			if (all.includes("(")) {
+				out.push({
+					line: i + 1,
+					names: rw.declared,
+					calls,
+					...spans ? {
+						end,
+						work: true
+					} : {}
+				});
+				for (let j = i; j < end; j++) stmt_lines.add(j);
+			} else if (spans) out.push({
+				line: i + 1,
+				end,
+				names: rw.declared,
+				calls: [],
+				work: false
+			});
+		}
+	}
+	const mine = stmt_lines;
+	for (const o of out) o.calls = o.calls.filter((c) => !T.some((t, i) => i > body0 && i < body1 && !mine.has(i) && t.includes(c)));
+	return out;
+}
+/**
+* THE MOVE, CHECKED: which of the load's constant statements go to the file's top level (the costly
+* ones and what they read, nothing else) and the line they go above (the load's `export`, 1-based).
+* Null when moving them could change what the file does:
+* - the file declares a top-level `const` / `let` / `var` / `class` AFTER the load. A moved call can
+*   run a helper that reads it before it is set (its temporal dead zone), so no line is safe to move
+*   above it;
+* - a moved name is already a top-level name of the file (an import, a const, a function).
+*/
+function hoist_plan(source) {
+	const all = constant_work(source, true);
+	if (!all.some((x) => x.work)) return null;
+	const lines = source.split("\n");
+	const T = lines.map((l) => tokens(l));
+	const span = load_span(T);
+	if (!span) return null;
+	const by_name = /* @__PURE__ */ new Map();
+	for (const x of all) for (const n of x.names) by_name.set(n, x);
+	const keep = /* @__PURE__ */ new Set();
+	const visit = (x) => {
+		if (keep.has(x)) return;
+		keep.add(x);
+		for (const r of line_rw(lines.slice(x.line - 1, x.end).join(" ")).reads) {
+			const y = by_name.get(r);
+			if (y) visit(y);
+		}
+	};
+	for (const x of all) if (x.work) visit(x);
+	const stmts = all.filter((x) => keep.has(x)).map((x) => ({
+		line: x.line,
+		end: x.end,
+		names: x.names
+	}));
+	const top = /* @__PURE__ */ new Set();
+	let late = false;
+	let depth = 0;
+	for (let i = 0; i < T.length; i++) {
+		const t = T[i];
+		const at_top = depth === 0;
+		for (const x of t) depth += x === "{" ? 1 : x === "}" ? -1 : 0;
+		if (!at_top || i >= span.head && i <= span.body1) continue;
+		if (t[0] === "import") {
+			const ids = [];
+			let j = i;
+			for (let d = 0; j < T.length; j++) {
+				for (const x of T[j]) if (x === "{") d++;
+				else if (x === "}") d--;
+				else ids.push(x);
+				if (d <= 0) break;
+			}
+			for (let k = 0; k < ids.length; k++) if (is_id_start(ids[k].charCodeAt(0)) && !NOT_A_NAME.has(ids[k]) && ids[k] !== "import" && ids[k] !== "from" && ids[k] !== "type" && ids[k] !== "as" && ids[k + 1] !== "as") top.add(ids[k]);
+			continue;
+		}
+		let k = t[0] === "export" ? 1 : 0;
+		if (t[k] === "declare") k++;
+		if (t[k] === "const" || t[k] === "let" || t[k] === "var") {
+			for (const n of line_rw(lines[i]).declared) top.add(n);
+			if (i > span.body1) late = true;
+		} else if (t[k] === "class") {
+			if (t[k + 1]) top.add(t[k + 1]);
+			if (i > span.body1) late = true;
+		} else if (t[k] === "function" || t[k] === "async" && t[k + 1] === "function") {
+			const n = t[k] === "async" ? t[k + 2] : t[k + 1];
+			if (n && n !== "*") top.add(n);
+		}
+	}
+	if (late || stmts.some((x) => x.names.some((n) => top.has(n)))) return null;
+	return {
+		above: span.head + 1,
+		stmts
+	};
+}
+/** `data` at token `k` is the page's data: bare `data.x` (the prop), or `page.data.x` / `$page.data.x`
+*  — not another object's `data` (`post.data.tags`) */
+function is_page_data(t, k) {
+	if (t[k - 1] !== ".") return true;
+	return t[k - 2] === "page" || t[k - 2] === "$page";
+}
+/** the page-data key a component's local is made from: `const products = data.catalog.…` → catalog */
+function local_key(lines, name) {
+	for (const l of lines) {
+		const t = tokens(l);
+		const d = t.findIndex((x, k) => (x === "const" || x === "let") && t[k + 1] === name);
+		if (d === -1) continue;
+		for (let j = d + 2; j < t.length; j++) if (t[j] === "data" && t[j + 1] === "." && is_id_start((t[j + 2] ?? "").charCodeAt(0)) && is_page_data(t, j)) return t[j + 2];
+		return;
+	}
+}
+/**
+* THE LOOPS IN A COMPONENT'S MARKUP: each `{#each … as …}` block, the page-data key it walks
+* (`data.results`, `page.data.results` → results), and the components rendered inside it
+* (`<ResultCard …>`, nested blocks included). What decides how many times a child renders.
+* 1-based lines.
+*/
+function each_blocks(svelte) {
+	const lines = svelte.split("\n");
+	const out = [];
+	const open = [];
+	for (let i = 0; i < lines.length; i++) {
+		const t = tokens(lines[i]);
+		for (let k = 0; k < t.length; k++) if (t[k] === "{" && t[k + 1] === "#" && t[k + 2] === "each") {
+			let key;
+			for (let j = k + 3; j < t.length && t[j] !== "as"; j++) if (t[j] === "data" && t[j + 1] === "." && is_id_start((t[j + 2] ?? "").charCodeAt(0)) && is_page_data(t, j)) key = t[j + 2];
+			if (!key && is_id_start((t[k + 3] ?? "").charCodeAt(0)) && t[k + 4] === "as") key = local_key(lines, t[k + 3]);
+			out.push({
+				line: i + 1,
+				...key ? { key } : {},
+				components: /* @__PURE__ */ new Set()
+			});
+			open.push(out.length - 1);
+		} else if (t[k] === "{" && t[k + 1] === "/" && t[k + 2] === "each") open.pop();
+		else if (t[k] === "<" && open.length && (t[k + 1] ?? "").charCodeAt(0) >= 65 && (t[k + 1] ?? "").charCodeAt(0) <= 90) for (const o of open) out[o].components.add(t[k + 1]);
+	}
+	return out.map((o) => ({
+		line: o.line,
+		...o.key ? { key: o.key } : {},
+		components: [...o.components]
+	}));
+}
+/**
+* DATA ONLY A LATE ISLAND NEEDS: in a page's markup, the page-data keys used ONLY as props of
+* islands imported to wake late (`import Reviews from './Reviews.svelte' with { wake: 'visible' }`
+* — or `idle`, `interaction`), never in the page's own markup or an eager island. The page waits
+* for that data on every request for something seen later, if at all. An island already
+* `render: 'deferred'` fetches later by itself and is not one. 1-based lines of each use.
+*/
+function late_island_keys(svelte) {
+	const lines = svelte.split("\n");
+	const late = /* @__PURE__ */ new Map();
+	for (const l of lines) {
+		const t = tokens(l);
+		if (t[0] !== "import" || !t.includes("with")) continue;
+		const name = t[1];
+		const w = t.indexOf("wake");
+		const deferred = t.includes("render");
+		const m = w !== -1 ? l.slice(l.indexOf("wake")) : "";
+		const word = [
+			"visible",
+			"idle",
+			"interaction"
+		].find((x) => m.includes(`'${x}'`) || m.includes(`"${x}"`));
+		if (name && word && !deferred) late.set(name, word);
+	}
+	if (!late.size) return [];
+	const uses = /* @__PURE__ */ new Map();
+	let tag;
+	for (let i = 0; i < lines.length; i++) {
+		const t = tokens(lines[i]);
+		for (let k = 0; k < t.length; k++) {
+			if (t[k] === "<" && is_id_start((t[k + 1] ?? "").charCodeAt(0))) tag = t[k + 1];
+			else if (t[k] === ">") tag = void 0;
+			if (t[k] === "data" && t[k + 1] === "." && is_id_start((t[k + 2] ?? "").charCodeAt(0)) && is_page_data(t, k)) {
+				const list = uses.get(t[k + 2]) ?? [];
+				list.push({
+					...tag && late.has(tag) ? { island: tag } : {},
+					line: i + 1
+				});
+				uses.set(t[k + 2], list);
+			}
+		}
+	}
+	const out = [];
+	for (const [key, list] of uses) {
+		if (!list.every((u) => u.island)) continue;
+		out.push({
+			key,
+			island: list[0].island,
+			wake: late.get(list[0].island),
+			line: list[0].line
+		});
+	}
+	return out;
+}
+/** What a `load` takes from the request: the names in its parameter list (`async ({ url, cookies })`
+*  → url, cookies). Empty when it takes nothing; null when there is no load. */
+function load_inputs(source) {
+	const lines = source.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const t = tokens(lines[i]);
+		if (t[0] !== "export" || !t.some((x, k) => x === "load" && (t[k - 1] === "const" || t[k - 1] === "function"))) continue;
+		const all = [];
+		for (let j = i; j < Math.min(lines.length, i + 20); j++) all.push(...tokens(lines[j]));
+		let k = all.indexOf("load");
+		if (all[k - 1] === "function") while (k < all.length && all[k] !== "(") k++;
+		else {
+			const arrow = all.indexOf("=>", k);
+			if (arrow === -1 || all[arrow - 1] !== ")") return arrow > 0 && is_id_start((all[arrow - 1] ?? "").charCodeAt(0)) ? ["*" + all[arrow - 1]] : [];
+			let back = 0;
+			for (k = arrow - 1; k > 0; k--) if (all[k] === ")") back++;
+			else if (all[k] === "(" && --back === 0) break;
+		}
+		let d = 0;
+		const names = [];
+		for (; k < all.length; k++) {
+			const x = all[k];
+			if (x === "(" || x === "{" || x === "[") d++;
+			else if (x === ")" || x === "}" || x === "]") {
+				if (--d === 0) break;
+			} else if (d === 1 && is_id_start(x.charCodeAt(0)) && all[k - 1] === "(") names.push("*" + x);
+			else if (d === 2 && is_id_start(x.charCodeAt(0)) && (all[k - 1] === "{" || all[k - 1] === ",")) names.push(x);
+		}
+		return names;
+	}
+	return null;
+}
+/**
+* THE CHANGE, WRITTEN: awaits in a row as one `Promise.all` — when they are plain one-line
+* statements (`const user = await get('user');`), next to each other (blank and comment lines
+* between are fine; any other statement between could feed a later call, so none is), the rewrite
+* only moves the later calls up to start with the first. The caller has already proved no call
+* reads what an earlier one produced. `lines`: the source from the first line to the last (1-based
+* `start`); `at`: the chain's lines. Undefined when the shape is anything else.
+*/
+function promise_all_rewrite(lines, start, at) {
+	if (at.length < 2) return void 0;
+	const set = new Set(at);
+	const first = Math.min(...at);
+	const last = Math.max(...at);
+	const decls = [];
+	let indent = "";
+	let kind = "const";
+	for (let n = first; n <= last; n++) {
+		const raw = lines[n - start];
+		if (raw === void 0) return void 0;
+		const l = raw.trim();
+		if (!set.has(n)) {
+			if (l === "" || l.startsWith("//")) continue;
+			return;
+		}
+		const d = await_decl(l);
+		if (!d) return void 0;
+		if (d.kind === "let") kind = "let";
+		if (n === first) indent = raw.slice(0, raw.length - raw.trimStart().length);
+		decls.push(d);
+	}
+	return {
+		before: lines.slice(first - start, last - start + 1).join("\n"),
+		after: `${indent}${kind} [${decls.map((d) => d.binding).join(", ")}] = await Promise.all([${decls.map((d) => d.expr).join(", ")}]);`
+	};
+}
+/** where a line's code ends: before a `//` or `/*` comment that is not inside a string */
+function code_end(s) {
+	for (let i = 0; i < s.length; i++) {
+		const c = s[i];
+		if (c === "\"" || c === "'" || c === "`") {
+			for (i++; i < s.length && s[i] !== c; i++) if (s[i] === "\\") i++;
+			continue;
+		}
+		if (c === "/" && (s[i + 1] === "/" || s[i + 1] === "*")) return i;
+	}
+	return s.length;
+}
+/** names that say a call CHANGES something (`db.insert`, `saveCart`): two of them started together
+*  can land in either order, so a chain with one stays in a row */
+const WRITE_VERBS = [
+	"insert",
+	"update",
+	"delete",
+	"remove",
+	"save",
+	"create",
+	"put",
+	"post",
+	"patch",
+	"write",
+	"send",
+	"set",
+	"add",
+	"upsert",
+	"increment",
+	"decrement",
+	"mark",
+	"lock",
+	"commit",
+	"publish",
+	"enqueue",
+	"push",
+	"reserve",
+	"charge"
+];
+/**
+* One statement `const <binding> = await <call>;` split into its binding and call, or undefined when
+* the line is any other shape: a type on the binding (`const a: User = …`), two names (`const a =
+* …, b = …`), a second statement or an `await` inside the call, anything done to the answer
+* (`await f() + 1`, `await f() || x`: moved into an array, the operator would apply to the promise),
+* or a call whose name says it writes.
+*/
+function await_decl(line) {
+	let body = line.slice(0, code_end(line)).trim();
+	if (body.endsWith(";")) body = body.slice(0, -1).trimEnd();
+	const kind = body.startsWith("const ") ? "const" : body.startsWith("let ") ? "let" : void 0;
+	if (!kind) return void 0;
+	let eq = -1;
+	for (let i = kind.length, d = 0; i < body.length && eq < 0; i++) {
+		const c = body[i];
+		if (c === "\"" || c === "'" || c === "`") {
+			for (i++; i < body.length && body[i] !== c; i++) if (body[i] === "\\") i++;
+		} else if (c === "(" || c === "[" || c === "{") d++;
+		else if (c === ")" || c === "]" || c === "}") d--;
+		else if (d === 0 && (c === ":" || c === "," || c === ";")) return void 0;
+		else if (d === 0 && c === "=" && body[i + 1] !== "=" && body[i + 1] !== ">") eq = i;
+	}
+	if (eq < 0) return void 0;
+	const binding = body.slice(kind.length, eq).trim();
+	const rest = body.slice(eq + 1).trim();
+	if (!binding || !rest.startsWith("await ")) return void 0;
+	const expr = rest.slice(6).trim();
+	const e = tokens(expr);
+	if (e.includes("await") || e.includes(";")) return void 0;
+	let j = e[0] === "new" ? 1 : 0;
+	if (!is_id_start((e[j] ?? "").charCodeAt(0))) return void 0;
+	const names = [e[j++]];
+	let called = false;
+	while (j < e.length) if ((e[j] === "." || e[j] === "?.") && is_id_start((e[j + 1] ?? "").charCodeAt(0))) {
+		names.push(e[j + 1]);
+		j += 2;
+		called = false;
+	} else if (e[j] === "(" || e[j] === "[") {
+		called = e[j] === "(";
+		let d = 0;
+		for (; j < e.length; j++) if (e[j] === "(" || e[j] === "[" || e[j] === "{") d++;
+		else if ((e[j] === ")" || e[j] === "]" || e[j] === "}") && --d === 0) break;
+		if (d !== 0) return void 0;
+		j++;
+	} else return void 0;
+	if (!called) return void 0;
+	const says_write = (n) => WRITE_VERBS.some((v) => {
+		if (!n.toLowerCase().startsWith(v)) return false;
+		const next = n[v.length];
+		return next === void 0 || next === "_" || next >= "A" && next <= "Z";
+	});
+	if (names.some(says_write)) return void 0;
+	if (e.includes("method") && !expr.includes("'GET'") && !expr.includes("\"GET\"")) return void 0;
+	return {
+		kind,
+		binding,
+		expr
+	};
+}
+/** the balanced `( … )` text starting at `open` (the index of `(`), and the index past its `)` */
+function paren_text(s, open) {
+	let d = 0;
+	for (let i = open; i < s.length; i++) {
+		const c = s[i];
+		if (c === "\"" || c === "'" || c === "`") {
+			const q = c;
+			for (i++; i < s.length && s[i] !== q; i++) if (s[i] === "\\") i++;
+			continue;
+		}
+		if (c === "(") d++;
+		else if (c === ")" && --d === 0) return {
+			inner: s.slice(open + 1, i),
+			end: i + 1
+		};
+	}
+}
+/**
+* THE CHANGE, WRITTEN, for a formatter built on every call: `new Intl.NumberFormat(locale, {…})` on
+* a line. Arguments that read nothing (literals only) → one formatter at the top of the file, used
+* on the line. Arguments that read variables → a cached factory at the top (one formatter per
+* locale + options, built once) called on the line in place of `new Intl.X(`. A `.localeCompare(y,
+* 'de', {…})` with literal arguments → one `Intl.Collator`'s `compare`. `ts`: the file is TypeScript
+* (the factory is typed). Undefined when the line is anything else.
+*/
+function formatter_rewrite(line, opts) {
+	const { ts, svelte = false } = opts;
+	const taken = opts.taken ?? new Set(tokens(line));
+	const made = opts.made ?? /* @__PURE__ */ new Map();
+	const edits = [];
+	const tops = [];
+	const reused = /* @__PURE__ */ new Set();
+	/** the name for one addition: the one already made for the same thing, else a fresh one no name
+	*  of the file uses (`COLLATOR`, `COLLATOR_2`); `decl` writes the addition under that name */
+	const name_for = (key, base, decl, also = () => []) => {
+		const had = made.get(key);
+		if (had) {
+			reused.add(had);
+			return had;
+		}
+		let name = base;
+		for (let n = 2; taken.has(name) || also(name).some((x) => taken.has(x)); n++) name = `${base}_${n}`;
+		taken.add(name);
+		for (const x of also(name)) taken.add(x);
+		made.set(key, name);
+		tops.push(decl(name));
+		return name;
+	};
+	for (let at = code_index(line, "new Intl."); at !== -1;) {
+		let k = at + 9;
+		while (k < line.length && is_id_part(line.charCodeAt(k))) k++;
+		const ctor = line.slice(at + 9, k);
+		const args = line[k] === "(" ? paren_text(line, k) : void 0;
+		if (!ctor || !args) return void 0;
+		let snake = "";
+		for (let i = 0; i < ctor.length; i++) {
+			const c = ctor[i];
+			snake += c >= "A" && c <= "Z" ? (i ? "_" : "") + c.toLowerCase() : c;
+		}
+		if (!line_rw(`x(${args.inner})`).reads.filter((r) => r !== "x").length) {
+			const name = name_for(`const|${ctor}|${args.inner}`, snake.toUpperCase(), (n) => `const ${n} = new Intl.${ctor}(${args.inner});`);
+			edits.push({
+				start: at,
+				end: args.end,
+				text: name
+			});
+		} else {
+			const shape = FACTORY_CTORS.get(ctor);
+			if (!shape) {
+				at = code_index(line, "new Intl.", args.end);
+				continue;
+			}
+			const types = ts ? {
+				loc: ": Intl.LocalesArgument",
+				opt: shape.required ? `: Intl.${ctor}Options` : `?: Intl.${ctor}Options`,
+				map: `<string, Intl.${ctor}>`
+			} : {
+				loc: "",
+				opt: "",
+				map: ""
+			};
+			const name = name_for(`factory|${ctor}`, snake, (n) => [
+				`const ${n}_cache = new Map${types.map}();`,
+				`function ${n}(locale${types.loc}, options${types.opt}) {`,
+				`\tconst key = \`\${String(locale)}|\${JSON.stringify(options)}\`;`,
+				`\tlet f = ${n}_cache.get(key);`,
+				`\tif (!f) ${n}_cache.set(key, (f = new Intl.${ctor}(locale, options)));`,
+				`\treturn f;`,
+				`}`
+			].join("\n"), (n) => [`${n}_cache`]);
+			edits.push({
+				start: at,
+				end: args.end,
+				text: `${name}(${args.inner})`
+			});
+		}
+		at = code_index(line, "new Intl.", args.end);
+	}
+	for (let lc = code_index(line, ".localeCompare("); lc !== -1;) {
+		const args = paren_text(line, lc + 14);
+		if (!args) return void 0;
+		const parts = split_args(args.inner);
+		const next = code_index(line, ".localeCompare(", args.end);
+		if (line[lc - 1] === "?") {
+			lc = next;
+			continue;
+		}
+		if (parts.length < 2) {
+			lc = next;
+			continue;
+		}
+		const other = parts[0];
+		const rest = parts.slice(1).join(", ");
+		if (line_rw(`x(${rest})`).reads.some((r) => r !== "x")) {
+			lc = next;
+			continue;
+		}
+		let s = lc - 1;
+		while (s >= 0) {
+			const c = line[s];
+			if (is_id_part(c.charCodeAt(0)) || c === "." || c === "?" && line[s + 1] === ".") s--;
+			else if (c === ")" || c === "]") {
+				const open = c === ")" ? "(" : "[";
+				let d = 0;
+				for (; s >= 0; s--) if (line[s] === c) d++;
+				else if (line[s] === open && --d === 0) break;
+				s--;
+			} else break;
+		}
+		const recv = line.slice(s + 1, lc);
+		if (!recv || !is_id_start(recv.charCodeAt(0)) || edits.some((e) => e.start < args.end && s + 1 < e.end)) {
+			lc = next;
+			continue;
+		}
+		const name = name_for(`collator|${rest}`, "COLLATOR", (n) => `const ${n} = new Intl.Collator(${rest});`);
+		edits.push({
+			start: s + 1,
+			end: args.end,
+			text: `${name}.compare(${recv}, ${other})`
+		});
+		lc = next;
+	}
+	if (!edits.length) return void 0;
+	edits.sort((a, b) => a.start - b.start);
+	let changed = "";
+	let from = 0;
+	for (const e of edits) {
+		changed += line.slice(from, e.start) + e.text;
+		from = e.end;
+	}
+	changed += line.slice(from);
+	const where = svelte ? "in `<script module>` (built once, not per render)" : "at the top of the file (built once)";
+	return {
+		before: line,
+		after: `${[...tops.length ? [`// ${where}:`, ...tops] : [], ...reused.size ? [`// uses ${[...reused].join(", ")}, added by the change above`] : []].join("\n")}\n// the line:\n${changed}`
+	};
+}
+/** Intl constructors taken as `(locales, options)` — what one cached factory can build — and
+*  whether their options are required */
+const FACTORY_CTORS = /* @__PURE__ */ new Map([
+	["NumberFormat", { required: false }],
+	["DateTimeFormat", { required: false }],
+	["RelativeTimeFormat", { required: false }],
+	["PluralRules", { required: false }],
+	["Collator", { required: false }],
+	["ListFormat", { required: false }],
+	["Segmenter", { required: false }],
+	["DisplayNames", { required: true }]
+]);
+/** the index of `needle` in a line's code, at or after `from`: not inside a string, not in a
+*  comment. -1 when none. */
+function code_index(line, needle, from = 0) {
+	const end = code_end(line);
+	for (let i = from; i < end; i++) {
+		const c = line[i];
+		if (c === "\"" || c === "'" || c === "`") {
+			for (i++; i < end && line[i] !== c; i++) if (line[i] === "\\") i++;
+			continue;
+		}
+		if (line.startsWith(needle, i)) return i;
+	}
+	return -1;
+}
+/** a call's argument text split at its top-level commas (not one inside a call, an object or a string) */
+function split_args(inner) {
+	const out = [];
+	let d = 0;
+	let from = 0;
+	for (let i = 0; i < inner.length; i++) {
+		const c = inner[i];
+		if (c === "\"" || c === "'" || c === "`") {
+			for (i++; i < inner.length && inner[i] !== c; i++) if (inner[i] === "\\") i++;
+		} else if (c === "(" || c === "[" || c === "{") d++;
+		else if (c === ")" || c === "]" || c === "}") d--;
+		else if (c === "," && d === 0) {
+			out.push(inner.slice(from, i).trim());
+			from = i + 1;
+		}
+	}
+	const last = inner.slice(from).trim();
+	if (last) out.push(last);
+	return out;
+}
+/** The functions a set of lines names — called (`newestReview(x)`) or handed over (`.sort(byName)`):
+*  every bare identifier on them (not a property, not a keyword). What a CPU row by that name, run
+*  from a helper file with no line of the load on its samples, was working for. */
+function names_on(source, lines) {
+	const all = source.split("\n");
+	const out = /* @__PURE__ */ new Set();
+	for (const l of lines) {
+		const t = tokens(all[l - 1] ?? "");
+		for (let k = 0; k < t.length; k++) if (is_id_start(t[k].charCodeAt(0)) && !NOT_A_NAME.has(t[k]) && t[k - 1] !== "." && t[k - 1] !== "?.") out.add(t[k]);
+	}
+	return [...out];
+}
+export { REGEXP_FRAME, backtracks, calls_name, constant_work, each_blocks, formatter_rewrite, function_body, handle_parts, hoist_plan, import_aliases, key_sources, late_island_keys, line_rw, load_inputs, load_span, names_on, needs_previous, parent_use, promise_all_rewrite, regex_literals, tokens, wrapper_aliases };