bosia 1.1.6 → 1.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bosapi and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -194,4 +194,4 @@ my-app/
 
 ## License
 
-MIT
+[MIT](https://github.com/bosapi/bosia/blob/main/LICENSE) © 2026 Bosapi and contributors. See [AUTHORS](https://github.com/bosapi/bosia/blob/main/AUTHORS).

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "bosia",
-	"version": "1.1.6",
+	"version": "1.2.1",
 	"type": "module",
 	"engines": {
 		"bun": ">=1.4"

package/src/ambient.d.ts

@@ -15,6 +15,9 @@ declare module "bosia:routes" {
 		prerender: boolean;
 	}>;
 
+	/** What client navigation titles a page that sets no title of its own. */
+	export const defaultTitle: string;
+
 	export const serverRoutes: Array<{
 		pattern: string;
 		id: string;

package/src/cli/sync.ts

@@ -1,5 +1,7 @@
 import { scanRoutes, RouteConflictError } from "../core/scanner.ts";
 import { generateRoutesFile } from "../core/routeFile.ts";
+import { clientDefaultTitle, loadAppHtmlTemplate } from "../core/appHtml.ts";
+import { DEFAULT_TITLE } from "../core/headScan.ts";
 import { generateRouteTypes, ensureRootDirs } from "../core/routeTypes.ts";
 import { loadEnv, classifyEnvVars } from "../core/env.ts";
 import { generateEnvModules } from "../core/envCodegen.ts";
@@ -16,7 +18,7 @@ export async function runSync() {
 		console.error(`❌ ${err.message}`);
 		process.exit(1);
 	}
-	generateRoutesFile(manifest);
+	generateRoutesFile(manifest, syncDefaultTitle());
 	generateRouteTypes(manifest);
 	ensureRootDirs();
 	generateEnvModules(classifiedEnv);
@@ -32,3 +34,14 @@ export async function runSync() {
 		process.exit(1);
 	}
 }
+
+/** app.html's title, as build passes it. A missing or broken app.html is the
+ *  build's error to report; sync still writes the routes. */
+function syncDefaultTitle(): string {
+	try {
+		return clientDefaultTitle(loadAppHtmlTemplate());
+	} catch (err) {
+		console.warn(`⚠️  Could not read the app.html title, using "${DEFAULT_TITLE}":`, err);
+		return DEFAULT_TITLE;
+	}
+}

package/src/core/appHtml.ts

@@ -5,6 +5,7 @@ import { OUT_DIR } from "./paths.ts";
 import { readArtifact } from "./artifacts.ts";
 import { rebaseHtmlAttrs } from "./basePath.ts";
 import { currentBase } from "./appBase.ts";
+import { DEFAULT_TITLE, hasTitle, titleText } from "./headScan.ts";
 
 // ─── Types ────────────────────────────────────────────────
 
@@ -62,6 +63,57 @@ export function loadAppHtmlTemplate(cwd: string = process.cwd()): AppHtmlSegment
 	};
 }
 
