@ogygia/core 0.0.0 → 0.11.1

package/dist/server/reversible.js

@@ -0,0 +1,994 @@
+import { escape_amp_quot } from "../escape.js";
+// src/server/reversible.ts
+/**
+* REVERSIBLE TRANSFORMS — an app's server transform (a web-component server render, say) may reshape
+* the markup ogygia hands it, Svelte-owned markup included, and ogygia puts back what hydration needs.
+*
+* The one rule this rests on, vendor-neutral: **a custom element's server render may move its light
+* DOM children** (a scoped render emulates slots by moving them into its rendered tree). So:
+*
+*   1. MARK, before the transform: every custom element gets an id (`og-h="K"` when ogygia will restore
+*      it — in Svelte-owned markup, above Svelte-owned markup, or anywhere in a hole / lake answer;
+*      `og-u="K"` otherwise), and each of its children a tag (`og-c="K.i"` on an element, a
+*      `<!--og-c K.i t|c-->` comment before a text or comment node). Text a trimmer could change,
+*      deeper inside a restored host's children, gets `<!--og-t K.n-->`.
+*   2. The app's transform runs. On an `og-h` host it renders the plan: its slot positions as real
+*      `<slot>` wrappers, `og-shadow="key …"` (the sheets for the host's shadow root), `og-keep="attr …"`.
+*   3. SETTLE, after it: hosts without a plan (no `og-shadow`) lose every mark and are left as the
+*      transform wrote them; a planned host keeps its marks plus what the restorer needs to put the
+*      children back exactly (`og-r`: the attributes to reset; the original text of a trimmed or
+*      dropped text node). Start tags the HTML parser would restructure (an `<a>` in an `<a>`, a block
+*      in a `<p>`, …) where the render introduced the tag or the element it would close become
+*      `<og-as tag="…">` stand-ins. `data-og-head` assets move into `<head>` (a document), deduped.
+*
+* The browser half (runtime/restore.ts) attaches each planned host's shadow root, moves the rendered
+* tree into it, and puts Svelte's children back — before anything snapshots or hydrates.
+*
+* Pure string work over one tokenizer pass each (indexOf-driven, no regex, no DOM): it runs on every
+* response of an app that configures a transform.
+*/
+const RAW = /* @__PURE__ */ new Set([
+	"script",
+	"style",
+	"textarea",
+	"title",
+	"xmp",
+	"iframe",
+	"noembed",
+	"noframes"
+]);
+const VOID = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"source",
+	"track",
+	"wbr",
+	"param",
+	"keygen",
+	"frame"
+]);
+function is_space(c) {
+	return c === 32 || c === 9 || c === 10 || c === 12 || c === 13;
+}
+function is_alpha(c) {
+	return c >= 65 && c <= 90 || c >= 97 && c <= 122;
+}
+/** Index of the `>` ending the tag at `open`, respecting quoted values; `html.length` if none. */
+function tag_end(html, open) {
+	let quote = 0;
+	for (let i = open + 1; i < html.length; i++) {
+		const c = html.charCodeAt(i);
+		if (quote) {
+			if (c === quote) quote = 0;
+		} else if (c === 34 || c === 39) quote = c;
+		else if (c === 62) return i;
+	}
+	return html.length;
+}
+function read_name(html, from) {
+	let i = from;
+	while (i < html.length) {
+		const c = html.charCodeAt(i);
+		if (is_space(c) || c === 62 || c === 47) break;
+		i++;
+	}
+	return i;
+}
+/** The raw-text body end (`<` of the matching `</name`), or `html.length`. */
+function raw_end(html, from, name) {
+	let at = from;
+	for (;;) {
+		const lt = html.indexOf("</", at);
+		if (lt === -1) return html.length;
+		let ok = true;
+		for (let k = 0; k < name.length; k++) {
+			const c = html.charCodeAt(lt + 2 + k);
+			if ((c >= 65 && c <= 90 ? c + 32 : c) !== name.charCodeAt(k)) {
+				ok = false;
+				break;
+			}
+		}
+		const after = html.charCodeAt(lt + 2 + name.length);
+		if (ok && (Number.isNaN(after) || is_space(after) || after === 62 || after === 47)) return lt;
+		at = lt + 2;
+	}
+}
+/** A tag name, lower-cased only when it has an upper-case letter (the common case allocates nothing
+*  beyond the slice). */
+function tag_name(html, from, to) {
+	const name = html.slice(from, to);
+	for (let k = from; k < to; k++) {
+		const c = html.charCodeAt(k);
+		if (c >= 65 && c <= 90) return name.toLowerCase();
+	}
+	return name;
+}
+/**
+* The tokenizer: ONE token object, rewritten in place by each `next()` (a document is tens of
+* thousands of tokens; an object per token, or a generator, is garbage the collector pays for on
+* every request). Read a token's fields before the next `next()`.
+*/
+var Lexer = class {
+	t = "text";
+	name = "";
+	start = 0;
+	end = 0;
+	name_end = 0;
+	self = false;
+	#html;
+	#i = 0;
+	/** the raw-text element just opened: its body is the next token */
+	#raw = "";
+	constructor(html) {
+		this.#html = html;
+	}
+	#set(t, start, end) {
+		this.t = t;
+		this.start = start;
+		this.end = end;
+		this.#i = end;
+		return true;
+	}
+	next() {
+		const html = this.#html;
+		const n = html.length;
+		let i = this.#i;
+		if (this.#raw) {
+			const name = this.#raw;
+			this.#raw = "";
+			const re = raw_end(html, i, name);
+			if (re > i) return this.#set("raw", i, re);
+			i = this.#i = re;
+		}
+		if (i >= n) return false;
+		const lt = html.indexOf("<", i);
+		if (lt === -1) return this.#set("text", i, n);
+		const c1 = html.charCodeAt(lt + 1);
+		if (!(is_alpha(c1) || c1 === 47 && is_alpha(html.charCodeAt(lt + 2)) || c1 === 33 || c1 === 63)) {
+			let j = lt + 1;
+			for (;;) {
+				const nx = html.indexOf("<", j);
+				if (nx === -1) {
+					j = n;
+					break;
+				}
+				const d = html.charCodeAt(nx + 1);
+				if (is_alpha(d) || d === 47 && is_alpha(html.charCodeAt(nx + 2)) || d === 33 || d === 63) {
+					j = nx;
+					break;
+				}
+				j = nx + 1;
+			}
+			return this.#set("text", i, j);
+		}
+		if (lt > i) return this.#set("text", i, lt);
+		if (html.startsWith("<!--", lt)) {
+			const close = html.indexOf("-->", lt + 4);
+			return this.#set("comment", lt, close === -1 ? n : close + 3);
+		}
+		if (c1 === 33 || c1 === 63) return this.#set("other", lt, tag_end(html, lt) + 1);
+		if (c1 === 47) {
+			const ne = read_name(html, lt + 2);
+			this.name = tag_name(html, lt + 2, ne);
+			return this.#set("end", lt, tag_end(html, lt) + 1);
+		}
+		const ne = read_name(html, lt + 1);
+		const name = tag_name(html, lt + 1, ne);
+		const gt = tag_end(html, lt);
+		this.name = name;
+		this.name_end = ne;
+		this.self = html.charCodeAt(gt - 1) === 47;
+		if (RAW.has(name) && !this.self) this.#raw = name;
+		return this.#set("start", lt, gt + 1);
+	}
+};
+/** (the attributes of a tag nobody asked about: one shared empty list, never an allocation per tag) */
+const NO_ATTRS = Object.freeze([]);
+/** (nothing to remove from a tag without ogygia's marks; only a tag with marks ever adds to its set) */
+const NO_REMOVE = /* @__PURE__ */ new Set();
+function parse_attrs(html, from, to) {
+	const out = [];
+	let i = from;
+	while (i < to) {
+		let c = html.charCodeAt(i);
+		if (is_space(c) || c === 47) {
+			i++;
+			continue;
+		}
+		const ns = i;
+		while (i < to) {
+			c = html.charCodeAt(i);
+			if (is_space(c) || c === 61 || c === 62 || c === 47) break;
+			i++;
+		}
+		const name = html.slice(ns, i).toLowerCase();
+		let j = i;
+		while (j < to && is_space(html.charCodeAt(j))) j++;
+		if (html.charCodeAt(j) === 61) {
+			j++;
+			while (j < to && is_space(html.charCodeAt(j))) j++;
+			const q = html.charCodeAt(j);
+			let value;
+			if (q === 34 || q === 39) {
+				const close = html.indexOf(q === 34 ? "\"" : "'", j + 1);
+				const e = close === -1 || close > to ? to : close;
+				value = html.slice(j + 1, e);
+				j = e + 1;
+			} else {
+				const vs = j;
+				while (j < to && !is_space(html.charCodeAt(j)) && html.charCodeAt(j) !== 62) j++;
+				value = html.slice(vs, j);
+			}
+			if (name) out.push({
+				name,
+				value: decode(value),
+				start: ns,
+				end: j
+			});
+			i = j;
+		} else {
+			if (name) out.push({
+				name,
+				value: "",
+				start: ns,
+				end: i
+			});
+			if (i === ns) i++;
+		}
+	}
+	return out;
+}
+const NAMED = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'",
+	nbsp: "\xA0",
+	"#39": "'"
+};
+/** Decode character references (the common named ones and every numeric one): enough to compare two
+*  serializations of the same text or attribute value. */
+function decode(s) {
+	if (s.indexOf("&") === -1) return s;
+	let out = "";
+	let i = 0;
+	for (;;) {
+		const amp = s.indexOf("&", i);
+		if (amp === -1) return out + s.slice(i);
+		out += s.slice(i, amp);
+		const semi = s.indexOf(";", amp);
+		if (semi === -1 || semi - amp > 10) {
+			out += "&";
+			i = amp + 1;
+			continue;
+		}
+		const ref = s.slice(amp + 1, semi);
+		let ch;
+		if (ref.charCodeAt(0) === 35) {
+			const code = ref[1] === "x" || ref[1] === "X" ? parseInt(ref.slice(2), 16) : parseInt(ref.slice(1), 10);
+			if (Number.isFinite(code) && code > 0 && code <= 1114111) ch = String.fromCodePoint(code);
+		} else ch = NAMED[ref];
+		if (ch === void 0) {
+			out += "&";
+			i = amp + 1;
+		} else {
+			out += ch;
+			i = semi + 1;
+		}
+	}
+}
+const esc_attr = escape_amp_quot;
+/** JSON safe inside an HTML comment: no `--`, no `>`. */
+function comment_json(v) {
+	return replace_all(replace_all(JSON.stringify(v), "-", "\\u002d"), ">", "\\u003e");
+}
+function script_json(v) {
+	return replace_all(JSON.stringify(v), "<", "\\u003c");
+}
+/** `replaceAll` behind a native search: no copy when there is nothing to replace. */
+function replace_all(s, from, to) {
+	return s.indexOf(from) === -1 ? s : s.replaceAll(from, to);
+}
+const P_CLOSERS = /* @__PURE__ */ new Set([
+	"address",
+	"article",
+	"aside",
+	"blockquote",
+	"center",
+	"details",
+	"dialog",
+	"dir",
+	"div",
+	"dl",
+	"fieldset",
+	"figcaption",
+	"figure",
+	"footer",
+	"form",
+	"header",
+	"hgroup",
+	"main",
+	"menu",
+	"nav",
+	"ol",
+	"p",
+	"search",
+	"section",
+	"summary",
+	"ul",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"pre",
+	"listing",
+	"table",
+	"hr",
+	"xmp",
+	"li",
+	"dd",
+	"dt",
+	"plaintext"
+]);
+const HEADINGS = /* @__PURE__ */ new Set([
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6"
+]);
+const SCOPE = /* @__PURE__ */ new Set([
+	"applet",
+	"caption",
+	"html",
+	"table",
+	"td",
+	"th",
+	"marquee",
+	"object",
+	"template",
+	"foreignobject",
+	"desc"
+]);
+const TRACKED = new Map([
+	"a",
+	"nobr",
+	"button",
+	"form",
+	"li",
+	"dd",
+	"dt",
+	"p",
+	"td",
+	"th",
+	"tr"
+].map((n, i) => [n, i]));
+function push(stack, f) {
+	const slot = TRACKED.get(f.name) ?? -1;
+	(stack.slots ??= []).push(slot);
+	if (slot !== -1) (stack.open ??= Array.from({ length: TRACKED.size }, () => 0))[slot]++;
+	stack.push(f);
+}
+/** Close the elements from `k` up. */
+function cut(stack, k) {
+	const slots = stack.slots;
+	if (slots) {
+		const open = stack.open;
+		if (open) {
+			for (let j = slots.length - 1; j >= k; j--) if (slots[j] !== -1) open[slots[j]]--;
+		}
+		slots.length = k;
+	}
+	stack.length = k;
+}
+/** The index of the open `name` in scope, or -1. (A stand-in `<og-as tag="a">` is not an `<a>` to
+*  the parser: the element's own name is what counts.) */
+function in_scope(stack, name, extra) {
+	const slot = TRACKED.get(name);
+	if (slot === void 0 || !stack.open?.[slot]) return -1;
+	for (let k = stack.length - 1; k >= 0; k--) {
+		const f = stack[k];
+		if (f.name === name) return k;
+		if (SCOPE.has(f.name) || extra?.has(f.name)) return -1;
+	}
+	return -1;
+}
+const BUTTON_SCOPE = /* @__PURE__ */ new Set(["button"]);
+const LIST_SCOPE = /* @__PURE__ */ new Set(["ol", "ul"]);
+/** `implied_close`: the parser ignores this start tag (a form in a form) */
+const DROP = -2;
+/** What the parser does to the stack BEFORE inserting start tag `name`: the index of the element it
+*  would close (and everything above it), -1 for nothing, or `DROP` (it ignores the tag). A number,
+*  never an object: this runs on every start tag. */
+function implied_close(stack, name) {
+	if (name === "a" || name === "nobr" || name === "button") return in_scope(stack, name);
+	if (name === "form") return in_scope(stack, "form") === -1 ? -1 : DROP;
+	if (name === "li") {
+		const li = in_scope(stack, "li", LIST_SCOPE);
+		if (li !== -1) return li;
+	}
+	if (name === "dd" || name === "dt") {
+		const k = Math.max(in_scope(stack, "dd"), in_scope(stack, "dt"));
+		if (k !== -1) return k;
+	}
+	if (P_CLOSERS.has(name)) {
+		const p = in_scope(stack, "p", BUTTON_SCOPE);
+		if (p !== -1) return p;
+		if (HEADINGS.has(name)) {
+			const top = stack[stack.length - 1];
+			if (top && HEADINGS.has(top.name)) return stack.length - 1;
+		}
+	}
+	if (name === "option" || name === "optgroup") {
+		const top = stack[stack.length - 1];
+		if (top && top.name === "option") return stack.length - 1;
+	}
+	if (name === "td" || name === "th") {
+		const k = Math.max(in_scope(stack, "td"), in_scope(stack, "th"));
+		if (k !== -1) return k;
+	}
+	if (name === "tr") {
+		const k = in_scope(stack, "tr");
+		if (k !== -1) return k;
+	}
+	return -1;
+}
+/** An end tag: close up to the innermost element of that name (a stand-in answers to its real tag,
+*  whose end tag the settle pass rewrites). */
+function pop_to(stack, name) {
+	for (let k = stack.length - 1; k >= 0; k--) if ((stack[k].as ?? stack[k].name) === name) {
+		cut(stack, k);
+		return;
+	}
+}
+function is_custom(name, foreign) {
+	if (foreign || name.indexOf("-") === -1 || !is_alpha(name.charCodeAt(0))) return false;
+	return !name.startsWith("ogygia-") && !name.startsWith("og-");
+}
+/** Who renders a region's inside, for Svelte ownership: a hole's and a lake's are opaque to any
+*  hydration — and so is a BAKED live region's (its first HTML is one `{@html}` string to Svelte), the
+*  same set the client calls opaque (region-attrs.ts `OPAQUE_SELECTOR`). Restoring a host in there to
+*  Svelte's render undid what the server's transform wrote for no hydration to follow (a closed
+*  dropdown lost `hidden` and pushed the page down until its own runtime set it again). */
+function region_kind(attrs) {
+	if (attrs.some((a) => a.name === "endpoint")) return "hole";
+	if (attrs.some((a) => a.name === "wake" && a.value === "none" || a.name === "data-og-baked")) return "lake";
+	return "island";
+}
+/** Text the serializer could change: whitespace-only, or with leading / trailing whitespace. */
+function trimmable(s) {
+	if (!s.length) return false;
+	const a = s.charCodeAt(0);
+	const b = s.charCodeAt(s.length - 1);
+	return is_space(a) || is_space(b) || a === 160 || b === 160 || s.indexOf("&nbsp;") !== -1 || s.indexOf("&#160;") !== -1;
+}
+/** (the record of a host ogygia won't restore: shared, never written) */
+const NO_RECORD = Object.freeze({});
+const NO_CHILDREN = /* @__PURE__ */ new Map();
+const NO_TEXTS = /* @__PURE__ */ new Map();
+const attr_map = (attrs) => {
+	const m = {};
+	for (const a of attrs) m[a.name] = a.value;
+	return m;
+};
+/**
+* Which custom elements (in document order) get a plan: every one in an ANSWER — markup the runtime
+* morphs into a live page (a hole / lake answer, or a document the router fetched: `answer`) — whose
+* hosts meet live ones its own runtime already rendered, so they must arrive in the form the restorer
+* gives (Svelte's children in the light DOM), never in the transform's server form only the
+* component's first hydrate reads (that form, morphed into a live host, left the transform's tree in
+* its light DOM: a site nav collapsed to one unstyled item after an in-place navigation). In a
+* document loaded as one, every one in Svelte-owned markup, and every one with Svelte-owned markup
+* below it (a server-owned host around an island: adopting it would reach into the island). A first
+* pass, so the marking pass knows a host's plan before it reaches the host's children.
+*/
+function plan_hosts(html, kind, csr, answer) {
+	const planned = [];
+	const stack = [];
+	let in_body = kind !== "document";
+	for (const tok = new Lexer(html); tok.next();) if (tok.t === "start") {
+		const name = tok.name;
+		if (name === "body") in_body = true;
+		const close = implied_close(stack, name);
+		if (close === DROP) continue;
+		if (close !== -1) cut(stack, close);
+		const parent = stack[stack.length - 1];
+		const foreign = name === "svg" || name === "math" || !!parent?.foreign;
+		let owned = name === "body" && kind === "document" && csr || (parent ? parent.owned : false);
+		if (name === "ogygia-region") owned = region_kind(parse_attrs(html, tok.name_end, tok.end - 1)) === "island";
+		let host = -1;
+		if (in_body && is_custom(name, foreign)) {
+			host = planned.length;
+			planned.push(answer || kind !== "document" || owned);
+		}
+		if (owned && !(parent ? parent.owned : false)) {
+			for (const f of stack) if (f.host !== -1) planned[f.host] = true;
+		}
+		if (!(VOID.has(name) || tok.self && foreign)) push(stack, {
+			name,
+			host,
+			owned,
+			foreign
+		});
+	} else if (tok.t === "end") pop_to(stack, tok.name);
+	return planned;
+}
+/** Is there any custom element (in a document: after `<body`) — a hop from `<` to `<` reading only
+*  tag names, no tokenization. Most pages of most apps have none, and then there is nothing to mark. */
+function has_custom_element(html, document) {
+	let at = document ? html.indexOf("<body") : 0;
+	if (at === -1) return false;
+	for (at = html.indexOf("<", at); at !== -1; at = html.indexOf("<", at + 1)) {
+		if (!is_alpha(html.charCodeAt(at + 1))) continue;
+		const ne = read_name(html, at + 1);
+		const dash = html.indexOf("-", at + 1);
+		if (dash !== -1 && dash < ne && is_custom(tag_name(html, at + 1, ne), false)) return true;
+	}
+	return false;
+}
+/**
+* Tag `html` for the transform. `csr`: a Kit-hydrated document (its whole body is Svelte's, except
+* lakes and holes). `answer`: a document the router fetched, morphed into the live page (every host
+* planned, as in a region answer — see `plan_hosts`). Returns the tagged HTML, or `null` when there is
+* no custom element to tag (the transform then gets the HTML as is, and settle has nothing to do).
+*/
+function mark(html, kind, csr, answer = false) {
+	if (!has_custom_element(html, kind === "document")) return null;
+	const planned = plan_hosts(html, kind, csr, answer);
+	if (!planned.length) return null;
+	const out = [];
+	let pos = 0;
+	const hosts = /* @__PURE__ */ new Map();
+	let next_k = 0;
+	const stack = [];
+	let in_body = kind !== "document";
+	let last_was_pre_start = false;
+	const top = () => stack[stack.length - 1];
+	const under_now = () => top() ? top().under : -1;
+	for (const tok = new Lexer(html); tok.next();) {
+		if (tok.t === "start") {
+			const name = tok.name;
+			if (name === "body") in_body = true;
+			const close = implied_close(stack, name);
+			if (close === DROP) continue;
+			if (close !== -1) cut(stack, close);
+			const parent = top();
+			const foreign = name === "svg" || name === "math" || !!parent?.foreign;
+			const custom = in_body && is_custom(name, foreign);
+			const child_of_host = !!parent && parent.host !== -1 && in_body;
+			const recorded = custom && planned[next_k] === true || child_of_host && planned[parent.host] === true;
+			const attrs = name === "ogygia-region" || name === "template" || recorded ? parse_attrs(html, tok.name_end, tok.end - 1) : NO_ATTRS;
+			let owned = name === "body" && kind === "document" && csr || (parent ? parent.owned : false);
+			if (name === "ogygia-region") owned = region_kind(attrs) === "island";
+			let insert = "";
+			const shadow_tpl = name === "template" && attrs.some((a) => a.name === "shadowrootmode");
+			if (child_of_host && !shadow_tpl) {
+				const i = parent.next++;
+				insert += ` og-c="${parent.host}.${i}"`;
+				if (planned[parent.host]) hosts.get(parent.host).children.set(i, { attrs: attr_map(attrs) });
+			}
+			let host = -1;
+			if (custom) {
+				host = next_k++;
+				const is_planned = planned[host] ?? false;
+				hosts.set(host, {
+					planned: is_planned,
+					owned,
+					attrs: is_planned ? attr_map(attrs) : NO_RECORD,
+					children: is_planned ? /* @__PURE__ */ new Map() : NO_CHILDREN,
+					texts: is_planned ? /* @__PURE__ */ new Map() : NO_TEXTS,
+					text_next: 0,
+					inner_start: tok.end,
+					inner_end: tok.end
+				});
+				insert += is_planned ? ` og-h="${host}"` : ` og-u="${host}"`;
+			}
+			if (insert) {
+				out.push(html.slice(pos, tok.name_end), insert);
+				pos = tok.name_end;
+			}
+			if (!(VOID.has(name) || tok.self && foreign)) push(stack, {
+				name,
+				host,
+				next: 0,
+				owned,
+				under: host !== -1 && planned[host] ? host : under_now(),
+				introduced: false,
+				foreign
+			});
+			last_was_pre_start = name === "pre" || name === "listing";
+			continue;
+		}
+		if (tok.t === "end") {
+			const name = tok.name;
+			for (let k = stack.length - 1; k >= 0; k--) if (stack[k].name === name) {
+				for (let j = stack.length - 1; j >= k; j--) {
+					const f = stack[j];
+					if (f.host !== -1) hosts.get(f.host).inner_end = tok.start;
+				}
+				cut(stack, k);
+				break;
+			}
+			last_was_pre_start = false;
+			continue;
+		}
+		if (tok.t === "text" || tok.t === "comment") {
+			const parent = top();
+			if (parent && parent.host !== -1 && in_body && !hosts.get(parent.host).planned) parent.next++;
+			else if (parent && parent.host !== -1 && in_body) {
+				const i = parent.next++;
+				const rec = hosts.get(parent.host);
+				if (tok.t === "text") {
+					const raw = html.slice(tok.start, tok.end);
+					rec.children.set(i, { text: raw });
+					out.push(html.slice(pos, tok.start), `<!--og-c ${parent.host}.${i} t-->`);
+				} else {
+					rec.children.set(i, {});
+					out.push(html.slice(pos, tok.start), `<!--og-c ${parent.host}.${i} c-->`);
+				}
+				pos = tok.start;
+			} else if (tok.t === "text" && parent && under_now() !== -1 && !last_was_pre_start) {
+				const raw = html.slice(tok.start, tok.end);
+				if (trimmable(raw)) {
+					const k = under_now();
+					const rec = hosts.get(k);
+					const n = rec.text_next++;
+					rec.texts.set(n, raw);
+					out.push(html.slice(pos, tok.start), `<!--og-t ${k}.${n}-->`);
+					pos = tok.start;
+				}
+			}
+			last_was_pre_start = false;
+			continue;
+		}
+		last_was_pre_start = false;
+	}
+	if (!hosts.size) return null;
+	out.push(html.slice(pos));
+	return {
+		html: out.join(""),
+		record: {
+			kind,
+			source: html,
+			hosts
+		}
+	};
+}
+/** How the stand-ins keep their element's box before the restore swaps them back (zero specificity:
+*  the component's own class rules still win). */
+const STAND_IN_CSS = ":where(og-as){display:inline}:where(og-as[tag=address],og-as[tag=article],og-as[tag=aside],og-as[tag=blockquote],og-as[tag=center],og-as[tag=details],og-as[tag=dialog],og-as[tag=dir],og-as[tag=div],og-as[tag=dl],og-as[tag=dd],og-as[tag=dt],og-as[tag=fieldset],og-as[tag=figcaption],og-as[tag=figure],og-as[tag=footer],og-as[tag=form],og-as[tag=header],og-as[tag=hgroup],og-as[tag=main],og-as[tag=menu],og-as[tag=nav],og-as[tag=ol],og-as[tag=p],og-as[tag=search],og-as[tag=section],og-as[tag=summary],og-as[tag=ul],og-as[tag=h1],og-as[tag=h2],og-as[tag=h3],og-as[tag=h4],og-as[tag=h5],og-as[tag=h6],og-as[tag=pre],og-as[tag=listing],og-as[tag=hr],og-as[tag=xmp]){display:block}:where(og-as[tag=li]){display:list-item}:where(og-as[tag=table]){display:table}:where(og-as[tag=button]){display:inline-block}";
+/** The attributes a restore resets: `name → Svelte's value`, or `null` to remove. */
+function attr_diff(now, was, keep) {
+	let diff = null;
+	const seen = /* @__PURE__ */ new Set();
+	for (const a of now) {
+		if (a.name.startsWith("og-")) continue;
+		seen.add(a.name);
+		if (a.name in was) {
+			if (was[a.name] !== a.value) (diff ??= {})[a.name] = was[a.name];
+		} else if (!keep.has(a.name)) (diff ??= {})[a.name] = null;
+	}
+	for (const name in was) if (!seen.has(name) && !name.startsWith("og-")) (diff ??= {})[name] = was[name];
+	return diff;
+}
+/** Rewrite a start tag: drop the attributes named in `drop`, append `add`, rename to `rename`. */
+function rewrite_start(html, tok, attrs, drop, add, rename) {
+	let s = "<" + (rename ?? html.slice(tok.start + 1, tok.name_end));
+	let at = tok.name_end;
+	for (const a of attrs) {
+		if (!drop.has(a.name)) continue;
+		let from = a.start;
+		while (from > at && is_space(html.charCodeAt(from - 1))) from--;
+		s += html.slice(at, from);
+		at = a.end;
+	}
+	const close = html.charCodeAt(tok.end - 2) === 47 ? tok.end - 2 : tok.end - 1;
+	return s + html.slice(at, close) + add + html.slice(close, tok.end);
+}
+function settle(html, record, opts = {}) {
+	const plan = /* @__PURE__ */ new Set();
+	for (let at = html.indexOf(" og-shadow="); at !== -1; at = html.indexOf(" og-shadow=", at + 11)) {
+		const lt = html.lastIndexOf("<", at);
+		if (lt === -1) continue;
+		const gt = tag_end(html, lt);
+		if (gt < at) continue;
+		const h = parse_attrs(html, read_name(html, lt + 1), gt).find((a) => a.name === "og-h");
+		if (h) plan.add(Number(h.value));
+	}
+	/** Does the tag at `[from, to)` hold `needle`? A forward-only cursor: tags come in document order,
+	*  so each occurrence is searched for once (a search from every tag is quadratic in the gaps). */
+	const within = (needle) => {
+		let at = html.indexOf(needle);
+		return (from, to) => {
+			if (at !== -1 && at < from) at = html.indexOf(needle, from);
+			return at !== -1 && at < to;
+		};
+	};
+	const og_in = within(" og-");
+	const head_in = within("data-og-head");
+	const out = [];
+	let pos = 0;
+	const stack = [];
+	const head = [];
+	const head_keys = /* @__PURE__ */ new Set();
+	let head_cut = null;
+	let stand_ins = 0;
+	let pending_text = null;
+	const doc = record.kind === "document";
+	/** Close a pending text mark: `text` is the text that follows it in the output (or null: none). */
+	const finish_text = (text) => {
+		const p = pending_text;
+		pending_text = null;
+		const rec = record.hosts.get(p.k);
+		const was = p.og === "c" ? rec?.children.get(p.i)?.text : rec?.texts.get(p.i);
+		if (was === void 0) {
+			out[p.comment_at] = "";
+			return;
+		}
+		if (!plan.has(p.k)) {
+			out[p.comment_at] = "";
+			if (text === null || decode(text) !== decode(was)) for (let s = stack.length - 1; s >= 0; s--) {
+				const a = stack[s].host;
+				if (a === -1 || !plan.has(a)) continue;
+				const ra = record.hosts.get(a);
+				if (ra) out[p.comment_at] = `<!--og-t ${a}.${ra.text_next++} ${comment_json(decode(was))}-->`;
+				break;
+			}
+			return;
+		}
+		if (p.og === "t") {
+			out[p.comment_at] = text !== null && decode(text) === decode(was) ? "" : `<!--og-t ${p.k}.${p.i} ${comment_json(decode(was))}-->`;
+			return;
+		}
+		out[p.comment_at] = text !== null && decode(text) === decode(was) ? `<!--og-c ${p.k}.${p.i} t-->` : `<!--og-c ${p.k}.${p.i} t ${comment_json(decode(was))}-->`;
+	};
+	for (const tok = new Lexer(html); tok.next();) {
+		if (head_cut) {
+			if (tok.t === "end" && tok.name === head_cut.name && --head_cut.depth === 0) {
+				const asset = html.slice(head_cut.start, tok.end);
+				pos = tok.end;
+				if (!head_keys.has(head_cut.key)) {
+					head_keys.add(head_cut.key);
+					head.push(asset);
+				}
+				head_cut = null;
+			} else if (tok.t === "start" && tok.name === head_cut.name) head_cut.depth++;
+			continue;
+		}
+		if (pending_text && tok.t !== "text") finish_text(null);
+		if (tok.t === "text") {
+			if (pending_text) {
+				out.push(html.slice(pos, tok.start));
+				pos = tok.start;
+				finish_text(html.slice(tok.start, tok.end));
+			}
+			continue;
+		}
+		if (tok.t === "comment") {
+			const body = html.slice(tok.start + 4, tok.end - 3);
+			const is_c = body.startsWith("og-c ");
+			const is_t = body.startsWith("og-t ");
+			if (!is_c && !is_t) continue;
+			const sp = body.indexOf(" ", 5);
+			const id = body.slice(5, sp === -1 ? body.length : sp);
+			const dot = id.indexOf(".");
+			const k = Number(id.slice(0, dot));
+			const i = Number(id.slice(dot + 1));
+			out.push(html.slice(pos, tok.start));
+			pos = tok.end;
+			if (is_c && body.endsWith(" c")) {
+				out.push(plan.has(k) ? html.slice(tok.start, tok.end) : "");
+				continue;
+			}
+			out.push("");
+			pending_text = {
+				k,
+				i,
+				comment_at: out.length - 1,
+				og: is_c ? "c" : "t"
+			};
+			continue;
+		}
+		if (tok.t === "start") {
+			const name = tok.name;
+			const implied = implied_close(stack, name);
+			const drop = implied === DROP;
+			const close = drop ? -1 : implied;
+			const parent = stack[stack.length - 1];
+			const has_og = og_in(tok.start, tok.end);
+			const head_attr = head_in(tok.start, tok.end);
+			const attrs = has_og || head_attr || close !== -1 ? parse_attrs(html, tok.name_end, tok.end - 1) : NO_ATTRS;
+			if (doc && head_attr && !has_og) {
+				const key = attrs.find((a) => a.name === "data-og-head")?.value;
+				if (key !== void 0 && (name === "style" || name === "link" || name === "template")) {
+					out.push(html.slice(pos, tok.start));
+					pos = tok.start;
+					if (name === "link" || tok.self) {
+						pos = tok.end;
+						if (!head_keys.has(key)) {
+							head_keys.add(key);
+							head.push(html.slice(tok.start, tok.end));
+						}
+					} else head_cut = {
+						start: tok.start,
+						name,
+						depth: 1,
+						key
+					};
+					continue;
+				}
+			}
+			const og_c = has_og ? attrs.find((a) => a.name === "og-c") : void 0;
+			const og_h = has_og ? attrs.find((a) => a.name === "og-h" || a.name === "og-u") : void 0;
+			const foreign = name === "svg" || name === "math" || !!parent?.foreign;
+			const is_host = !!og_h;
+			const introduced = og_c ? false : parent ? parent.host !== -1 ? true : parent.introduced : false;
+			let stand_in = false;
+			if ((close !== -1 || drop) && !foreign) {
+				const trigger = close !== -1 ? stack[close] : void 0;
+				if (introduced || trigger?.introduced || drop && introduced) stand_in = true;
+			}
+			if (!stand_in) {
+				if (close !== -1) cut(stack, close);
+				if (drop) continue;
+			}
+			const remove = has_og ? /* @__PURE__ */ new Set() : NO_REMOVE;
+			let add = "";
+			let reset = null;
+			let planned_host = false;
+			if (og_h) {
+				const k = Number(og_h.value);
+				if (og_h.name === "og-u" || !plan.has(k)) {
+					remove.add(og_h.name);
+					remove.add("og-shadow");
+					remove.add("og-keep");
+				} else {
+					planned_host = true;
+					const keep = new Set((attrs.find((a) => a.name === "og-keep")?.value ?? "").split(" ").filter(Boolean));
+					reset = attr_diff(attrs, record.hosts.get(k)?.attrs ?? {}, keep);
+				}
+			}
+			if (og_c) {
+				const dot = og_c.value.indexOf(".");
+				const k = Number(og_c.value.slice(0, dot));
+				if (!plan.has(k)) remove.add("og-c");
+				else if (!planned_host && og_h?.name !== "og-u") reset = attr_diff(attrs, record.hosts.get(k)?.children.get(Number(og_c.value.slice(dot + 1)))?.attrs ?? {}, /* @__PURE__ */ new Set());
+			}
+			if (reset) add += ` og-r="${esc_attr(JSON.stringify(reset))}"`;
+			if (stand_in) {
+				add += ` tag="${name}"`;
+				stand_ins++;
+			}
+			if (remove.size || add || stand_in) {
+				out.push(html.slice(pos, tok.start), rewrite_start(html, tok, attrs, remove, add, stand_in ? "og-as" : void 0));
+				pos = tok.end;
+			}
+			if (!(VOID.has(name) || tok.self && foreign)) push(stack, {
+				name: stand_in ? "og-as" : name,
+				as: stand_in ? name : void 0,
+				host: is_host ? Number(og_h.value) : -1,
+				next: 0,
+				owned: false,
+				under: -1,
+				introduced,
+				foreign
+			});
+			continue;
+		}
+		if (tok.t === "end") {
+			const name = tok.name;
+			for (let k = stack.length - 1; k >= 0; k--) {
+				const f = stack[k];
+				if ((f.as ?? f.name) === name) {
+					if (f.as) {
+						out.push(html.slice(pos, tok.start), "</og-as>");
+						pos = tok.end;
+					}
+					cut(stack, k);
+					break;
+				}
+			}
+			continue;
+		}
+	}
+	if (pending_text) finish_text(null);
+	out.push(html.slice(pos));
+	let check;
+	if (opts.dev) for (const k of plan) {
+		const rec = record.hosts.get(k);
+		if (rec && rec.planned) (check ??= {})[k] = record.source.slice(rec.inner_start, rec.inner_end);
+	}
+	return {
+		html: out.join(""),
+		planned: plan.size,
+		stand_ins,
+		head,
+		...check ? { check } : {}
+	};
+}
+/** The dev check's payload: each planned Svelte-owned host's original children, by its id. */
+function check_script(check) {
+	return `<script type="application/ogygia-restore-check">${script_json(check)}<\/script>`;
+}
+/** The host id right after `at` (digits), and where they end. */
+function read_id(s, at) {
+	let n = 0;
+	let j = at;
+	while (j < s.length && s.charCodeAt(j) >= 48 && s.charCodeAt(j) <= 57) n = n * 10 + (s.charCodeAt(j++) - 48);
+	return j === at ? null : {
+		id: n,
+		end: j
+	};
+}
+/** Rewrite every host id in ogygia's marks through `map` (ids it lacks stay). */
+function remap(html, map) {
+	let out = "";
+	let pos = 0;
+	for (let a = html.indexOf("og-"); a !== -1; a = html.indexOf("og-", a + 3)) {
+		const c = html.charCodeAt(a + 3);
+		let id_at = -1;
+		if ((c === 104 || c === 117 || c === 99) && html.charCodeAt(a + 4) === 61 && html.charCodeAt(a + 5) === 34) id_at = a + 6;
+		else if ((c === 99 || c === 116) && html.charCodeAt(a + 4) === 32 && html.startsWith("<!--", a - 4)) id_at = a + 5;
+		if (id_at === -1) continue;
+		const r = read_id(html, id_at);
+		if (!r) continue;
+		const to = map(r.id);
+		if (to === void 0 || to === r.id) continue;
+		out += html.slice(pos, id_at) + to;
+		pos = r.end;
+		a = r.end - 3;
+	}
+	return pos === 0 ? html : out + html.slice(pos);
+}
+/**
+* STABLE MARKS FOR A CACHING TRANSFORM. ogygia numbers hosts across the whole document, so the same
+* block carries other ids on another page, and a render cache keyed on its markup never hits.
+* `localizeMarks(block)` renumbers the block's marks from 0 (in order of appearance): cache on the
+* result, then `back(rendered)` puts the document's ids back on whatever the render returned.
+*
+* ```ts
+* const local = localizeMarks(block);
+* const rendered = cache.get(local.html) ?? cache.set(local.html, await render(local.html));
+* return local.back(rendered);
+* ```
+*/
+function localizeMarks(html) {
+	const to_local = /* @__PURE__ */ new Map();
+	const local = remap(html, (id) => {
+		let l = to_local.get(id);
+		if (l === void 0) to_local.set(id, l = to_local.size);
+		return l;
+	});
+	const to_doc = new Map([...to_local].map(([d, l]) => [l, d]));
+	return {
+		html: local,
+		back: (rendered) => remap(rendered, (id) => to_doc.get(id))
+	};
+}
+/**
+* The whole server round trip for one piece of markup: mark → the app's transform → settle. Kit-free
+* (exported from `ogygia/markup` for tests that harvest markup and run a transform over it).
+*/
+async function transformMarkup(html, transform, opts = {}) {
+	const marked = mark(html, opts.kind ?? "region", !!opts.csr);
+	if (!marked) return {
+		html: await transform(html),
+		planned: 0,
+		stand_ins: 0,
+		head: []
+	};
+	return settle(await transform(marked.html), marked.record, { dev: opts.dev });
+}
+export { STAND_IN_CSS, check_script, decode, localizeMarks, mark, settle, transformMarkup };