+// Comments and <script>/<style> bodies are matched only to be skipped; the
+// first real `</head …>` or, when the optional </head> is left out, `<body`
+// is where the head ends.
+const HEAD_END_RE =
+	/<!--[\s\S]*?(?:-->|$)|<(script|style)\b[\s\S]*?(?:<\/\1\s*>|$)|<\/head\s*>|<body[\s>/]/gi;
+
+/** Index in headClose (which runs on to %bosia.body%) where the head ends, or -1.
+ *  Matches case-insensitively on the original string: lowercasing a copy can
+ *  change its length (`İ`) and shift the index. */
+export function findHeadEnd(headClose: string): number {
+	for (const m of headClose.matchAll(HEAD_END_RE)) {
+		if (m[0].startsWith("<!--") || m[1]) continue;
+		return m.index;
+	}
+	return -1;
+}
+
+type HeadSplit = { before: string; after: string; hasTitle: boolean };
+
+// app.html never changes after it is parsed, so split it and check it for a
+// title once per segments object instead of on every render. Kept in memory,
+// not in dist/app-html.json, so it can't go stale against headClose.
+const headSplits = new WeakMap<AppHtmlSegments, HeadSplit>();
+
+/** headClose split at the end of the head: `before` still belongs to <head>,
+ *  `after` runs on to %bosia.body%. Also whether app.html's head sets a title. */
+export function headSplit(segments: AppHtmlSegments): HeadSplit {
+	let split = headSplits.get(segments);
+	if (!split) {
+		const { headOpen, headClose } = segments;
+		const i = findHeadEnd(headClose);
+		const before = i < 0 ? "" : headClose.slice(0, i);
+		const after = i < 0 ? headClose : headClose.slice(i);
+		split = { before, after, hasTitle: hasTitle(headOpen) || hasTitle(before) };
+		headSplits.set(segments, split);
+	}
+	return split;
+}
+
+/** The raw text of app.html's own <title>, or null when it has none. Looks in
+ *  the same places as headSplit, so it finds the title SSR keeps. */
+export function appHtmlTitle(segments: AppHtmlSegments): string | null {
+	return titleText(segments.headOpen) ?? titleText(headSplit(segments).before);
+}
+
+/** What client navigation calls a page with no title anywhere: app.html's
+ *  <title>, else "Bosia App" — as SSR does. Raw text; the browser decodes it. */
+export function clientDefaultTitle(segments: AppHtmlSegments): string {
+	return appHtmlTitle(segments) ?? DEFAULT_TITLE;
+}
+
 function replaceStaticPlaceholders(template: string): string {
 	// Replace %bosia.assets% with BOSIA_ASSETS_BASE env var
 	const assetsBase = process.env.BOSIA_ASSETS_BASE || "";

package/src/core/build.ts

@@ -27,7 +27,7 @@ import { currentBase } from "./appBase.ts";
 import { finalizeTailwindCss, TW_TEMP_BASENAME } from "./twHash.ts";
 import { loadBosiaConfig, loadPlugins } from "./config.ts";
 import type { BuildContext, RuntimeTarget } from "./types/plugin.ts";
-import { loadAppHtmlTemplate, writeAppHtmlSegments } from "./appHtml.ts";
+import { clientDefaultTitle, loadAppHtmlTemplate, writeAppHtmlSegments } from "./appHtml.ts";
 import {
 	generateArtifactsModule,
 	generateWorkersRuntime,
@@ -189,8 +189,9 @@ for (const p of userPlugins) {
 	}
 }
 
-// 2. Generate .bosia/routes.ts (single file replaces all old code generators)
-generateRoutesFile(manifest);
+// 2. Generate .bosia/routes.ts (single file replaces all old code generators).
+// The client names a page with no title after app.html, as SSR does.
+generateRoutesFile(manifest, clientDefaultTitle(appHtml));
 
 // 2b. Generate .bosia/types/src/routes/**/$types.d.ts for IDE type inference
 generateRouteTypes(manifest);

package/src/core/client/App.svelte

@@ -2,13 +2,16 @@
 	import { tick } from "svelte";
 	import { router, scrollToHash } from "./router.svelte.ts";
 	import { findMatch } from "../matcher.ts";
-	import { clientRoutes } from "bosia:routes";
+	import { clientRoutes, defaultTitle } from "bosia:routes";
 	import { consumePrefetch, prefetchCache, dataUrl, readDataResponse } from "./prefetch.ts";
 	import { appState, clearDirty } from "./appState.svelte.ts";
 	import { captureSnapshot, liveContext, shouldRerun, type CacheEntry } from "./loaderCache.ts";
 	import { pickErrorPage } from "../errorMatch.ts";
 	import { fireAfterNavigate, type Navigation } from "./navListeners.ts";
 	import { drainNavResolvers } from "./navigation.ts";
+	import { collapseTitle } from "../headScan.ts";
+	import { chainTitles, takeTitleWrite, titleNav } from "./titleMemory.svelte.ts";
+	import TitleProbe from "./TitleProbe.svelte";
 
 	let {
 		ssrMode = false,
@@ -39,6 +42,43 @@
 	let pageInstance = $state<any>(null);
 	if (!ssrMode) router.getPageSnapshot = () => pageInstance?.snapshot;
 
+	// The last title navigation (or SSR's metadata()) wrote, as document.title
+	// reads it. Same page, same title still → no component took it over, so
+	// navigation may replace it again.
+	let navTitle: string | null = null;
+
+	// Build-time titles are raw HTML text; a <textarea> decodes every entity the
+	// way the browser did on a hard load. Trusted Types block the innerHTML
+	// write, so the raw text is the fallback there.
+	const decoded = new Map<string, string>();
+	function decodeTitle(raw: string): string {
+		let text = decoded.get(raw);
+		if (text === undefined) {
+			try {
+				const t = document.createElement("textarea");
+				t.innerHTML = raw;
+				text = collapseTitle(t.value);
+			} catch {
+				text = collapseTitle(raw);
+			}
+			decoded.set(raw, text);
+		}
+		return text;
+	}
+
+	/** The title a page with none of its own shows under the first `depth`
+	 *  layouts: the deepest one's that wrote one (TitleProbe), else app.html's. */
+	function baseTitle(depth: number): string {
+		return (depth > 0 ? chainTitles[depth - 1] : null) ?? decodeTitle(defaultTitle);
+	}
+
+	/** How many leading layouts two routes share, by file path. */
+	function sharedDepth(a: string[], b: string[]): number {
+		let s = 0;
+		while (s < a.length && s < b.length && a[s] === b[s]) s++;
+		return s;
+	}
+
 	// Call the landed-on page's snapshot.restore() once it's mounted (post-tick).
 	function settleSnapshot() {
 		const snap = router.pendingSnapshot;
@@ -104,6 +144,15 @@
 		settleSnapshot();
 	}
 
+	// Each flush a navigation starts begins here, before any head effect: what
+	// was written since — navigation's own title, an afterNavigate listener's,
+	// the last page's — is no layout's, so the probes must not take it.
+	$effect.pre(() => {
+		if (ssrMode) return;
+		titleNav.seq;
+		takeTitleWrite();
+	});
+
 	$effect(() => {
 		if (ssrMode) return;
 
@@ -124,6 +173,11 @@
 		firstNav = false;
 		if (isFirst) {
 			currentLayoutPaths = (match.route as any).layoutPaths ?? [];
+			// The probes ran during hydration, before this effect. A title other than
+			// metadata()'s or the layouts' was a component's, so navigation keeps it.
+			const ssrTitle: string | undefined = (window as any).__BOSIA_TITLE__;
+			const base = baseTitle(currentLayoutPaths.length);
+			navTitle = ssrTitle ? collapseTitle(ssrTitle) : document.title === base ? base : null;
 			lastSettledPath = pathname;
 			lastNavKey = navKey;
 			lastTick = currentTick;
@@ -162,13 +216,7 @@
 		const destLayoutPaths = ((match.route as any).layoutPaths as string[]) ?? [];
 		const loadingImport = (match.route as any).loading as (() => Promise<any>) | null;
 		if (loadingImport && pathname !== lastSettledPath) {
-			let s = 0;
-			while (
-				s < currentLayoutPaths.length &&
-				s < destLayoutPaths.length &&
-				currentLayoutPaths[s] === destLayoutPaths[s]
-			)
-				s++;
+			const s = sharedDepth(currentLayoutPaths, destLayoutPaths);
 			loadingImport().then((m) => {
 				if (cancelled) return; // superseded nav
 				loadingDepth = s;
@@ -259,9 +307,11 @@
 			// Tear down the loading skeleton and record identity for the next nav.
 			// Superseded navs have cancelled === true and never reach here, so they
 			// can't clobber a newer nav's loader.
+			// The skeleton and the error page render in their own {#if} branch, so
+			// leaving either remounts the page. Read before both are cleared below.
+			const pageShown = !showLoading && !appState.errorComponent;
 			showLoading = false;
 			LoadingComponent = null;
-			currentLayoutPaths = destLayoutPaths;
 			lastSettledPath = pathname;
 			lastNavKey = navKey;
 			navDoneTimer = setTimeout(() => {
@@ -301,6 +351,8 @@
 					]);
 					if (cancelled) return;
 					layoutComponents = layoutModsForError.map((m: any) => m.default);
+					currentLayoutPaths = destLayoutPaths.slice(0, K);
+					titleNav.seq++; // the error branch remounts the layouts
 					const newLayoutData: Record<string, any>[] = [];
 					for (let i = 0; i < K; i++) newLayoutData.push({});
 					appState.layoutData = newLayoutData;
@@ -316,6 +368,11 @@
 				}
 				return;
 			}
+			// Layout paths are recorded only once they render: a redirect above
+			// leaves the mounted ones in place.
+			const shared = sharedDepth(currentLayoutPaths, destLayoutPaths);
+			currentLayoutPaths = destLayoutPaths;
+			const pageChanged = !pageShown || PageComponent !== pageMod.default;
 			PageComponent = pageMod.default;
 			layoutComponents = layoutMods.map((m: any) => m.default);
 
@@ -408,9 +465,19 @@
 			if (result || !match.route.hasServerData) {
 				const md = result?.metadata;
 				document.querySelectorAll("[data-bosia-meta]").forEach((el) => el.remove());
-				// A page that declares no title keeps the previous one rather than flashing
-				// the "Bosia App" fallback. Give metadata() a title if that matters.
-				if (md?.title) document.title = md.title;
+				// With no metadata() title, a page gets the one a hard load would give
+				// it: the layouts' (baseTitle), else app.html's <title>, else "Bosia
+				// App". A layout that stays mounted never writes its title again, so it
+				// is put back here. Set before Svelte flushes, so a freshly mounted
+				// <svelte:head><title> still wins. On the same page (invalidate, a form
+				// action, ?page=2) it stays once a component like <Seo> took it over.
+				if (md?.title) {
+					document.title = md.title;
+					navTitle = document.title;
+				} else if (pageChanged || document.title === navTitle) {
+					document.title = baseTitle(shared);
+					navTitle = document.title;
+				}
 				if (md?.lang) document.documentElement.lang = md.lang;
 				const emit = (tag: "meta" | "link", attrs: Record<string, string | undefined>) => {
 					const el = document.createElement(tag);
@@ -424,6 +491,7 @@
 				for (const l of md?.link ?? [])
 					emit("link", { rel: l.rel, href: l.href, hreflang: l.hreflang });
 			}
+			titleNav.seq++; // the probes read again as this flushes
 
 			settle({ url, params: match.params });
 		});
@@ -480,10 +548,12 @@
 
 	{#if index < leafDepth - 1}
 		<Layout {data} {params}>
+			<TitleProbe depth={index} layout={Layout} />
 			{@render renderLayout(index + 1, leafDepth)}
 		</Layout>
 	{:else}
 		<Layout {data} {params}>
+			<TitleProbe depth={index} layout={Layout} />
 			{#if ErrorComponent}
 				<ErrorComponent {...errorProps ?? {}} {params} />
 			{:else if PageComponent}

package/src/core/client/TitleProbe.svelte

@@ -0,0 +1,15 @@
+<script lang="ts">
+	import { chainTitles, layoutTitles, takeTitleWrite, titleNav } from "./titleMemory.svelte.ts";
+
+	// Sits after layout `depth`, before what it wraps, and takes the title that
+	// layout wrote. `layout` is the layout component, the key it is remembered by.
+	let { depth, layout }: { depth: number; layout: unknown } = $props();
+
+	$effect(() => {
+		titleNav.seq; // read again on every navigation
+		const w = takeTitleWrite();
+		if (w !== null) layoutTitles.set(layout, w);
+		chainTitles[depth] =
+			layoutTitles.get(layout) ?? (depth > 0 ? (chainTitles[depth - 1] ?? null) : null);
+	});
+</script>

package/src/core/client/router.svelte.ts

@@ -90,8 +90,7 @@ export const router = new (class Router {
 	pendingScroll: { x: number; y: number } | null = null;
 	/** Set by App.svelte; returns the mounted page's `export const snapshot` (if any) at capture time. */
 	getPageSnapshot:
-		| (() => { capture: () => unknown; restore: (v: any) => void } | undefined)
-		| null = null;
+		(() => { capture: () => unknown; restore: (v: any) => void } | undefined) | null = null;
 	/** Captured snapshot for the entry a popstate/reload landed on; consumed once by App.svelte. `undefined` = nothing to restore. */
 	pendingSnapshot: unknown = undefined;
 

package/src/core/client/titleMemory.svelte.ts

@@ -0,0 +1,64 @@
+// The title each layout depth shows, read at run time. Svelte writes a
+// <svelte:head><title> only on mount or when its value changes, so a layout
+// that stays mounted through a navigation never writes it again. A
+// <TitleProbe> after each layout (App.svelte) notes the title written since
+// the probe above it — that layout's own, a <Seo> in it, a dynamic one —
+// so navigation can put it back.
+
+/** Bumped once per navigation, so every probe reads again in that flush. */
+export const titleNav = $state({ seq: 0 });
+
+/** Per layout depth: the title the layouts down to it show, or null for none. */
+export const chainTitles: (string | null)[] = [];
+
+/** Per layout component: the title it wrote last. Kept here, not in the probe,
+ *  since a layout that wraps its children in {#key} remounts the probe but
+ *  doesn't write its title again. */
+export const layoutTitles = new Map<unknown, string>();
+
+// One record per page, on window, so a second copy of this module (a duplicate
+// chunk, a dev reload) shares the patch instead of finding it taken.
+type TitleWrites = { written: string | null; gen: number; patched: boolean };
+const KEY = "__bosiaTitleWrites";
+const store: TitleWrites =
+	typeof window === "undefined"
+		? { written: null, gen: 0, patched: false }
+		: ((window as any)[KEY] ??= { written: null, gen: 0, patched: false });
+
+/** The last title written since the previous call, or null. */
+export function takeTitleWrite(): string | null {
+	const w = store.written;
+	store.written = null;
+	return w;
+}
+
+// Every write to document.title, from Svelte or anyone, passes through here.
+// The probes run in tree order, each right after its layout's head effects,
+// so the write each one takes is its layout's. A write is kept only until the
+// next microtask: Svelte flushes in one go, so a probe sees the writes of its
+// own flush, never a page's from an earlier one.
+if (typeof document !== "undefined" && !store.patched) {
+	const native = Object.getOwnPropertyDescriptor(Document.prototype, "title");
+	if (native?.get && native.set && !Object.prototype.hasOwnProperty.call(document, "title")) {
+		const { get, set } = native;
+		Object.defineProperty(document, "title", {
+			configurable: true,
+			get() {
+				return get.call(this);
+			},
+			set(v: string) {
+				set.call(this, v);
+				store.written = get.call(this);
+				const gen = ++store.gen;
+				queueMicrotask(() => {
+					if (store.gen === gen) store.written = null;
+				});
+			},
+		});
+		store.patched = true;
+	} else if (process.env.NODE_ENV !== "production") {
+		console.warn(
+			"[bosia] document.title is already overridden, so client navigation can't put a layout's title back.",
+		);
+	}
+}

package/src/core/headScan.ts

@@ -0,0 +1,132 @@
+// Finding the <title> in a chunk of head markup. Pure string code with no
+// imports, so build.ts and appHtml.ts can use it too — html.ts reads the dist
+// manifest the moment it loads, which neither of them can afford.
+
+/** The title a page gets when nothing else sets one. */
+export const DEFAULT_TITLE = "Bosia App";
+
+/** Whether a chunk of head markup already sets the document title. Matches a
+ *  <title> with attributes too. Ignores one in a comment, an attribute value, a
+ *  script or JSON-LD string, <style>, <noscript>, <template>, or an inline <svg>
+ *  (which only labels the icon). */
+export function hasTitle(html: string): boolean {
+	return titleTagEnd(html) !== -1;
+}
+
+/** The raw text of the <title> that hasTitle finds, or null when there is none.
+ *  Whitespace is collapsed and trimmed as document.title does; entities are left
+ *  for the browser to decode. An unclosed <title> runs to the end, as in a browser. */
+export function titleText(html: string): string | null {
+	const start = titleTagEnd(html);
+	if (start === -1) return null;
+	const m = /<\/title(?=[\t\n\f\r />])/i.exec(html.slice(start));
+	const raw = m ? html.slice(start, start + m.index) : html.slice(start);
+	return collapseTitle(raw);
+}
+
+/** A title as document.title reads it back: HTML whitespace runs collapsed to
+ *  one space, and trimmed. */
+export function collapseTitle(text: string): string {
+	return text.replace(/[\t\n\f\r ]+/g, " ").trim();
+}
+
+/** Index just past the `>` of the first real <title> tag, or -1. */
+function titleTagEnd(html: string): number {
+	// A single forward scan, not a regex: a lazy `<script…</script>` match retries
+	// from every unclosed `<script` and goes quadratic on hostile {@html} output.
+	// Each tag is skipped whole, quotes included, so nothing inside an attribute
+	// looks like a tag. This is a heuristic, not a full HTML tokenizer.
+	let unclosed: Set<string> | undefined;
+	let i = 0;
+	while ((i = html.indexOf("<", i)) !== -1) {
+		if (html.startsWith("<!--", i)) {
+			i = commentEnd(html, i);
+			if (i === -1) return -1; // unclosed comment runs to the end
+			continue;
+		}
+		if (!isAsciiAlpha(html.charCodeAt(i + 1))) {
+			i++;
+			continue;
+		}
+		const nameEnd = tagNameEnd(html, i + 1);
+		const tagEnd = openTagEnd(html, nameEnd);
+		if (tagEnd === -1) return -1; // the rest is inside an unfinished tag
+		const name = nameEnd - i - 1 <= MAX_NAME ? html.slice(i + 1, nameEnd).toLowerCase() : "";
+		if (name === "title") return tagEnd;
+		i = tagEnd;
+		const close = SKIPPED_TAGS.get(name);
+		// Only foreign content like <svg/> honors the self-closing slash.
+		const selfClosed = name === "svg" && html.charCodeAt(tagEnd - 2) === 47;
+		if (!close || selfClosed || unclosed?.has(name)) continue;
+		// An opener with no closer is read as a plain tag, and remembered, so
+		// later openers of that tag don't search to the end again.
+		close.lastIndex = tagEnd;
+		const gt = close.exec(html) ? html.indexOf(">", close.lastIndex) : -1;
+		if (gt === -1) (unclosed ??= new Set()).add(name);
+		else i = gt + 1;
+	}
+	return -1;
+}
+
+/** `</tag` followed by whitespace, `/` or `>`; the caller finds the `>` itself,
+ *  since a `[^>]*>` here would rescan to the end for every candidate. */
+const SKIPPED_TAGS = new Map(
+	["script", "style", "noscript", "template", "svg"].map((t) => [
+		t,
+		new RegExp(`</${t}(?=[\\t\\n\\f\\r />])`, "gi"),
+	]),
+);
+
+/** Longest tag name the scan needs to tell apart; longer names are never sliced. */
+const MAX_NAME = Math.max("title".length, ...[...SKIPPED_TAGS.keys()].map((t) => t.length));
+
+/** Index just past the comment opening at `start`, or -1 when it never closes.
+ *  `<!-->` and `<!--->` are complete empty comments. */
+function commentEnd(html: string, start: number): number {
+	if (html.startsWith(">", start + 4)) return start + 5;
+	if (html.startsWith("->", start + 4)) return start + 6;
+	const end = html.indexOf("-->", start + 4);
+	return end === -1 ? -1 : end + 3;
+}
+
+/** End of the tag name starting at `start`: the first whitespace, `/` or `>`. */
+function tagNameEnd(html: string, start: number): number {
+	let j = start;
+	while (j < html.length) {
+		const c = html.charCodeAt(j);
+		if (isHtmlSpace(c) || c === 47 || c === 62) break;
+		j++;
+	}
+	return j;
+}
+
+/** Index just past the `>` closing a start tag, skipping quoted attribute
+ *  values, or -1 when the tag never closes. */
+function openTagEnd(html: string, from: number): number {
+	for (let j = from; j < html.length; j++) {
+		const c = html.charCodeAt(j);
+		if (c === 62) return j + 1;
+		if (c !== 61) continue; // `=` starts a value
+		do j++;
+		while (j < html.length && isHtmlSpace(html.charCodeAt(j)));
+		const q = html.charCodeAt(j);
+		if (q === 34 || q === 39) {
+			j = html.indexOf(html[j]!, j + 1);
+			if (j === -1) return -1;
+			continue;
+		}
+		// Unquoted: runs to whitespace or `>`, quotes and `=` included.
+		while (j < html.length && !isHtmlSpace(html.charCodeAt(j)) && html.charCodeAt(j) !== 62) j++;
+		j--;
+	}
+	return -1;
+}
+
+/** HTML whitespace: tab, LF, FF, CR, space. Not \s, which also matches NBSP. */
+function isHtmlSpace(c: number): boolean {
+	return c === 32 || c === 9 || c === 10 || c === 12 || c === 13;
+}
+
+function isAsciiAlpha(c: number): boolean {
+	return (c >= 65 && c <= 90) || (c >= 97 && c <= 122);
+}