@menapo/machine 0.0.0-stage → 0.1.0

package/dist/vite.js

@@ -0,0 +1,4281 @@
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { dirname, join, resolve } from "node:path";
+import { parseSync } from "vite";
+import { existsSync, readFileSync, statSync } from "node:fs";
+//#region ../glue/src/detect.ts
+/**
+* Which framework a module renders with (machine PLAN §5.5), the way vicss
+* decides it: `.vue` and `.svelte` (with `.svelte.js`/`.svelte.ts` rune
+* modules) by extension; JSX by its `@jsxImportSource` pragma, else the
+* project's JSX framework ({@link jsxFrameworkOf}); plain scripts by the
+* plugin's `framework` option, else the framework the root `package.json`
+* depends on, else none (vanilla). Plain data in and out, so it is
+* unit-tested without Vite.
+*
+* vi18n has a detection of its own (its `vite/glue/detect.ts`, by plugin
+* names); it is published, so moving it onto this module waits for its
+* next minor (machine PLAN §11).
+*/
+/** Root dependencies that name a project's framework, the first found winning. */
+const DEPENDENCIES = [
+	["vue", "vue"],
+	["svelte", "svelte"],
+	["solid-js", "solid"],
+	["preact", "preact"],
+	["react", "react"]
+];
+/** `preact`, `solid-js` and `vue` (and their subpaths) by name; any other JSX source takes React's. */
+function jsxFramework(source) {
+	const name = source.split("/")[0];
+	if (name === "preact") return "preact";
+	if (name === "solid-js") return "solid";
+	if (name === "vue") return "vue";
+	return "react";
+}
+/** The framework of module `id` with source `code`. */
+function frameworkOf(id, code, settings) {
+	const file = id.replace(/[?#].*$/, "").toLowerCase();
+	if (file.endsWith(".vue")) return "vue";
+	if (file.endsWith(".svelte") || /\.svelte\.[cm]?[jt]s$/.test(file)) return "svelte";
+	if (/\.[jt]sx$/.test(file)) {
+		const pragma = /@jsxImportSource\s+([^\s*]+)/.exec(code)?.[1];
+		return pragma ? jsxFramework(pragma) : settings.jsx;
+	}
+	return settings.scripts;
+}
+/** The names a `package.json` depends on, if it can be read. */
+function dependencies(root) {
+	const file = join(root, "package.json");
+	if (!existsSync(file)) return void 0;
+	try {
+		const pkg = JSON.parse(readFileSync(file, "utf8"));
+		return /* @__PURE__ */ new Set([...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.devDependencies ?? {})]);
+	} catch {
+		return;
+	}
+}
+/** The framework the `package.json` in `root` depends on, if a known one. */
+function rootFramework(root) {
+	const names = dependencies(root);
+	return names && DEPENDENCIES.find(([name]) => names.has(name))?.[1];
+}
+/**
+* JSX frameworks by the names of the Vite plugins that compile them, as
+* vi18n recognises them: a prefix up to a separator, or the exact name.
+*/
+const JSX_PLUGINS = [
+	["react", /^(?:vite:react|@vitejs\/plugin-react)(?:[:/-]|$)/],
+	["preact", /^(?:preact:|vite:preact(?:[:/-]|$)|@preact\/|prefresh(?:[:/-]|$)|preact$)/],
+	["solid", /^(?:solid:|vite-plugin-solid(?:[:/-]|$)|solid-start(?:[:/-]|$)|solid$)/],
+	["vue", /^(?:vite:vue-jsx|@vitejs\/plugin-vue-jsx)(?:[:/-]|$)/]
+];
+/** The one JSX framework whose Vite plugin is in `plugins`; none when there are none or several. */
+function pluginFramework(plugins) {
+	const found = /* @__PURE__ */ new Set();
+	for (const plugin of plugins) {
+		const name = plugin?.name;
+		if (typeof name !== "string") continue;
+		for (const [framework, pattern] of JSX_PLUGINS) if (pattern.test(name)) found.add(framework);
+	}
+	return found.size === 1 ? [...found][0] : void 0;
+}
+/** tsconfig's JSON with comments and trailing commas, as TypeScript reads it. */
+function parseJsonc(text) {
+	let out = "";
+	for (let i = 0; i < text.length; i++) {
+		const c = text[i];
+		if (c === "\"") {
+			const end = /"(?:[^"\\]|\\.)*"/y;
+			end.lastIndex = i;
+			const string = end.exec(text)?.[0] ?? c;
+			out += string;
+			i += string.length - 1;
+		} else if (c === "/" && text[i + 1] === "/") {
+			while (i < text.length && text[i] !== "\n") i++;
+			out += "\n";
+		} else if (c === "/" && text[i + 1] === "*") {
+			const end = text.indexOf("*/", i + 2);
+			i = end < 0 ? text.length : end + 1;
+		} else out += c;
+	}
+	return JSON.parse(out.replace(/,(\s*[}\]])/g, "$1"));
+}
+/** A tsconfig named by `extends` or a reference: a file, a directory's `tsconfig.json`, or a package's. */
+function tsconfigPath(from, name) {
+	const local = name.startsWith(".") || name.startsWith("/");
+	let path;
+	try {
+		path = local ? resolve(dirname(from), name) : createRequire(from).resolve(name);
+	} catch {
+		return;
+	}
+	if (existsSync(path) && statSync(path).isDirectory()) path = join(path, "tsconfig.json");
+	else if (!existsSync(path) && existsSync(`${path}.json`)) path = `${path}.json`;
+	return existsSync(path) ? path : void 0;
+}
+/**
+* `compilerOptions.jsxImportSource` as TypeScript resolves it for `file`:
+* its own, else its `extends`' (the last one first); then, for a solution
+* file (`references`, as create-vite writes), the first referenced project
+* that sets one.
+*/
+function tsconfigJsxSource(file, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(file) || !existsSync(file)) return void 0;
+	seen.add(file);
+	let config;
+	try {
+		config = parseJsonc(readFileSync(file, "utf8"));
+	} catch {
+		return;
+	}
+	const own = config.compilerOptions?.jsxImportSource;
+	if (typeof own === "string") return own;
+	const bases = typeof config.extends === "string" ? [config.extends] : config.extends ?? [];
+	for (const base of [...bases].reverse()) {
+		const path = tsconfigPath(file, base);
+		const found = path && tsconfigJsxSource(path, seen);
+		if (found) return found;
+	}
+	for (const reference of config.references ?? []) {
+		const path = tsconfigPath(file, reference.path);
+		const found = path && tsconfigJsxSource(path, seen);
+		if (found) return found;
+	}
+}
+/**
+* The framework of JSX without a pragma: the JSX import source the Vite
+* config gives Oxc or esbuild; else the one JSX framework whose Vite plugin
+* is installed (`vite-plugin-solid`, the Preact preset); else the root
+* tsconfig's `jsxImportSource`, through `extends` and `references`; else
+* Preact, Solid or Vue when the root `package.json` depends on it; else React.
+*/
+function jsxFrameworkOf(config, root) {
+	const oxc = config.oxc;
+	const esbuild = config.esbuild;
+	const fromVite = (oxc && oxc.jsx?.importSource) ?? (esbuild && esbuild.jsxImportSource);
+	if (typeof fromVite === "string") return jsxFramework(fromVite);
+	const plugin = pluginFramework(config.plugins ?? []);
+	if (plugin) return plugin;
+	const fromTsconfig = tsconfigJsxSource(join(root, "tsconfig.json"));
+	if (fromTsconfig) return jsxFramework(fromTsconfig);
+	const names = dependencies(root);
+	if (names?.has("preact")) return "preact";
+	if (names?.has("solid-js")) return "solid";
+	if (names?.has("vue") && !names.has("react")) return "vue";
+	return "react";
+}
+//#endregion
+//#region ../glue/src/vite.ts
+/**
+* The build side of the shared glue (machine PLAN §5.1, §5.5): a Vite
+* plugin that resolves a package's hooks (`useMachine` from
+* `@menapo/machine`) per module to that module's framework, so one import
+* works in React, Preact, Vue, Svelte, Solid and plain scripts, and no
+* package has a `/react` or `/vue` entry (repo rule: entries by role).
+*
+* - **Per module:** each module importing a hook gets the hook from
+*   `virtual:<package>/glue/<framework>`, which resolves to the package's
+*   glue module for that framework; the rest of the import stays. Every
+*   form that reaches a hook is rewritten: named imports (string names
+*   too), a namespace import's members, re-exports, `export *` and
+*   `import()`.
+* - **The app's framework:** a glue module and the adapters it uses import
+*   `react`, `vue`… by name. Those imports resolve from the project root, as
+*   the app's own do, so the app's single copy is used wherever the glue
+*   module lives (a workspace package, `node_modules`); one that does not
+*   resolve there fails the build, naming the fix.
+*/
+/**
+* A path as Vite writes ids, with forward slashes on every platform:
+* `fileURLToPath` gives backslashes on Windows, and a prefix test of one
+* against the other never matches.
+*/
+const posix = (path) => path.replace(/\\/g, "/");
+/** Whether `id` is inside one of `dirs`, both compared as Vite writes them. */
+const within = (dirs, id) => dirs.some((dir) => posix(id).startsWith(posix(dir)));
+/** The adapters' own directory: their framework imports resolve from the project root too. */
+const OWN = dirname(fileURLToPath(import.meta.url));
+/** Packages a glue module imports by name: resolved from the project root. */
+const FRAMEWORK_IMPORT = /^(?:react|react-dom|preact|vue|svelte|solid-js)(?:\/|$)/;
+/** The modules the rewrite reads: scripts and framework files, never `?raw` text or an asset's URL. */
+const MODULE = /\.(?:[cm]?[jt]sx?|vue|svelte)(?:\?|$)/;
+const NOT_CODE = /[?&](?:raw|url|inline|worker|sharedworker)(?:[&=]|$)/;
+/** The scripts of a module: the whole of it, or a `.vue`/`.svelte` file's `<script>` blocks. */
+function scripts(code, file) {
+	const framework = /\.(?:vue|svelte)$/.test(file);
+	if (!framework || !code.includes("<script")) return [{
+		offset: 0,
+		source: code,
+		name: framework ? "x.ts" : file
+	}];
+	const out = [];
+	for (const match of code.matchAll(/(<script\b([^>]*)>)([\s\S]*?)<\/script>/g)) {
+		const lang = /\blang\s*=\s*["']([jt]sx?)["']/.exec(match[2])?.[1] ?? "js";
+		out.push({
+			offset: match.index + match[1].length,
+			source: match[3],
+			name: `x.${lang}`
+		});
+	}
+	return out;
+}
+/** Every node below `node`, depth first. */
+function walk(node, visit) {
+	if (Array.isArray(node)) for (const child of node) walk(child, visit);
+	else if (node && typeof node === "object" && typeof node.type === "string") {
+		visit(node);
+		for (const key of Object.keys(node)) if (key !== "parent") walk(node[key], visit);
+	}
+}
+const nameOf$2 = (node) => node.type === "Identifier" ? node.name : String(node.value);
+/** A name as a specifier writes it: bare when it is an identifier, else quoted (`"a-b"`). */
+const spell = (name) => /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+/**
+* Rewrites every way module `code` reaches `hooks` of `pkg` so they come
+* from `target`; type-only imports and specifiers stay. Replacements keep
+* the lines they replace, so every other position in the module stands.
+* Null when the module reaches no hook.
+*/
+function rewrite(code, file, pkg, hooks, target) {
+	const edits = [];
+	const to = JSON.stringify(target);
+	const from = JSON.stringify(pkg);
+	const lines = (start, end) => "\n".repeat(code.slice(start, end).split("\n").length - 1);
+	for (const { offset, source, name } of scripts(code, file)) {
+		const { program, errors } = parseSync(name, source);
+		if (errors.length) continue;
+		const at = (node) => [offset + node.start, offset + node.end];
+		/** Namespace imports of the package: their hook members are rewritten to `__glue_<hook>`. */
+		const namespaces = /* @__PURE__ */ new Set();
+		/** Where the hooks those members read are imported: before the namespace's import, on its line. */
+		let hidden;
+		let used = false;
+		for (const statement of program.body) if (statement.type === "ImportDeclaration" && statement.source.value === pkg) {
+			if (statement.importKind === "type") continue;
+			const mine = [];
+			const rest = [];
+			let namespace;
+			for (const specifier of statement.specifiers) if (specifier.type === "ImportNamespaceSpecifier") namespace = specifier.local.name;
+			else if (specifier.type === "ImportSpecifier") {
+				const imported = nameOf$2(specifier.imported);
+				const local = specifier.local.name;
+				const text = imported === local ? local : `${spell(imported)} as ${local}`;
+				if (specifier.importKind !== "type" && hooks.includes(imported)) mine.push(text);
+				else rest.push(specifier.importKind === "type" ? `type ${text}` : text);
+			}
+			if (namespace !== void 0) {
+				namespaces.add(namespace);
+				hidden ??= offset + statement.start;
+			}
+			if (!mine.length) continue;
+			const [start, end] = at(statement);
+			const kept = rest.length ? `import { ${rest.join(", ")} } from ${from}; ` : "";
+			edits.push([
+				start,
+				end,
+				`${kept}import { ${mine.join(", ")} } from ${to};${lines(start, end)}`
+			]);
+		} else if (statement.type === "ExportNamedDeclaration" && statement.source?.value === pkg && statement.exportKind !== "type") {
+			const mine = [];
+			const rest = [];
+			for (const specifier of statement.specifiers) {
+				const local = nameOf$2(specifier.local);
+				const exported = nameOf$2(specifier.exported);
+				const text = local === exported ? spell(local) : `${spell(local)} as ${spell(exported)}`;
+				if (specifier.exportKind !== "type" && hooks.includes(local)) mine.push(text);
+				else rest.push(specifier.exportKind === "type" ? `type ${text}` : text);
+			}
+			if (!mine.length) continue;
+			const [start, end] = at(statement);
+			const kept = rest.length ? `export { ${rest.join(", ")} } from ${from}; ` : "";
+			edits.push([
+				start,
+				end,
+				`${kept}export { ${mine.join(", ")} } from ${to};${lines(start, end)}`
+			]);
+		} else if (statement.type === "ExportAllDeclaration" && statement.source.value === pkg && !statement.exported && statement.exportKind !== "type") {
+			const [, end] = at(statement);
+			edits.push([
+				end,
+				end,
+				` export { ${hooks.join(", ")} } from ${to};`
+			]);
+		}
+		walk(program.body, (node) => {
+			if (node.type === "ImportExpression" && node.source.type === "Literal" && node.source.value === pkg) {
+				const [start, end] = at(node);
+				edits.push([
+					start,
+					end,
+					`Promise.all([import(${from}), import(${to})]).then(([m, g]) => ({ ...m, ...g }))`
+				]);
+			} else if (node.type === "MemberExpression" && node.object.type === "Identifier" && namespaces.has(node.object.name)) {
+				const key = node.computed ? node.property.type === "Literal" && typeof node.property.value === "string" ? node.property.value : void 0 : nameOf$2(node.property);
+				if (key === void 0 || !hooks.includes(key)) return;
+				const [start, end] = at(node);
+				edits.push([
+					start,
+					end,
+					`__glue_${key}`
+				]);
+				used = true;
+			}
+		});
+		if (used && hidden !== void 0) {
+			const names = hooks.map((hook) => `${hook} as __glue_${hook}`).join(", ");
+			edits.push([
+				hidden,
+				hidden,
+				`import { ${names} } from ${to}; `
+			]);
+		}
+	}
+	if (!edits.length) return null;
+	let out = code;
+	for (const [start, end, text] of edits.sort((a, b) => b[0] - a[0] || b[1] - a[1])) out = out.slice(0, start) + text + out.slice(end);
+	return out;
+}
+/** The plugin resolving `options.hooks` per framework. */
+function gluePlugin(options) {
+	const prefix = `virtual:${options.package}/glue/`;
+	const dirs = [OWN, ...options.dirs].map(posix);
+	let settings = {
+		scripts: "vanilla",
+		jsx: "react"
+	};
+	let root = process.cwd();
+	return {
+		name: options.name,
+		enforce: "pre",
+		configResolved(config) {
+			root = config.root;
+			settings = {
+				scripts: options.framework ?? rootFramework(root) ?? "vanilla",
+				jsx: jsxFrameworkOf(config, root)
+			};
+		},
+		async resolveId(source, importer) {
+			if (source.startsWith(prefix)) return posix(options.module(source.slice(prefix.length)));
+			if (importer && FRAMEWORK_IMPORT.test(source) && within(dirs, importer)) {
+				const found = await this.resolve(source, join(root, "index.html"), { skipSelf: true });
+				if (found) return found;
+				this.error(`[${options.name}] the ${options.package} glue imports "${source}", which does not resolve from the project root (${root}): install it there, or tell the plugin the framework (its \`framework\` option for plain scripts, a \`@jsxImportSource\` pragma or tsconfig's \`jsxImportSource\` for JSX).`);
+			}
+			return null;
+		},
+		transform: {
+			filter: {
+				id: {
+					include: MODULE,
+					exclude: NOT_CODE
+				},
+				code: options.package
+			},
+			handler(code, id) {
+				if (id.startsWith("\0") || within(dirs, id)) return null;
+				const framework = frameworkOf(id, code, settings);
+				const out = rewrite(code, posix(id).replace(/[?#].*$/, ""), options.package, options.hooks, prefix + framework);
+				return out === null ? null : {
+					code: out,
+					map: null
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.6.0/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
+var comma = ",".charCodeAt(0);
+var semicolon = ";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar$1 = /* @__PURE__ */ new Uint8Array(64);
+var charToInt = /* @__PURE__ */ new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+	const c = chars.charCodeAt(i);
+	intToChar$1[i] = c;
+	charToInt[c] = i;
+}
+function encodeInteger(builder, num) {
+	do {
+		let clamped = num & 31;
+		num >>>= 5;
+		if (num > 0) clamped |= 32;
+		builder.write(intToChar$1[clamped]);
+	} while (num > 0);
+}
+function encodeSign(num) {
+	return num < 0 ? -num << 1 | 1 : num << 1;
+}
+var bufLength = 16384;
+var td = typeof TextDecoder !== "undefined" ? /* @__PURE__ */ new TextDecoder() : typeof Buffer !== "undefined" ? { decode(buf) {
+	return Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength).toString();
+} } : { decode(buf) {
+	let out = "";
+	for (let i = 0; i < buf.length; i++) out += String.fromCharCode(buf[i]);
+	return out;
+} };
+var StringWriter = class {
+	constructor() {
+		this.pos = 0;
+		this.out = "";
+		this.buffer = new Uint8Array(bufLength);
+	}
+	write(v) {
+		const { buffer } = this;
+		buffer[this.pos++] = v;
+		if (this.pos === bufLength) {
+			this.out += td.decode(buffer);
+			this.pos = 0;
+		}
+	}
+	flush() {
+		const { buffer, out, pos } = this;
+		return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+	}
+};
+function encodeRangeMappings(decoded) {
+	if (decoded.length === 0) return "";
+	const writer = new StringWriter();
+	for (let i = 0; i < decoded.length; i++) {
+		const indices = decoded[i];
+		if (i > 0) writer.write(semicolon);
+		let index = 0;
+		for (let j = 0; j < indices.length; j++) {
+			const offset = indices[j];
+			encodeInteger(writer, offset - index);
+			index = offset;
+		}
+	}
+	return writer.flush();
+}
+function encode(decoded) {
+	const writer = new StringWriter();
+	let sourcesIndex = 0;
+	let sourceLine = 0;
+	let sourceColumn = 0;
+	let namesIndex = 0;
+	for (let i = 0; i < decoded.length; i++) {
+		const line = decoded[i];
+		if (i > 0) writer.write(semicolon);
+		if (line.length === 0) continue;
+		let genColumn = 0;
+		for (let j = 0; j < line.length; j++) {
+			const segment = line[j];
+			if (j > 0) writer.write(comma);
+			encodeInteger(writer, encodeSign(segment[0] - genColumn));
+			genColumn = segment[0];
+			if (segment.length === 1) continue;
+			encodeInteger(writer, encodeSign(segment[1] - sourcesIndex));
+			encodeInteger(writer, encodeSign(segment[2] - sourceLine));
+			encodeInteger(writer, encodeSign(segment[3] - sourceColumn));
+			sourcesIndex = segment[1];
+			sourceLine = segment[2];
+			sourceColumn = segment[3];
+			if (segment.length === 4) continue;
+			encodeInteger(writer, encodeSign(segment[4] - namesIndex));
+			namesIndex = segment[4];
+		}
+	}
+	return writer.flush();
+}
+//#endregion
+//#region ../../node_modules/.pnpm/magic-string@1.4.3/node_modules/magic-string/dist/index.mjs
+var BitSet = class BitSet {
+	constructor(arg) {
+		this.bits = arg instanceof BitSet ? arg.bits.slice() : [];
+	}
+	add(n) {
+		this.bits[n >> 5] |= 1 << (n & 31);
+	}
+	has(n) {
+		return !!(this.bits[n >> 5] & 1 << (n & 31));
+	}
+};
+var Chunk = class Chunk {
+	constructor(start, end, content) {
+		this.start = start;
+		this.end = end;
+		this.original = content;
+		this.intro = "";
+		this.outro = "";
+		this.content = content;
+		this.storeName = false;
+		this.edited = false;
+		this.previous = null;
+		this.next = null;
+	}
+	appendLeft(content) {
+		this.outro += content;
+	}
+	appendRight(content) {
+		this.intro = this.intro + content;
+	}
+	clone() {
+		const chunk = new Chunk(this.start, this.end, this.original);
+		chunk.intro = this.intro;
+		chunk.outro = this.outro;
+		chunk.content = this.content;
+		chunk.storeName = this.storeName;
+		chunk.edited = this.edited;
+		return chunk;
+	}
+	contains(index) {
+		return this.start < index && index < this.end;
+	}
+	eachNext(fn) {
+		fn(this);
+		let chunk = this.next;
+		while (chunk) {
+			fn(chunk);
+			chunk = chunk.next;
+		}
+	}
+	eachPrevious(fn) {
+		fn(this);
+		let chunk = this.previous;
+		while (chunk) {
+			fn(chunk);
+			chunk = chunk.previous;
+		}
+	}
+	edit(content, storeName, contentOnly) {
+		this.content = content;
+		if (!contentOnly) {
+			this.intro = "";
+			this.outro = "";
+		}
+		this.storeName = storeName;
+		this.edited = true;
+		return this;
+	}
+	prependLeft(content) {
+		this.outro = content + this.outro;
+	}
+	prependRight(content) {
+		this.intro = content + this.intro;
+	}
+	reset() {
+		this.intro = "";
+		this.outro = "";
+		if (this.edited) {
+			this.content = this.original;
+			this.storeName = false;
+			this.edited = false;
+		}
+	}
+	split(index) {
+		const sliceIndex = index - this.start;
+		const originalBefore = this.original.slice(0, sliceIndex);
+		const originalAfter = this.original.slice(sliceIndex);
+		this.original = originalBefore;
+		const newChunk = new Chunk(index, this.end, originalAfter);
+		newChunk.outro = this.outro;
+		this.outro = "";
+		this.end = index;
+		if (this.edited) {
+			newChunk.edit("", false, true);
+			this.content = "";
+		} else this.content = originalBefore;
+		newChunk.next = this.next;
+		if (newChunk.next) newChunk.next.previous = newChunk;
+		newChunk.previous = this;
+		this.next = newChunk;
+		return newChunk;
+	}
+	toString() {
+		return this.intro + this.content + this.outro;
+	}
+	trimEnd(rx) {
+		this.outro = this.outro.replace(rx, "");
+		if (this.outro.length) return true;
+		const trimmed = this.content.replace(rx, "");
+		if (trimmed.length) {
+			if (trimmed !== this.content) {
+				if (this.edited) this.edit(trimmed, this.storeName, true);
+				else this.split(this.start + trimmed.length).edit("", void 0, true);
+			}
+			return true;
+		} else {
+			this.edit("", void 0, true);
+			this.intro = this.intro.replace(rx, "");
+			if (this.intro.length) return true;
+		}
+	}
+	trimStart(rx) {
+		this.intro = this.intro.replace(rx, "");
+		if (this.intro.length) return true;
+		const trimmed = this.content.replace(rx, "");
+		if (trimmed.length) {
+			if (trimmed !== this.content) {
+				if (this.edited) this.edit(trimmed, this.storeName, true);
+				else {
+					this.split(this.end - trimmed.length);
+					this.edit("", void 0, true);
+				}
+			}
+			return true;
+		} else {
+			this.edit("", void 0, true);
+			this.outro = this.outro.replace(rx, "");
+			if (this.outro.length) return true;
+		}
+	}
+};
+/**
+* The single error type thrown by MagicString.
+*
+* Every message is prefixed with `[MagicString]` so its source is obvious at a
+* glance, and is kept short and consistent in tone.
+*/
+var MagicStringError = class extends Error {
+	name = "MagicStringError";
+	constructor(message, options) {
+		super(`[MagicString] ${message}`, options);
+	}
+};
+function getBtoa() {
+	/* v8 ignore next -- environment fallback, unreachable when `btoa` is present */
+	if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
+	const buffer = globalThis["Buffer"];
+	if (buffer) return (str) => buffer.from(str, "utf-8").toString("base64");
+	return () => {
+		throw new MagicStringError("unsupported environment: `btoa` or `Buffer` is required");
+	};
+	/* v8 ignore stop */
+}
+const btoa = /* #__PURE__ */ getBtoa();
+var SourceMap = class {
+	constructor(properties) {
+		this.version = 3;
+		this.file = properties.file;
+		this.sources = properties.sources;
+		this.sourcesContent = properties.sourcesContent;
+		this.names = properties.names;
+		this.mappings = typeof properties.mappings === "string" ? properties.mappings : encode(properties.mappings);
+		if (typeof properties.x_google_ignoreList !== "undefined") this.x_google_ignoreList = properties.x_google_ignoreList;
+		if (typeof properties.debugId !== "undefined") this.debugId = properties.debugId;
+		if (typeof properties.rangeMappings !== "undefined") {
+			let shouldOutputRangeMapping = false;
+			for (const line of properties.rangeMappings) if (line.length !== 0) {
+				shouldOutputRangeMapping = true;
+				break;
+			}
+			if (shouldOutputRangeMapping) this.rangeMappings = encodeRangeMappings(properties.rangeMappings);
+		}
+	}
+	/**
+	* Returns the equivalent of `JSON.stringify(map)`
+	*/
+	toString() {
+		return JSON.stringify(this);
+	}
+	/**
+	* Returns a DataURI containing the sourcemap. Useful for doing this sort of thing:
+	* `generateMap(options?: SourceMapOptions): SourceMap;`
+	*/
+	toUrl() {
+		return `data:application/json;charset=utf-8;base64,${btoa(this.toString())}`;
+	}
+};
+function getLocator(source) {
+	const lineOffsets = [0];
+	for (let i = source.indexOf("\n"); i !== -1; i = source.indexOf("\n", i + 1)) lineOffsets.push(i + 1);
+	return function locate(index) {
+		let i = 0;
+		let j = lineOffsets.length;
+		while (i < j) {
+			const m = i + j >> 1;
+			if (index < lineOffsets[m]) j = m;
+			else i = m + 1;
+		}
+		const line = i - 1;
+		return {
+			line,
+			column: index - lineOffsets[line]
+		};
+	};
+}
+function getRelativePath(from, to) {
+	const fromParts = from.split(/[/\\]/);
+	const toParts = to.split(/[/\\]/);
+	fromParts.pop();
+	while (fromParts[0] === toParts[0]) {
+		fromParts.shift();
+		toParts.shift();
+	}
+	if (fromParts.length) {
+		let i = fromParts.length;
+		while (i--) fromParts[i] = "..";
+	}
+	return fromParts.concat(toParts).join("/");
+}
+function guessIndent(code) {
+	const lines = code.split("\n");
+	const tabbed = lines.filter((line) => /^\t+/.test(line));
+	const spaced = lines.filter((line) => /^ {2,}/.test(line));
+	if (tabbed.length === 0 && spaced.length === 0) return null;
+	if (tabbed.length >= spaced.length) return "	";
+	const min = spaced.reduce((previous, current) => {
+		const numSpaces = /^ +/.exec(current)[0].length;
+		return Math.min(numSpaces, previous);
+	}, Infinity);
+	return " ".repeat(min);
+}
+const toString = Object.prototype.toString;
+function isObject(thing) {
+	return toString.call(thing) === "[object Object]";
+}
+const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const intToChar = /* #__PURE__ */ (() => {
+	const chars = /* @__PURE__ */ new Uint8Array(64);
+	for (let i = 0; i < 64; i++) chars[i] = BASE64_CHARS.charCodeAt(i);
+	return chars;
+})();
+const COMMA = 44;
+const SEMICOLON = 59;
+const BUFFER_SIZE = 16384;
+const FLUSH_THRESHOLD = 16348;
+const scratch = /* #__PURE__ */ new Uint8Array(BUFFER_SIZE);
+function writeVlq(pos, num) {
+	num = num < 0 ? -num << 1 | 1 : num << 1;
+	do {
+		let clamped = num & 31;
+		num >>>= 5;
+		if (num > 0) clamped |= 32;
+		scratch[pos++] = intToChar[clamped];
+	} while (num > 0);
+	return pos;
+}
+const decoder = /* #__PURE__ */ new TextDecoder();
+var MappingsEncoder = class {
+	constructor() {
+		this.out = "";
+		this.pos = 0;
+		this.lines = [];
+		this.buffered = 0;
+		this.needsComma = false;
+		this.prevGenColumn = 0;
+		this.prevSourceIndex = 0;
+		this.prevSourceLine = 0;
+		this.prevSourceColumn = 0;
+		this.prevNameIndex = 0;
+	}
+	endLine(segments) {
+		this.lines.push(segments);
+		this.buffered += segments.length + 1;
+		if (this.buffered >= 4096) this.drain(null);
+	}
+	segments(segments) {
+		this.drain(segments);
+	}
+	finish(segments) {
+		this.drain(segments);
+		this.flush();
+		return this.out;
+	}
+	drain(trailing) {
+		const lines = this.lines;
+		const lineCount = lines.length;
+		for (let l = 0; l <= lineCount; l++) {
+			const line = l < lineCount ? lines[l] : trailing;
+			if (line === null) break;
+			for (let i = 0; i < line.length; i++) {
+				if (this.pos > FLUSH_THRESHOLD) this.flush();
+				const segment = line[i];
+				if (this.needsComma) scratch[this.pos++] = COMMA;
+				this.needsComma = true;
+				this.pos = writeVlq(this.pos, segment[0] - this.prevGenColumn);
+				this.prevGenColumn = segment[0];
+				this.pos = writeVlq(this.pos, segment[1] - this.prevSourceIndex);
+				this.prevSourceIndex = segment[1];
+				this.pos = writeVlq(this.pos, segment[2] - this.prevSourceLine);
+				this.prevSourceLine = segment[2];
+				this.pos = writeVlq(this.pos, segment[3] - this.prevSourceColumn);
+				this.prevSourceColumn = segment[3];
+				if (segment.length === 5) {
+					this.pos = writeVlq(this.pos, segment[4] - this.prevNameIndex);
+					this.prevNameIndex = segment[4];
+				}
+			}
+			if (l < lineCount) {
+				if (this.pos > FLUSH_THRESHOLD) this.flush();
+				scratch[this.pos++] = SEMICOLON;
+				this.needsComma = false;
+				this.prevGenColumn = 0;
+			}
+		}
+		lines.length = 0;
+		this.buffered = 0;
+		this.flush();
+	}
+	flush() {
+		this.out += decoder.decode(scratch.subarray(0, this.pos));
+		this.pos = 0;
+	}
+};
+const NEWLINE_CHAR$1 = 10;
+function isWordCode(code) {
+	return code >= 97 && code <= 122 || code >= 65 && code <= 90 || code >= 48 && code <= 57 || code === 95;
+}
+var Mappings = class {
+	constructor(hires, encoder = null) {
+		this.hires = hires;
+		this.generatedCodeLine = 0;
+		this.generatedCodeColumn = 0;
+		this.raw = [];
+		this.rawSegments = this.raw[this.generatedCodeLine] = [];
+		this.rawRangeMappings = [];
+		this.rawRangeMappingsIndices = this.rawRangeMappings[this.generatedCodeLine] = [];
+		this.encoder = encoder;
+	}
+	nextLine() {
+		if (this.encoder === null) {
+			this.generatedCodeLine += 1;
+			this.raw[this.generatedCodeLine] = this.rawSegments = [];
+		} else {
+			this.encoder.endLine(this.rawSegments);
+			this.rawSegments = [];
+			this.generatedCodeLine += 1;
+		}
+		this.generatedCodeColumn = 0;
+		this.rawRangeMappings[this.generatedCodeLine] = this.rawRangeMappingsIndices = [];
+	}
+	addEdit(sourceIndex, content, loc, nameIndex) {
+		if (content.length) {
+			const contentLengthMinusOne = content.length - 1;
+			let contentLineEnd = content.indexOf("\n", 0);
+			let previousContentLineEnd = -1;
+			while (contentLineEnd >= 0 && contentLengthMinusOne > contentLineEnd) {
+				const segment = [
+					this.generatedCodeColumn,
+					sourceIndex,
+					loc.line,
+					loc.column
+				];
+				if (nameIndex >= 0) segment.push(nameIndex);
+				this.rawSegments.push(segment);
+				this.nextLine();
+				previousContentLineEnd = contentLineEnd;
+				contentLineEnd = content.indexOf("\n", contentLineEnd + 1);
+			}
+			const segment = [
+				this.generatedCodeColumn,
+				sourceIndex,
+				loc.line,
+				loc.column
+			];
+			if (nameIndex >= 0) segment.push(nameIndex);
+			this.rawSegments.push(segment);
+			this.advance(content.slice(previousContentLineEnd + 1));
+		}
+	}
+	addUneditedChunk(sourceIndex, chunk, original, loc, sourcemapLocations) {
+		const end = chunk.end;
+		let i = chunk.start;
+		if (this.hires) {
+			const boundary = this.hires === "boundary";
+			const experimentalRange = this.hires === "experimental-range";
+			const encoder = experimentalRange ? null : this.encoder;
+			let charInHiresBoundary = false;
+			while (i < end) {
+				if (encoder !== null && this.rawSegments.length >= 4096) {
+					encoder.segments(this.rawSegments);
+					this.rawSegments.length = 0;
+				}
+				if (experimentalRange && i + 1 >= end) this.rawSegments.push([
+					this.generatedCodeColumn,
+					sourceIndex,
+					loc.line,
+					loc.column
+				]);
+				const code = original.charCodeAt(i);
+				if (code === NEWLINE_CHAR$1) {
+					loc.line += 1;
+					loc.column = 0;
+					this.nextLine();
+					charInHiresBoundary = false;
+				} else {
+					if (boundary) {
+						if (isWordCode(code)) {
+							if (!charInHiresBoundary) {
+								this.rawSegments.push([
+									this.generatedCodeColumn,
+									sourceIndex,
+									loc.line,
+									loc.column
+								]);
+								charInHiresBoundary = true;
+							}
+						} else {
+							this.rawSegments.push([
+								this.generatedCodeColumn,
+								sourceIndex,
+								loc.line,
+								loc.column
+							]);
+							charInHiresBoundary = false;
+						}
+					} else if (experimentalRange) {
+						if (i === chunk.start) {
+							this.rawRangeMappingsIndices.push(this.rawSegments.length);
+							this.rawSegments.push([
+								this.generatedCodeColumn,
+								sourceIndex,
+								loc.line,
+								loc.column
+							]);
+						}
+					} else this.rawSegments.push([
+						this.generatedCodeColumn,
+						sourceIndex,
+						loc.line,
+						loc.column
+					]);
+					loc.column += 1;
+					this.generatedCodeColumn += 1;
+				}
+				i += 1;
+			}
+		} else {
+			const bits = sourcemapLocations.bits;
+			while (i < end) {
+				let newline = original.indexOf("\n", i);
+				if (newline === -1 || newline > end) newline = end;
+				if (newline > i) {
+					this.rawSegments.push([
+						this.generatedCodeColumn,
+						sourceIndex,
+						loc.line,
+						loc.column
+					]);
+					for (let w = i + 1 >> 5, last = newline - 1 >> 5; w <= last; w++) {
+						let word = bits[w];
+						if (!word) continue;
+						const base = w << 5;
+						while (word) {
+							const lowest = word & -word;
+							const index = base + 31 - Math.clz32(lowest);
+							if (index > i && index < newline) {
+								const offset = index - i;
+								this.rawSegments.push([
+									this.generatedCodeColumn + offset,
+									sourceIndex,
+									loc.line,
+									loc.column + offset
+								]);
+							}
+							word ^= lowest;
+						}
+					}
+					loc.column += newline - i;
+					this.generatedCodeColumn += newline - i;
+				}
+				if (newline === end) break;
+				loc.line += 1;
+				loc.column = 0;
+				this.nextLine();
+				i = newline + 1;
+			}
+		}
+	}
+	advance(str) {
+		if (!str) return;
+		const lastNewline = str.lastIndexOf("\n");
+		for (let i = str.indexOf("\n"); i !== -1; i = str.indexOf("\n", i + 1)) this.nextLine();
+		this.generatedCodeColumn += str.length - lastNewline - 1;
+	}
+};
+const n = "\n";
+const NEWLINE_CHAR = "\n".charCodeAt(0);
+const CR_CHAR = "\r".charCodeAt(0);
+const warned = {
+	insertLeft: false,
+	insertRight: false,
+	storeName: false
+};
+/**
+* Expands the `$` substitution patterns that `String.prototype.replace` accepts
+* in a string replacement.
+* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_a_parameter
+*
+* `captures` holds the capture groups in order, so `captures[0]` is `$1`.
+* `namedCaptures` is `undefined` when the pattern has no named groups, and
+* `$<name>` is then literal text - which is also the case for a string search
+* value, where there are no groups of either kind.
+*/
+function expandReplacement(replacement, matched, position, str, captures, namedCaptures) {
+	if (!replacement.includes("$")) return replacement;
+	let result = "";
+	let index = 0;
+	while (index < replacement.length) {
+		const dollar = replacement.indexOf("$", index);
+		if (dollar === -1) {
+			result += replacement.slice(index);
+			break;
+		}
+		result += replacement.slice(index, dollar);
+		const char = replacement[dollar + 1];
+		let expansion = "$";
+		let consumed = 1;
+		if (char === "$") consumed = 2;
+		else if (char === "&") {
+			expansion = matched;
+			consumed = 2;
+		} else if (char === "`") {
+			expansion = str.slice(0, position);
+			consumed = 2;
+		} else if (char === "'") {
+			expansion = str.slice(position + matched.length);
+			consumed = 2;
+		} else if (char === "<" && namedCaptures !== void 0) {
+			const close = replacement.indexOf(">", dollar + 2);
+			if (close !== -1) {
+				expansion = namedCaptures[replacement.slice(dollar + 2, close)] ?? "";
+				consumed = close + 1 - dollar;
+			}
+		} else if (char >= "0" && char <= "9") {
+			const second = replacement[dollar + 2];
+			const double = second >= "0" && second <= "9" ? Number(char + second) : NaN;
+			const single = Number(char);
+			if (double >= 1 && double <= captures.length) {
+				expansion = captures[double - 1] ?? "";
+				consumed = 3;
+			} else if (single >= 1 && single <= captures.length) {
+				expansion = captures[single - 1] ?? "";
+				consumed = 2;
+			}
+		}
+		result += expansion;
+		index = dollar + consumed;
+	}
+	return result;
+}
+var MagicString = class MagicString {
+	constructor(string, options = {}) {
+		const chunk = new Chunk(0, string.length, string);
+		Object.defineProperties(this, {
+			original: {
+				writable: true,
+				value: string
+			},
+			outro: {
+				writable: true,
+				value: ""
+			},
+			intro: {
+				writable: true,
+				value: ""
+			},
+			firstChunk: {
+				writable: true,
+				value: chunk
+			},
+			lastChunk: {
+				writable: true,
+				value: chunk
+			},
+			lastSearchedChunk: {
+				writable: true,
+				value: chunk
+			},
+			byStart: {
+				writable: true,
+				value: /* @__PURE__ */ new Map([[0, chunk]])
+			},
+			byEnd: {
+				writable: true,
+				value: /* @__PURE__ */ new Map([[string.length, chunk]])
+			},
+			filename: {
+				writable: true,
+				value: options.filename
+			},
+			indentExclusionRanges: {
+				writable: true,
+				value: options.indentExclusionRanges
+			},
+			sourcemapLocations: {
+				writable: true,
+				value: new BitSet()
+			},
+			storedNames: {
+				writable: true,
+				value: {}
+			},
+			indentStr: {
+				writable: true,
+				value: void 0
+			},
+			ignoreList: {
+				writable: true,
+				value: options.ignoreList
+			},
+			offset: {
+				writable: true,
+				value: options.offset || 0
+			},
+			hasMovedChunks: {
+				writable: true,
+				value: false
+			}
+		});
+	}
+	/**
+	* Adds the specified character index (with respect to the original string) to sourcemap mappings, if `hires` is false.
+	*/
+	addSourcemapLocation(char) {
+		this.sourcemapLocations.add(char);
+	}
+	/**
+	* Appends the specified content to the end of the string.
+	*/
+	append(content) {
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+		this.outro += content;
+		return this;
+	}
+	/**
+	* Appends the specified content at the index in the original string.
+	* If a range *ending* with index is subsequently moved, the insert will be moved with it.
+	* See also `s.prependLeft(...)`.
+	*/
+	appendLeft(index, content) {
+		index = index + this.offset;
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+		this._split(index);
+		const chunk = this.byEnd.get(index);
+		if (chunk) chunk.appendLeft(content);
+		else this.intro += content;
+		return this;
+	}
+	/**
+	* Appends the specified content at the index in the original string.
+	* If a range *starting* with index is subsequently moved, the insert will be moved with it.
+	* See also `s.prependRight(...)`.
+	*/
+	appendRight(index, content) {
+		index = index + this.offset;
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+		this._split(index);
+		const chunk = this.byStart.get(index);
+		if (chunk) chunk.appendRight(content);
+		else this.outro += content;
+		return this;
+	}
+	/**
+	* Does what you'd expect.
+	*/
+	clone() {
+		const cloned = new MagicString(this.original, {
+			filename: this.filename,
+			ignoreList: this.ignoreList,
+			offset: this.offset
+		});
+		let originalChunk = this.firstChunk;
+		let clonedChunk = cloned.firstChunk = cloned.lastSearchedChunk = originalChunk.clone();
+		while (originalChunk) {
+			cloned.byStart.set(clonedChunk.start, clonedChunk);
+			cloned.byEnd.set(clonedChunk.end, clonedChunk);
+			const nextOriginalChunk = originalChunk.next;
+			const nextClonedChunk = nextOriginalChunk && nextOriginalChunk.clone();
+			if (nextClonedChunk) {
+				clonedChunk.next = nextClonedChunk;
+				nextClonedChunk.previous = clonedChunk;
+				clonedChunk = nextClonedChunk;
+			}
+			originalChunk = nextOriginalChunk;
+		}
+		cloned.lastChunk = clonedChunk;
+		if (this.indentExclusionRanges) cloned.indentExclusionRanges = this.indentExclusionRanges.slice();
+		cloned.sourcemapLocations = new BitSet(this.sourcemapLocations);
+		cloned.storedNames = { ...this.storedNames };
+		cloned.intro = this.intro;
+		cloned.outro = this.outro;
+		cloned.hasMovedChunks = this.hasMovedChunks;
+		return cloned;
+	}
+	/**
+	* Generates a sourcemap object with raw mappings in array form, rather than encoded as a string.
+	* Useful if you need to manipulate the sourcemap further, but most of the time you will use `generateMap` instead.
+	*/
+	generateDecodedMap(options) {
+		options = options || {};
+		const mappings = new Mappings(options.hires);
+		const names = this._generateMappings(mappings);
+		return {
+			...this._mapProperties(options, names),
+			mappings: mappings.raw,
+			rangeMappings: mappings.rawRangeMappings
+		};
+	}
+	/**
+	* Generates a version 3 sourcemap.
+	*/
+	generateMap(options) {
+		options = options || {};
+		const encoder = new MappingsEncoder();
+		const mappings = new Mappings(options.hires, encoder);
+		const names = this._generateMappings(mappings);
+		return new SourceMap({
+			...this._mapProperties(options, names),
+			mappings: encoder.finish(mappings.rawSegments),
+			rangeMappings: mappings.rawRangeMappings
+		});
+	}
+	/** @internal */
+	_generateMappings(mappings) {
+		const sourceIndex = 0;
+		const names = Object.keys(this.storedNames);
+		const locate = getLocator(this.original);
+		if (this.intro) mappings.advance(this.intro);
+		this.firstChunk.eachNext((chunk) => {
+			const loc = locate(chunk.start);
+			if (chunk.intro.length) mappings.advance(chunk.intro);
+			if (chunk.edited) mappings.addEdit(sourceIndex, chunk.content, loc, chunk.storeName ? names.indexOf(chunk.original) : -1);
+			else mappings.addUneditedChunk(sourceIndex, chunk, this.original, loc, this.sourcemapLocations);
+			if (chunk.outro.length) mappings.advance(chunk.outro);
+		});
+		if (this.outro) mappings.advance(this.outro);
+		return names;
+	}
+	/** @internal */
+	_mapProperties(options, names) {
+		return {
+			file: options.file ? options.file.split(/[/\\]/).pop() : void 0,
+			sources: [options.source ? getRelativePath(options.file || "", options.source) : options.file || ""],
+			sourcesContent: options.includeContent ? [this.original] : void 0,
+			names,
+			x_google_ignoreList: this.ignoreList ? [0] : void 0
+		};
+	}
+	/** @internal */
+	_ensureindentStr() {
+		if (this.indentStr === void 0) this.indentStr = guessIndent(this.original);
+	}
+	/** @internal */
+	_getRawIndentString() {
+		this._ensureindentStr();
+		return this.indentStr;
+	}
+	getIndentString() {
+		this._ensureindentStr();
+		return this.indentStr === null ? "	" : this.indentStr;
+	}
+	indent(indentStr, options) {
+		const pattern = /^[^\r\n]/gm;
+		if (isObject(indentStr)) {
+			options = indentStr;
+			indentStr = void 0;
+		}
+		if (indentStr === void 0) {
+			this._ensureindentStr();
+			indentStr = this.indentStr || "	";
+		}
+		if (indentStr === "") return this;
+		const resolvedIndentStr = indentStr;
+		options = options || {};
+		const isExcluded = {};
+		if (options.exclude) (typeof options.exclude[0] === "number" ? [options.exclude] : options.exclude).forEach((exclusion) => {
+			for (let i = exclusion[0]; i < exclusion[1]; i += 1) isExcluded[i] = true;
+		});
+		let shouldIndentNextCharacter = options.indentStart !== false;
+		const indentPiece = (str) => {
+			if (str === "") return str;
+			const indented = str.replace(pattern, (match, offset) => offset > 0 || shouldIndentNextCharacter ? `${resolvedIndentStr}${match}` : match);
+			shouldIndentNextCharacter = str[str.length - 1] === "\n";
+			return indented;
+		};
+		this.intro = indentPiece(this.intro);
+		let charIndex = 0;
+		let chunk = this.firstChunk;
+		const indentAt = (index) => {
+			shouldIndentNextCharacter = false;
+			if (index === chunk.start) chunk.appendRight(resolvedIndentStr);
+			else {
+				this._splitChunk(chunk, index);
+				chunk = chunk.next;
+				chunk.prependRight(resolvedIndentStr);
+			}
+		};
+		while (chunk) {
+			const end = chunk.end;
+			if (!isExcluded[chunk.start]) chunk.intro = indentPiece(chunk.intro);
+			if (chunk.edited) {
+				if (!isExcluded[charIndex]) chunk.content = indentPiece(chunk.content);
+			} else if (options.exclude) {
+				charIndex = chunk.start;
+				while (charIndex < end) {
+					if (!isExcluded[charIndex]) {
+						const char = this.original.charCodeAt(charIndex);
+						if (char === NEWLINE_CHAR) shouldIndentNextCharacter = true;
+						else if (char !== CR_CHAR && shouldIndentNextCharacter) indentAt(charIndex);
+					}
+					charIndex += 1;
+				}
+			} else {
+				charIndex = chunk.start;
+				while (charIndex < end) {
+					if (!shouldIndentNextCharacter) {
+						const nextLine = this.original.indexOf(n, charIndex);
+						if (nextLine === -1 || nextLine >= end) break;
+						shouldIndentNextCharacter = true;
+						charIndex = nextLine + 1;
+						continue;
+					}
+					const char = this.original.charCodeAt(charIndex);
+					if (char === NEWLINE_CHAR || char === CR_CHAR) {
+						charIndex += 1;
+						continue;
+					}
+					indentAt(charIndex);
+					charIndex += 1;
+				}
+			}
+			if (!isExcluded[chunk.end - 1]) chunk.outro = indentPiece(chunk.outro);
+			charIndex = chunk.end;
+			chunk = chunk.next;
+		}
+		this.outro = indentPiece(this.outro);
+		return this;
+	}
+	/** @internal */
+	insert() {
+		throw new MagicStringError("insert() is deprecated, use appendLeft() or prependRight()");
+	}
+	/** @internal */
+	insertLeft(index, content) {
+		if (!warned.insertLeft) {
+			console.warn("magicString.insertLeft(...) is deprecated. Use magicString.appendLeft(...) instead");
+			warned.insertLeft = true;
+		}
+		return this.appendLeft(index, content);
+	}
+	/** @internal */
+	insertRight(index, content) {
+		if (!warned.insertRight) {
+			console.warn("magicString.insertRight(...) is deprecated. Use magicString.prependRight(...) instead");
+			warned.insertRight = true;
+		}
+		return this.prependRight(index, content);
+	}
+	/**
+	* Moves the characters from `start` and `end` to `index`.
+	*
+	* `affinity` controls where the range is anchored at `index`. With the
+	* default `'right'`, it is inserted before the content that starts at `index`;
+	* with `'left'`, it is inserted after the content that ends at `index`. The
+	* two differ only when other content has already been moved to that boundary,
+	* mirroring the `appendLeft`/`appendRight` distinction.
+	*/
+	move(start, end, index, affinity = "right") {
+		start = start + this.offset;
+		end = end + this.offset;
+		index = index + this.offset;
+		if (start === end) return this;
+		if (index >= start && index <= end) throw new MagicStringError("cannot move a selection inside itself");
+		this._split(start);
+		this._split(end);
+		this._split(index);
+		const first = this.byStart.get(start);
+		const last = this.byEnd.get(end);
+		if (this.hasMovedChunks) {
+			let cursor = first;
+			while (cursor !== last) {
+				cursor = cursor.next;
+				if (!cursor || cursor.start < start || cursor.end > end) throw new MagicStringError(`cannot move ${start} to ${end} because an earlier move split that range`);
+			}
+		}
+		const oldLeft = first.previous;
+		const oldRight = last.next;
+		let newLeft;
+		let newRight;
+		if (affinity === "left") {
+			newLeft = this.byEnd.get(index) ?? null;
+			if (!newLeft) {
+				if (first === this.firstChunk) return this;
+				newRight = this.firstChunk;
+			} else {
+				if (newLeft.next === first) return this;
+				newRight = newLeft.next;
+			}
+		} else {
+			newRight = this.byStart.get(index) ?? null;
+			if (!newRight) {
+				if (last === this.lastChunk) return this;
+				newLeft = this.lastChunk;
+			} else {
+				if (newRight.previous === last) return this;
+				newLeft = newRight.previous;
+			}
+		}
+		if (oldLeft) oldLeft.next = oldRight;
+		if (oldRight) oldRight.previous = oldLeft;
+		if (newLeft) newLeft.next = first;
+		if (newRight) newRight.previous = last;
+		if (!first.previous) this.firstChunk = last.next;
+		if (!last.next) {
+			this.lastChunk = first.previous;
+			this.lastChunk.next = null;
+		}
+		first.previous = newLeft;
+		last.next = newRight || null;
+		if (!newLeft) this.firstChunk = first;
+		if (!newRight) this.lastChunk = last;
+		this.hasMovedChunks = true;
+		return this;
+	}
+	/**
+	* Replaces the characters from `start` to `end` with `content`, along with the appended/prepended content in
+	* that range. The same restrictions as `s.remove()` apply.
+	*
+	* The fourth argument is optional. It can have a storeName property - if true, the original name will be stored
+	* for later inclusion in a sourcemap's names array - and a contentOnly property which determines whether only
+	* the content is overwritten, or anything that was appended/prepended to the range as well.
+	*
+	* It may be preferred to use `s.update(...)` instead if you wish to avoid overwriting the appended/prepended content.
+	*/
+	overwrite(start, end, content, options) {
+		const optionObject = typeof options === "object" && options ? options : {};
+		return this.update(start, end, content, {
+			...optionObject,
+			overwrite: !optionObject.contentOnly
+		});
+	}
+	/**
+	* Replaces the characters from `start` to `end` with `content`. The same restrictions as `s.remove()` apply.
+	*
+	* The fourth argument is optional. It can have a storeName property - if true, the original name will be stored
+	* for later inclusion in a sourcemap's names array - and an overwrite property which determines whether only
+	* the content is overwritten, or anything that was appended/prepended to the range as well.
+	*/
+	update(start, end, content, options) {
+		start = start + this.offset;
+		end = end + this.offset;
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+		if (this.original.length !== 0) {
+			if (start < 0) start = Math.max(0, start + this.original.length);
+			if (end < 0) end = Math.max(0, end + this.original.length);
+		}
+		if (start < 0) throw new MagicStringError(`start ${start} is out of bounds`);
+		if (end > this.original.length) throw new MagicStringError(`end ${end} is out of bounds`);
+		if (start === end) throw new MagicStringError(`cannot overwrite a zero-length range at ${start}, use appendLeft() or prependRight()`);
+		if (start > end) throw new MagicStringError(`end must be greater than start (start: ${start}, end: ${end})`);
+		this._split(start);
+		this._split(end);
+		if (options === true) {
+			if (!warned.storeName) {
+				console.warn("The final argument to magicString.overwrite(...) should be an options object. See https://github.com/rich-harris/magic-string");
+				warned.storeName = true;
+			}
+			options = { storeName: true };
+		}
+		const optionObject = typeof options === "object" && options ? options : {};
+		const storeName = optionObject.storeName || false;
+		const overwrite = optionObject.overwrite || false;
+		if (storeName) {
+			const original = this.original.slice(start, end);
+			Object.defineProperty(this.storedNames, original, {
+				writable: true,
+				value: true,
+				enumerable: true
+			});
+		}
+		const first = this.byStart.get(start);
+		const last = this.byEnd.get(end);
+		/* v8 ignore else -- unreachable: a valid start/end always yields a `first` chunk */
+		if (first) {
+			let chunk = first;
+			while (chunk !== last) {
+				if (chunk.next !== this.byStart.get(chunk.end)) throw new MagicStringError("cannot overwrite across a split point");
+				chunk = chunk.next;
+				chunk.edit("", false, !overwrite);
+			}
+			first.edit(content, storeName, !overwrite);
+		} else {
+			const newChunk = new Chunk(start, end, "").edit(content, storeName);
+			last.next = newChunk;
+			newChunk.previous = last;
+		}
+		return this;
+	}
+	/**
+	* Prepends the string with the specified content.
+	*/
+	prepend(content) {
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+		this.intro = content + this.intro;
+		return this;
+	}
+	/**
+	* Same as `s.appendLeft(...)`, except that the inserted content will go *before* any previous appends or prepends at index
+	*/
+	prependLeft(index, content) {
+		index = index + this.offset;
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+		this._split(index);
+		const chunk = this.byEnd.get(index);
+		if (chunk) chunk.prependLeft(content);
+		else this.intro = content + this.intro;
+		return this;
+	}
+	/**
+	* Same as `s.appendRight(...)`, except that the inserted content will go *before* any previous appends or prepends at `index`
+	*/
+	prependRight(index, content) {
+		index = index + this.offset;
+		if (typeof content !== "string") throw new MagicStringError(`content must be a string, got ${typeof content}`);
+		this._split(index);
+		const chunk = this.byStart.get(index);
+		if (chunk) chunk.prependRight(content);
+		else this.outro = content + this.outro;
+		return this;
+	}
+	/**
+	* Removes the characters from `start` to `end` (of the original string, **not** the generated string).
+	* Content appended or prepended at positions strictly inside the range is removed with it, while
+	* content attached at `start` or `end` is preserved — use `s.overwrite(start, end, '')` to remove
+	* the range including its edge inserts.
+	* Repeated removals and removals with partially overlapping ranges are allowed.
+	*/
+	remove(start, end) {
+		start = start + this.offset;
+		end = end + this.offset;
+		if (this.original.length !== 0) {
+			if (start < 0) start = Math.max(0, start + this.original.length);
+			if (end < 0) end = Math.max(0, end + this.original.length);
+		}
+		if (start === end) return this;
+		if (start < 0 || end > this.original.length) throw new MagicStringError(`range ${start}–${end} is out of bounds`);
+		if (start > end) throw new MagicStringError(`end must be greater than start (start: ${start}, end: ${end})`);
+		this._split(start);
+		this._split(end);
+		let chunk = this.byStart.get(start);
+		while (chunk) {
+			if (chunk.start > start) chunk.intro = "";
+			if (chunk.end < end) chunk.outro = "";
+			chunk.edit("", false, true);
+			chunk = end > chunk.end ? this.byStart.get(chunk.end) : null;
+		}
+		return this;
+	}
+	/**
+	* Reset the modified characters from `start` to `end` (of the original string, **not** the generated string).
+	*/
+	reset(start, end) {
+		start = start + this.offset;
+		end = end + this.offset;
+		if (this.original.length !== 0) {
+			if (start < 0) start = Math.max(0, start + this.original.length);
+			if (end < 0) end = Math.max(0, end + this.original.length);
+		}
+		if (start === end) return this;
+		if (start < 0 || end > this.original.length) throw new MagicStringError(`range ${start}–${end} is out of bounds`);
+		if (start > end) throw new MagicStringError(`end must be greater than start (start: ${start}, end: ${end})`);
+		this._split(start);
+		this._split(end);
+		let chunk = this.byStart.get(start);
+		while (chunk) {
+			chunk.reset();
+			chunk = end > chunk.end ? this.byStart.get(chunk.end) : null;
+		}
+		return this;
+	}
+	lastChar() {
+		if (this.outro.length) return this.outro[this.outro.length - 1];
+		let chunk = this.lastChunk;
+		while (chunk) {
+			if (chunk.outro.length) return chunk.outro[chunk.outro.length - 1];
+			if (chunk.content.length) return chunk.content[chunk.content.length - 1];
+			if (chunk.intro.length) return chunk.intro[chunk.intro.length - 1];
+			chunk = chunk.previous;
+		}
+		if (this.intro.length) return this.intro[this.intro.length - 1];
+		return "";
+	}
+	lastLine() {
+		let lineIndex = this.outro.lastIndexOf(n);
+		if (lineIndex !== -1) return this.outro.substr(lineIndex + 1);
+		let lineStr = this.outro;
+		let chunk = this.lastChunk;
+		while (chunk) {
+			if (chunk.outro.length > 0) {
+				lineIndex = chunk.outro.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.outro.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.outro + lineStr;
+			}
+			if (chunk.content.length > 0) {
+				lineIndex = chunk.content.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.content.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.content + lineStr;
+			}
+			if (chunk.intro.length > 0) {
+				lineIndex = chunk.intro.lastIndexOf(n);
+				if (lineIndex !== -1) return chunk.intro.substr(lineIndex + 1) + lineStr;
+				lineStr = chunk.intro + lineStr;
+			}
+			chunk = chunk.previous;
+		}
+		lineIndex = this.intro.lastIndexOf(n);
+		if (lineIndex !== -1) return this.intro.substr(lineIndex + 1) + lineStr;
+		return this.intro + lineStr;
+	}
+	/**
+	* Returns the content of the generated string that corresponds to the slice between `start` and `end` of the original string.
+	* Throws error if the indices are for characters that were already removed.
+	*/
+	slice(start = 0, end = this.original.length - this.offset) {
+		start = start + this.offset;
+		end = end + this.offset;
+		if (this.original.length !== 0) {
+			if (start < 0) start = Math.max(0, start + this.original.length);
+			if (end < 0) end = Math.max(0, end + this.original.length);
+		}
+		let result = "";
+		let chunk = this.firstChunk;
+		while (chunk && (chunk.start > start || chunk.end <= start)) {
+			if (chunk.start < end && chunk.end >= end || end === 0 && chunk.start === 0) return result;
+			chunk = chunk.next;
+		}
+		if (chunk && chunk.edited && chunk.start !== start) throw new MagicStringError(`cannot use edited character ${start} as slice start anchor`);
+		const startChunk = chunk;
+		while (chunk) {
+			if (end === 0 && chunk.start === 0) break;
+			if (chunk.intro && (startChunk !== chunk || chunk.start === start)) result += chunk.intro;
+			const containsEnd = chunk.start < end && chunk.end >= end;
+			if (containsEnd && chunk.edited && chunk.end !== end) throw new MagicStringError(`cannot use edited character ${end} as slice end anchor`);
+			const sliceStart = startChunk === chunk ? start - chunk.start : 0;
+			const sliceEnd = containsEnd ? chunk.content.length + end - chunk.end : chunk.content.length;
+			result += chunk.content.slice(sliceStart, sliceEnd);
+			if (chunk.outro && (!containsEnd || chunk.end === end)) result += chunk.outro;
+			if (containsEnd) break;
+			chunk = chunk.next;
+		}
+		return result;
+	}
+	/**
+	* Returns a clone of `s`, with all content before the `start` and `end` characters of the original string removed.
+	*/
+	snip(start, end) {
+		const clone = this.clone();
+		clone.remove(0, start);
+		clone.remove(end, clone.original.length);
+		return clone;
+	}
+	/** @internal */
+	_split(index) {
+		if (this.byStart.get(index) || this.byEnd.get(index)) return;
+		let chunk = this.lastSearchedChunk;
+		let previousChunk = chunk;
+		const searchForward = index > chunk.end;
+		while (chunk) {
+			if (chunk.contains(index)) return this._splitChunk(chunk, index);
+			chunk = searchForward ? this.byStart.get(chunk.end) : this.byEnd.get(chunk.start);
+			if (chunk === previousChunk) return;
+			previousChunk = chunk;
+		}
+	}
+	/** @internal */
+	_splitChunk(chunk, index) {
+		if (chunk.edited && chunk.content.length) {
+			const loc = getLocator(this.original)(index);
+			throw new MagicStringError(`cannot split a chunk that has already been edited (${loc.line}:${loc.column} – "${chunk.original}")`);
+		}
+		const newChunk = chunk.split(index);
+		this.byEnd.set(index, chunk);
+		this.byStart.set(index, newChunk);
+		this.byEnd.set(newChunk.end, newChunk);
+		if (chunk === this.lastChunk) this.lastChunk = newChunk;
+		this.lastSearchedChunk = chunk;
+		return true;
+	}
+	/**
+	* Returns the generated string.
+	*/
+	toString() {
+		let str = this.intro;
+		let chunk = this.firstChunk;
+		while (chunk) {
+			str += chunk.toString();
+			chunk = chunk.next;
+		}
+		return str + this.outro;
+	}
+	/**
+	* Returns true if the resulting source is empty (disregarding white space).
+	*/
+	isEmpty() {
+		if (this.intro.length && this.intro.trim()) return false;
+		let chunk = this.firstChunk;
+		while (chunk) {
+			if (chunk.intro.length && chunk.intro.trim() || chunk.content.length && chunk.content.trim() || chunk.outro.length && chunk.outro.trim()) return false;
+			chunk = chunk.next;
+		}
+		if (this.outro.length && this.outro.trim()) return false;
+		return true;
+	}
+	length() {
+		let chunk = this.firstChunk;
+		let length = 0;
+		while (chunk) {
+			length += chunk.intro.length + chunk.content.length + chunk.outro.length;
+			chunk = chunk.next;
+		}
+		return length;
+	}
+	/**
+	* Removes empty lines from the start and end.
+	*/
+	trimLines() {
+		return this.trim("[\\r\\n]");
+	}
+	/**
+	* Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start and end.
+	*/
+	trim(charType) {
+		return this.trimStart(charType).trimEnd(charType);
+	}
+	/** @internal */
+	trimEndAborted(charType) {
+		const rx = new RegExp(`${charType || "\\s"}+$`);
+		this.outro = this.outro.replace(rx, "");
+		if (this.outro.length) return true;
+		let chunk = this.lastChunk;
+		do {
+			const end = chunk.end;
+			const aborted = chunk.trimEnd(rx);
+			if (chunk.end !== end) {
+				if (this.lastChunk === chunk) this.lastChunk = chunk.next;
+				this.byEnd.set(chunk.end, chunk);
+				this.byStart.set(chunk.next.start, chunk.next);
+				this.byEnd.set(chunk.next.end, chunk.next);
+			}
+			if (aborted) return true;
+			chunk = chunk.previous;
+		} while (chunk);
+		this.intro = this.intro.replace(rx, "");
+		return this.intro.length > 0;
+	}
+	/**
+	* Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the end.
+	*/
+	trimEnd(charType) {
+		this.trimEndAborted(charType);
+		return this;
+	}
+	/** @internal */
+	trimStartAborted(charType) {
+		const rx = new RegExp(`^${charType || "\\s"}+`);
+		this.intro = this.intro.replace(rx, "");
+		if (this.intro.length) return true;
+		let chunk = this.firstChunk;
+		do {
+			const end = chunk.end;
+			const aborted = chunk.trimStart(rx);
+			if (chunk.end !== end) {
+				if (chunk === this.lastChunk) this.lastChunk = chunk.next;
+				this.byEnd.set(chunk.end, chunk);
+				this.byStart.set(chunk.next.start, chunk.next);
+				this.byEnd.set(chunk.next.end, chunk.next);
+			}
+			if (aborted) return true;
+			chunk = chunk.next;
+		} while (chunk);
+		this.outro = this.outro.replace(rx, "");
+		return this.outro.length > 0;
+	}
+	/**
+	* Trims content matching `charType` (defaults to `\s`, i.e. whitespace) from the start.
+	*/
+	trimStart(charType) {
+		this.trimStartAborted(charType);
+		return this;
+	}
+	/**
+	* Indicates if the string has been changed.
+	*/
+	hasChanged() {
+		if (this.intro || this.outro) return true;
+		let outputIndex = 0;
+		let chunk = this.firstChunk;
+		while (chunk) {
+			if (chunk.intro || chunk.outro) return true;
+			if (!chunk.edited && chunk.start === outputIndex) outputIndex = chunk.end;
+			else {
+				if (!this.original.startsWith(chunk.content, outputIndex)) return true;
+				outputIndex += chunk.content.length;
+			}
+			chunk = chunk.next;
+		}
+		return outputIndex !== this.original.length;
+	}
+	/**
+	* Whether the original range [start, end) has had any of its characters
+	* removed. `replace`/`replaceAll` search `original`, so a match can land on
+	* text that is no longer in the output - overwriting it would resurrect the
+	* removed characters, so such matches are skipped instead.
+	*
+	* @internal
+	*/
+	_hasRemovedContent(start, end) {
+		let chunk = this.byStart.get(start);
+		if (!chunk) {
+			chunk = this.lastSearchedChunk;
+			const searchForward = start >= chunk.end;
+			while (chunk && !chunk.contains(start)) chunk = searchForward ? this.byStart.get(chunk.end) : this.byEnd.get(chunk.start);
+			if (chunk) this.lastSearchedChunk = chunk;
+		}
+		while (chunk && chunk.start < end) {
+			if (chunk.content === "") return true;
+			chunk = this.byStart.get(chunk.end);
+		}
+		return false;
+	}
+	/** @internal */
+	_replaceRegexp(searchValue, replacement) {
+		function getReplacement(match, str) {
+			if (typeof replacement === "string") return expandReplacement(replacement, match[0], match.index, str, match.slice(1), match.groups);
+			else return match.groups === void 0 ? replacement(match[0], ...match.slice(1), match.index, str) : replacement(match[0], ...match.slice(1), match.index, str, match.groups);
+		}
+		const replaceMatch = (match) => {
+			/* v8 ignore next 2 -- `match.index` is always defined for matches from `matchAll` */
+			if (match.index == null) return false;
+			if (this._hasRemovedContent(match.index, match.index + match[0].length)) return false;
+			const replacement = getReplacement(match, this.original);
+			if (replacement === match[0]) return true;
+			if (match[0].length === 0) this.appendRight(match.index - this.offset, replacement);
+			else this.overwrite(match.index - this.offset, match.index + match[0].length - this.offset, replacement);
+			return true;
+		};
+		if (searchValue.global) {
+			searchValue.lastIndex = 0;
+			for (const match of this.original.matchAll(searchValue)) replaceMatch(match);
+		} else {
+			const match = this.original.match(searchValue);
+			if (match && !replaceMatch(match)) {
+				const global = new RegExp(searchValue.source, `${searchValue.flags}g`);
+				for (const next of this.original.matchAll(global)) if (replaceMatch(next)) break;
+			}
+		}
+		return this;
+	}
+	/** @internal */
+	_replaceString(string, replacement) {
+		const { original } = this;
+		let index = original.indexOf(string);
+		while (index !== -1) {
+			if (this._hasRemovedContent(index, index + string.length)) {
+				index = original.indexOf(string, index + string.length);
+				continue;
+			}
+			if (typeof replacement === "function") replacement = replacement(string, index, original);
+			else replacement = expandReplacement(replacement, string, index, original, [], void 0);
+			if (string !== replacement) {
+				if (string.length === 0) this.appendRight(index - this.offset, replacement);
+				else this.overwrite(index - this.offset, index + string.length - this.offset, replacement);
+			}
+			break;
+		}
+		return this;
+	}
+	/**
+	* String replacement with RegExp or string.
+	*/
+	replace(searchValue, replacement) {
+		if (typeof searchValue === "string") return this._replaceString(searchValue, replacement);
+		return this._replaceRegexp(searchValue, replacement);
+	}
+	/** @internal */
+	_replaceAllString(string, replacement) {
+		const { original } = this;
+		const stringLength = string.length;
+		if (stringLength === 0) {
+			for (let index = 0; index <= original.length; index += 1) {
+				if (this._hasRemovedContent(index, index)) continue;
+				const _replacement = typeof replacement === "function" ? replacement("", index, original) : expandReplacement(replacement, "", index, original, [], void 0);
+				if (_replacement !== "") this.appendRight(index - this.offset, _replacement);
+			}
+			return this;
+		}
+		for (let index = original.indexOf(string); index !== -1; index = original.indexOf(string, index + stringLength)) {
+			if (this._hasRemovedContent(index, index + stringLength)) continue;
+			const previous = original.slice(index, index + stringLength);
+			const _replacement = typeof replacement === "function" ? replacement(previous, index, original) : expandReplacement(replacement, previous, index, original, [], void 0);
+			if (previous !== _replacement) this.overwrite(index - this.offset, index + stringLength - this.offset, _replacement);
+		}
+		return this;
+	}
+	/**
+	* Same as `s.replace`, but replace all matched strings instead of just one.
+	*/
+	replaceAll(searchValue, replacement) {
+		if (typeof searchValue === "string") return this._replaceAllString(searchValue, replacement);
+		if (!searchValue.global) throw new MagicStringError("replaceAll() requires a global RegExp");
+		return this._replaceRegexp(searchValue, replacement);
+	}
+};
+//#endregion
+//#region src/core/env.ts
+/**
+* Whether dev checks and messages run (PLAN §1, principle 4). Vite replaces
+* `import.meta.env.DEV` with a literal, so a production build drops every
+* `if (DEV)` branch and the messages in it (tests/production.test.ts checks
+* the bundle). Without Vite (plain Node, wrangler's esbuild, a CDN) `env` is
+* undefined, and the checks are off instead of throwing.
+*/
+const DEV = !!import.meta.env?.DEV;
+/**
+* Whether normalising a machine checks its config: in development, and in
+* the plugin's build-time compilation (M7), which runs this normaliser in
+* Node, where `import.meta.env` is undefined, and turns its errors into
+* build errors. Only {@link checkAlways} assigns it, and only the plugin
+* imports that, so an app's bundle never does and the bundler reads it as
+* `DEV`, dropping the checks from production builds as before.
+*/
+let CHECK = DEV;
+/** Turns the normaliser's checks on in this process: the plugin's build side only. */
+const checkAlways = () => void (CHECK = true);
+/**
+* Dev-only bookkeeping: how deep the running code is inside actions, so a
+* context write elsewhere can be named (D5). Only read and written behind
+* `DEV`, so production builds drop it.
+*/
+const dev = { acting: 0 };
+//#endregion
+//#region src/core/dev.ts
+/**
+* Dev errors and warnings (PLAN §4.11): each names the machine, what went
+* wrong and the fix, behind a code. Every caller sits behind `if (DEV)`, so
+* none of this reaches a production bundle.
+*/
+/** `[machine:CODE] name: message`. */
+const message = (code, machine, text) => `[machine:${code}] ${machine}: ${text}`;
+function fail(code, machine, text) {
+	throw new Error(message(code, machine, text));
+}
+/** Edit distance, for "did you mean". */
+function distance(a, b) {
+	let row = Array.from({ length: b.length + 1 }, (_, i) => i);
+	for (let i = 1; i <= a.length; i++) {
+		const next = [i];
+		for (let j = 1; j <= b.length; j++) next[j] = Math.min(row[j] + 1, next[j - 1] + 1, row[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+		row = next;
+	}
+	return row[b.length];
+}
+/** `; did you mean "closed"?` for the nearest of `options`, or "" when none is close. */
+function suggest(name, options) {
+	let best = "";
+	let score = Math.max(2, Math.floor(name.length / 3)) + 1;
+	for (const option of options) {
+		const d = distance(name.toLowerCase(), option.toLowerCase());
+		if (d < score) [best, score] = [option, d];
+	}
+	return best ? `; did you mean "${best}"?` : "";
+}
+/** Keys users bring from XState and Zag, with what they are called here. */
+const RENAMED = {
+	target: "to",
+	guard: "if",
+	cond: "if",
+	actions: "do",
+	effects: "effect",
+	onEntry: "entry",
+	onExit: "exit"
+};
+/** Fails on a key `config` should not have, naming the right one. */
+function checkKeys(config, allowed, machine, where) {
+	for (const key of Object.keys(config)) {
+		if (allowed.includes(key)) continue;
+		fail("UNKNOWN_KEY", machine, `${where} has an unknown key "${key}"${RENAMED[key] ? `; use "${RENAMED[key]}".` : suggest(key, allowed) || "."} Allowed: ${allowed.join(", ")}.`);
+	}
+}
+/** The DOM's spellings a part may not use, and React's, which every glue maps to its framework's. */
+const SPELLED = {
+	class: "className",
+	for: "htmlFor"
+};
+/**
+* Dev only: each part's handlers send an event some state handles, or are
+* functions; its keys are spelled as React spells them (`@menapo/glue/naming`).
+* Checked by the normaliser, so the plugin's compilation fails the build on
+* them, and when a compiled machine loads in development.
+*/
+function checkParts(config, name, handled) {
+	const parts = config.parts ?? {};
+	for (const part of Object.keys(parts)) for (const key of Object.keys(parts[part])) {
+		const value = parts[part][key];
+		if (/^on[A-Z]/.test(key)) {
+			if (typeof value !== "string" && typeof value !== "function") fail("BAD_HANDLER", name, `part "${part}" has ${key}: ${String(value)}; an on* key takes an event name or a function of (view, event).`);
+			if (typeof value === "string" && !handled.has(value)) fail("UNKNOWN_EVENT", name, `part "${part}" sends "${value}" from ${key}, which no state handles${suggest(value, handled) || "."} Handle it in a state's \`on\`, or send another event.`);
+		} else if (key in SPELLED || /^on[a-z]/.test(key)) fail("PART_KEY", name, `part "${part}" has "${key}"; parts use React's spellings, which each framework's glue maps to its own, so write "${SPELLED[key] ?? `on${key[2].toUpperCase()}${key.slice(3)}`}"${key in SPELLED ? "" : " with the event's words capitalised (onKeyDown, onDoubleClick)"}.`);
+	}
+}
+//#endregion
+//#region src/core/effects.ts
+const AFTER = { type: "machine.after" };
+/** An `after` timer: setTimeout's extra arguments spare a closure per timer. */
+function fire(instance, rules) {
+	if (!instance.b) instance.go(rules, AFTER);
+}
+/** `[state, cleanup or timer, …]`: what an instance keeps while its states are active. */
+const keep = (instance, at, item) => void (instance.r ??= []).push(at, item);
+/** `instance.b` once stopped (the interpreter's STOPPED). */
+const STOPPED = 2;
+/**
+* Sets the timers and starts the effects of `states`, entered in the event
+* that just settled and still active, while the instance is busy: what an
+* effect sends runs once all have started. The glue's component calls it
+* only once the framework has committed the DOM, and never on a server.
+*
+* An effect that stops the instance ends it: nothing after it starts, and
+* the cleanup it returns runs at once. An effect that throws does not keep
+* the others from starting: the event runs to completion and tells its
+* subscribers, then the first error is thrown.
+*/
+function activate(instance, states) {
+	let thrown;
+	for (const at of states) {
+		if (instance.b === STOPPED) break;
+		if (at.af) for (const [ms, rules] of at.af) keep(instance, at, setTimeout(fire, ms, instance, rules));
+		if (at.ef) for (const effect of at.ef) {
+			if (instance.b === STOPPED) break;
+			try {
+				const cleanup = effect(instance);
+				if (typeof cleanup === "function") {
+					if (instance.b === STOPPED) cleanup();
+					else keep(instance, at, cleanup);
+				}
+			} catch (error) {
+				thrown ??= [error];
+			}
+		}
+	}
+	if (thrown) {
+		instance.settle();
+		throw thrown[0];
+	}
+}
+/**
+* Stops what `instance` keeps for state `at`, latest first, and forgets it
+* if it waits to start; without `at` (the instance stops), everything. A
+* cleanup that throws does not keep the others from running: the first
+* error is thrown once all have.
+*/
+function release(instance, at) {
+	const { r, x } = instance;
+	let thrown;
+	if (!at) instance.r = instance.x = void 0;
+	else x?.splice(x.indexOf(at) >>> 0, 1);
+	if (r) {
+		for (let k = r.length - 2; k >= 0; k -= 2) if (!at || r[k] === at) {
+			const item = r.splice(k, 2)[1];
+			try {
+				if (typeof item === "function") item();
+				else clearTimeout(item);
+			} catch (error) {
+				thrown ??= [error];
+			}
+		}
+	}
+	if (thrown) throw thrown[0];
+}
+//#endregion
+//#region ../glue/src/record.ts
+/**
+* The record kit's state lives in (machine PLAN D5, spike S1; store PLAN
+* D3): values in an array behind one accessor per field, defined once per
+* key set on a class's prototype, and a change mask with one bit per field.
+* A read is a few ns, and no proxy or snapshot is involved. `@menapo/machine`
+* lays out context and props by `bit`, `@menapo/store` its stores by `bit`
+* and `defineAccessors`, so the bit layout exists once. Machine writes its
+* accessor loop out: the call cost its toggle's size gate 12 B.
+*
+* Read tracking stays with each owner: machine records one mask per
+* derived value, the store one mask per store a derived value read.
+*/
+/** The bit of field `n`: fields past the 31st share the last bit. */
+const bit = (n) => 1 << Math.min(n, 31);
+//#endregion
+//#region src/core/props.ts
+/** Marks a `bindable()` value and carries its {@link Control}. */
+const BOUND = Symbol();
+/**
+* Records each declared prop's default, and hands a `bindable()` one to its
+* {@link Control}: what the normaliser does, and a compiled machine at load.
+*/
+function bind(tables, props) {
+	tables.pn.forEach((prop, j) => {
+		const value = props[prop];
+		const control = value?.[BOUND];
+		tables.pd.push(control ? value.value : value);
+		if (control) (tables.k = control).bind(tables, j, prop, value, tables.Q.prototype);
+		else tables.pl.push(j);
+	});
+}
+/**
+* Takes the owner's props; a missing plain prop falls back to its default.
+* From `setProps` (`queue`): taken once the event being handled is done,
+* as one event of their own when none is, never once stopped.
+*/
+function own(instance, owner, queue) {
+	if (queue) {
+		if (instance.b !== 2) {
+			instance.n = owner;
+			if (!instance.b) instance.go(void 0, instance.event);
+		}
+		return;
+	}
+	const { M, props } = instance;
+	const previous = instance.o;
+	instance.o = owner;
+	for (const j of M.pl) {
+		const given = owner[M.pn[j]];
+		const value = given === void 0 ? M.pd[j] : given;
+		if (props.v[j] !== value) {
+			props.v[j] = value;
+			props.m |= bit(1 + M.nm.length - M.pn.length + j);
+		}
+	}
+	if (instance.s) M.k?.own(instance, previous);
+}
+//#endregion
+//#region src/core/store.ts
+/**
+* Context and props as objects with one accessor per field, defined once per
+* machine on a prototype (D5, spike S1), with the bit layout of
+* `@menapo/glue`'s record, which the store shares: a read is a few ns, a write that
+* changes the value sets the field's bit in a change mask, and no proxy or
+* snapshot is involved. Reads also record their bits while a derived value
+* is being computed, so it is recomputed only when what it read changes.
+*/
+/** Bits read since the innermost derived value started computing. */
+let reads = 0;
+const track = (bits) => {
+	reads |= bits;
+};
+/** Dev only: the name of the machine a store belongs to, for messages. */
+const nameOf$1 = (store) => store.i.M.name;
+/** A class with an accessor per name; `get(k)` and `set(k)` make each one's pair. */
+function accessors(names, get, set) {
+	class Values {
+		v;
+		m = 0;
+		i;
+		constructor(values, instance) {
+			this.v = values;
+			this.i = instance;
+		}
+	}
+	names.forEach((name, k) => {
+		Object.defineProperty(Values.prototype, name, {
+			configurable: true,
+			get: get(k),
+			set: set?.(k, name)
+		});
+	});
+	return Values;
+}
+/**
+* Context (`writable`) or props, over `this.v[k]`. Context is written by
+* actions only (D5: anywhere else throws in dev); props are the owner's,
+* and only bindable ones (which `bindable` redefines) can be written.
+*/
+function storeClass(names, first, writable) {
+	const Values = accessors(names, (k) => {
+		const mask = bit(first + k);
+		return function() {
+			reads |= mask;
+			return this.v[k];
+		};
+	}, (k, name) => {
+		const mask = bit(first + k);
+		return writable ? function(value) {
+			if (DEV && !dev.acting) fail("CONTEXT_WRITE", nameOf$1(this), `context.${name} was written outside an action. Write context in a transition's \`do\`, \`entry\` or \`exit\`, and send an event from here instead.`);
+			if (this.v[k] !== value) {
+				this.v[k] = value;
+				this.m |= mask;
+			}
+		} : DEV ? function() {
+			fail("PROPS_WRITE", nameOf$1(this), `props.${name} belongs to the owner and is read-only. Declare it \`${name}: bindable(…)\` to let actions write it.`);
+		} : void 0;
+	});
+	if (writable) Values.s = (machine, given) => {
+		const values = machine.df.slice();
+		if (given) for (const key of Object.keys(given)) {
+			const at = machine.nm.indexOf(key);
+			if (DEV && !(at >= 0 && at < values.length)) fail("UNKNOWN_FIELD", machine.name, `start() was given context.${key}, which the machine does not declare; add it to \`context\`.`);
+			values[at] = given[key];
+		}
+		return values;
+	};
+	return Values;
+}
+/**
+* The derived values' class: each getter returns the cached value while no
+* field it read has changed, else recomputes it with its reads recorded.
+* A value computed while a field it read is changed but not yet told is
+* recomputed on every read until the notification forgets it.
+*/
+function derivedClass(names, fns) {
+	const Derived = accessors(names, (k) => function() {
+		const c = this.v;
+		const instance = this.i;
+		const read = c[2 * k];
+		if (read === void 0 || read & instance.live()) {
+			const outer = reads;
+			reads = 0;
+			c[2 * k + 1] = fns[k](instance);
+			c[2 * k] = reads;
+			reads |= outer;
+		} else reads |= read;
+		return c[2 * k + 1];
+	});
+	/** Forgets the values that read what `changed` says changed: the interpreter calls it as it notifies. */
+	Derived.prototype.f = function(changed) {
+		const c = this.v;
+		for (let k = 0; k < c.length; k += 2) if (c[k] & changed) c[k] = void 0;
+	};
+	return Derived;
+}
+//#endregion
+//#region src/core/machine.ts
+/**
+* `defineMachine`: the config normalised once into tables (PLAN §5.2).
+* Each state becomes a record linked to its parent, numbered depth first
+* (so an ancestor's index is below its descendants'), with the leaf it
+* settles in when entered, its entry/exit/effect lists, `after` timers,
+* `always` rules and one `Map` from event name to what it does, its
+* ancestors' rules folded in after its own (D20).
+*/
+const STATE_KEYS = [
+	"initial",
+	"states",
+	"on",
+	"entry",
+	"exit",
+	"effect",
+	"after",
+	"always",
+	"type",
+	"done"
+];
+const MACHINE_KEYS = [
+	"name",
+	"context",
+	"props",
+	"events",
+	"derived",
+	"actions",
+	"guards",
+	"effects",
+	"initial",
+	"states",
+	"on",
+	"parts",
+	"expose"
+];
+const RULE_KEYS = [
+	"to",
+	"if",
+	"do"
+];
+const list = (value) => value === void 0 || Array.isArray(value) ? value : [value];
+const NOTHING = /* @__PURE__ */ new Map();
+/**
+* False while the plugin's compilation (M7) normalises at build time, so the
+* tables it emits hold data only and the features' runtimes wire them when
+* the compiled machine loads. Only {@link prepared} assigns it, and only the
+* plugin imports that, so an app's bundle reads it as `true`.
+*/
+let wiring = true;
+/** `normalise(config)` without the features' wiring: the plugin's build side only. */
+function prepared(config) {
+	wiring = false;
+	try {
+		return normalise(config);
+	} finally {
+		wiring = true;
+	}
+}
+/** Config → tables: what `defineMachine` does at runtime, and the plugin at build time ({@link prepared}). */
+function normalise(config) {
+	const name = CHECK ? config.name ?? "machine" : "";
+	const byPath = /* @__PURE__ */ new Map();
+	const states = [];
+	const root = {
+		i: -1,
+		path: ""
+	};
+	/** The raw config of `root`, then of each state. */
+	const raws = [config];
+	if (CHECK) checkKeys(config, MACHINE_KEYS, name, "the machine");
+	const where = (from) => from === root ? "the machine" : `"${from.path}"`;
+	const below = (up, key) => up === root ? key : `${up.path}.${key}`;
+	/** Dev only: the state and target being resolved, for `find`'s message; set before each call. */
+	let asked = [root, ""];
+	const find = (path) => {
+		const found = byPath.get(path);
+		if (CHECK && !found && asked[1] !== void 0) {
+			const [from, target] = asked;
+			const last = (p) => p.slice(p.lastIndexOf(".") + 1);
+			fail("UNKNOWN_TARGET", name, `${where(from)} → "${target}" does not exist${suggest(last(path), [...byPath.keys()].map(last)) || `; the states are ${[...byPath.keys()].map((p) => `"${p}"`).join(", ")}.`}`);
+		}
+		return found;
+	};
+	/**
+	* Named implementations (D8), in one map: the types keep each kind's
+	* names apart, and development rejects a name used in the wrong kind or
+	* declared in two.
+	*/
+	const named = {
+		...config.actions,
+		...config.guards,
+		...config.effects
+	};
+	if (CHECK) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const kind of [
+			"actions",
+			"guards",
+			"effects"
+		]) for (const key of Object.keys(config[kind] ?? {})) {
+			if (seen.has(key)) fail("NAME_CLASH", name, `"${key}" is declared in \`${kind}\` and in another of \`actions\`, \`guards\` and \`effects\`; give each its own name.`);
+			seen.add(key);
+		}
+	}
+	/** Functions as written, or the ones they name. */
+	const fns = (value) => value && list(value).map((f) => typeof f === "string" ? named[f] : f);
+	/** Dev only: each name in `value` is one of `config[kind]`. */
+	const known = (value, kind, from) => {
+		for (const f of list(value) ?? []) if (typeof f !== "function" && !config[kind]?.[f]) fail("UNKNOWN_NAME", name, `${where(from)} names "${String(f)}", which is not in \`${kind}\`${suggest(String(f), Object.keys(config[kind] ?? {})) || "."} Declare it in \`${kind}\`, or write the function in place.`);
+	};
+	/** Numbers `up`'s children depth first, then sets the leaf entering `up` settles in. */
+	const walk = (up, raw) => {
+		const children = raw.states;
+		if (children) {
+			for (const key of Object.keys(children)) {
+				const child = children[key];
+				const state = {
+					i: states.length,
+					path: below(up, key),
+					up,
+					fi: child.type === "final"
+				};
+				if (CHECK) {
+					if (/[.#]/.test(key)) fail("STATE_NAME", name, `state "${key}" has a "." or "#" in its name; targets use them as separators, so rename it.`);
+					checkKeys(child, STATE_KEYS, name, `state "${state.path}"`);
+					const type = child.type;
+					if (type !== void 0 && type !== "final" && typeof type !== "object") fail("BAD_TYPE", name, `"${state.path}" has \`type: ${JSON.stringify(type)}\`; a state's type is "final", or \`parallel\` imported from @menapo/machine (\`type: parallel\`).`);
+				}
+				byPath.set(state.path, state);
+				states.push(state);
+				raws.push(child);
+				walk(state, child);
+			}
+			if (CHECK && raw.initial === void 0 && typeof raw.type !== "object") fail("NO_INITIAL", name, `${up === root ? "the machine has no" : `"${up.path}" has child states but no`} \`initial\`; name one of: ${Object.keys(children).join(", ")}.`);
+		}
+		if (CHECK) asked = [up, raw.initial];
+		up.lf = children ? find(below(up, raw.initial))?.lf : up;
+	};
+	walk(root, config);
+	/** `#path` from the root, `.child` below `from`, else a sibling of `from` or of its nearest ancestor that has one. */
+	const resolve = (target, from) => {
+		if (CHECK) asked = [from, target];
+		if (target[0] === "#") return find(target.slice(1));
+		if (target[0] === ".") return find(below(from, target.slice(1)));
+		for (let up = from.up; up && up !== root; up = up.up) {
+			const found = byPath.get(`${up.path}.${target}`);
+			if (found) return found;
+		}
+		return find(target);
+	};
+	const rules = (transitions, from) => list(transitions).map((item) => {
+		if (CHECK && (typeof item !== "object" || item === null) && typeof item !== "string" && typeof item !== "function") fail("BAD_TRANSITION", name, `${where(from)} has a transition that is ${String(item)}; write a target name, an action, or { to, if, do }.`);
+		const rule = typeof item === "string" ? { to: item } : typeof item === "function" ? { do: item } : item;
+		if (CHECK) {
+			checkKeys(rule, RULE_KEYS, name, `a transition in ${where(from)}`);
+			known(rule.if, "guards", from);
+			known(rule.do, "actions", from);
+			if (rule.to === "") resolve("", from);
+		}
+		return {
+			to: rule.to && resolve(rule.to, from),
+			if: rule.if && fns(rule.if)[0],
+			do: fns(rule.do)
+		};
+	});
+	const handled = /* @__PURE__ */ new Set();
+	[root, ...states].forEach((state, k) => {
+		const raw = raws[k];
+		const up = state.up;
+		const inherited = up?.on ?? NOTHING;
+		let on = state.fi ? NOTHING : inherited;
+		if (raw.on && !state.fi) {
+			const folded = on = new Map(inherited);
+			for (const type of Object.keys(raw.on)) {
+				if (CHECK) {
+					const declared = config.events;
+					if (declared && !(type in declared)) fail("UNKNOWN_EVENT", name, `${where(state)} handles "${type}", which is not in \`events\`${suggest(type, Object.keys(declared)) || "."} Declare it in \`events\`.`);
+					handled.add(type);
+				}
+				const mine = rules(raw.on[type], state);
+				const outer = inherited.get(type);
+				folded.set(type, {
+					ev: outer?.ev ?? { type },
+					ru: outer ? mine.concat(outer.ru) : mine
+				});
+			}
+		}
+		if (CHECK) {
+			if (raw.done && raw.type?.kind !== "parallel") fail("DONE_KEY", name, `${where(state)} has \`done\`, which is taken when every region of a parallel state is final; give the state \`type: parallel\`, or use \`always\`.`);
+		}
+		if (CHECK && state.fi) {
+			const region = up !== root && (raws[up.up.i + 1]?.type)?.kind;
+			if (up !== root && region !== "parallel") fail("FINAL_STATE", name, `"${state.path}" is final but not top-level; a final state ends the machine at the top level, or a region of a parallel state, so move it or drop \`type: "final"\`.`);
+			for (const key of [
+				"states",
+				"on",
+				"effect",
+				"after",
+				"always"
+			]) if (raw[key]) fail("FINAL_STATE", name, `final state "${state.path}" has \`${key}\`, but the machine stops there; move it to another state.`);
+		}
+		const always = raw.always && rules(raw.always, state);
+		const after = raw.after;
+		state.on = on;
+		if (CHECK) {
+			known(raw.entry, "actions", state);
+			known(raw.exit, "actions", state);
+			known(raw.effect, "effects", state);
+		}
+		state.en = fns(raw.entry);
+		state.ex = fns(raw.exit);
+		state.ef = fns(raw.effect);
+		state.af = after && Object.keys(after).map((ms) => {
+			if (CHECK && !(Number(ms) >= 0)) fail("BAD_DELAY", name, `"${state.path}" has \`after: { ${ms}: … }\`; a delay is a number of milliseconds.`);
+			return [+ms, rules(after[ms], state)];
+		});
+		state.al = always && up?.al ? always.concat(up.al) : always || up?.al;
+	});
+	if (CHECK) checkParts(config, name, handled);
+	const context = config.context ?? {};
+	const fields = Object.keys(context);
+	const defaults = Object.values(context);
+	if (CHECK) {
+		for (const value of defaults) if (Array.isArray(value) || Object.getPrototypeOf(value ?? 0) === Object.prototype) Object.freeze(value);
+	}
+	const props = config.props ?? {};
+	const propNames = Object.keys(props);
+	const Props = propNames.length ? storeClass(propNames, 1 + fields.length, false) : void 0;
+	const derived = config.derived;
+	const tables = {
+		ss: states,
+		i0: root.lf,
+		df: defaults,
+		C: fields.length ? storeClass(fields, 1, true) : void 0,
+		pn: propNames,
+		pd: [],
+		Q: Props,
+		pl: [],
+		nm: fields.concat(propNames),
+		D: derived && derivedClass(Object.keys(derived), Object.values(derived)),
+		k: void 0,
+		bd: [],
+		c: config,
+		r: normalise,
+		A: activate,
+		X: release,
+		P: own
+	};
+	if (CHECK) Object.assign(tables, {
+		name,
+		handled
+	});
+	bind(tables, props);
+	for (const raw of raws) raw.type?.f?.(tables, raws, rules);
+	return tables;
+}
+Object.freeze({});
+function run(fns, view) {
+	if (fns) {
+		if (DEV) dev.acting++;
+		for (const fn of fns) fn(view);
+		if (DEV) dev.acting--;
+	}
+}
+//#endregion
+//#region src/core/bindable.ts
+/**
+* `bindable`: a prop the owner may control or leave to the machine (D9, as
+* spike S2 refined it). One transition serves both modes:
+*
+* - uncontrolled, the machine moves or stores the value and tells the owner
+*   through `on…Change`;
+* - controlled, a transition that would change the value runs its actions
+*   when the event is handled and asks the owner; only the move waits. When
+*   the owner's new value arrives, the machine takes the waiting transition's
+*   target, and the target's entry sees the event that asked. Props that do
+*   not grant it drop it (a veto); an owner that changes the value unasked
+*   moves the machine to the matching state.
+*
+* All of it lives here and reaches the core only through the
+* {@link Control} a `bindable()` value carries, so an app that never imports
+* `bindable` ships none of it.
+*/
+/** What entry actions see when the owner moves a bound boolean unasked. */
+const PROPS = { type: "machine.props" };
+/**
+* A controlled-or-uncontrolled prop: `open: bindable(false, { states: {
+* true: "open", false: "closed" } })` gives the owner `open`, `defaultOpen`
+* and `onOpenChange`; `value: bindable("")` is data that actions write as
+* `props.value = next`.
+*/
+const bindable = (value, options) => ({
+	[BOUND]: control,
+	value,
+	...options
+});
+const capital = (name) => name[0].toUpperCase() + name.slice(1);
+/** True when leaf `at` is inside `state`. */
+function inside$1(at, state) {
+	for (; at; at = at.up) if (at === state) return true;
+	return false;
+}
+const bounds = (machine) => machine.bd;
+const control = {
+	bind(machine, prop, name, bindable, proto) {
+		const { states, changed } = bindable;
+		const find = (path) => {
+			const state = machine.ss.find((s) => s.path === path);
+			if (CHECK && !state) fail("UNKNOWN_TARGET", machine.name, `bindable "${name}" names state "${path}", which does not exist; use a path from the root: ${machine.ss.map((s) => `"${s.path}"`).join(", ")}.`);
+			return state;
+		};
+		if (CHECK && changed !== void 0 && !machine.handled.has(changed)) {
+			const handled = [...machine.handled];
+			fail("UNKNOWN_EVENT", machine.name, `bindable "${name}" sends "${changed}" when the owner changes it, but no state handles it${suggest(changed, handled) || "."} Handle it in a state's \`on\`, or name an event one does.`);
+		}
+		const b = {
+			prop,
+			name,
+			bit: bit(1 + machine.nm.length - machine.pn.length + prop),
+			default: `default${capital(name)}`,
+			change: `on${capital(name)}Change`,
+			yes: states && find(states.true),
+			no: states && find(states.false),
+			changed
+		};
+		bounds(machine).push(b);
+		Object.defineProperty(proto, name, {
+			get() {
+				const instance = this.i;
+				track(b.bit);
+				const given = instance.o[name];
+				if (given !== void 0) return given;
+				if (!b.yes) return this.v[prop];
+				track(1);
+				return inside$1(instance.s, b.yes);
+			},
+			set(value) {
+				const owner = this.i.o;
+				if (DEV) {
+					if (b.yes) fail("BOUND_WRITE", machine.name, `props.${name} follows the state; move to "${b.yes.path}" or "${b.no.path}" instead of writing it.`);
+					if (!dev.acting) fail("CONTEXT_WRITE", machine.name, `props.${name} was written outside an action. Write it in a transition's \`do\`, \`entry\` or \`exit\`, and send an event from here instead.`);
+				}
+				const controlled = owner[name] !== void 0;
+				if ((controlled ? owner[name] : this.v[prop]) === value) return;
+				if (!controlled) {
+					this.v[prop] = value;
+					this.m |= b.bit;
+				}
+				owner[b.change]?.(value);
+			}
+		});
+	},
+	initial(instance, leaf) {
+		const owner = instance.o;
+		for (const b of bounds(instance.M)) {
+			const given = owner[b.name] !== void 0 ? owner[b.name] : owner[b.default];
+			if (given === void 0) continue;
+			if (!b.yes) instance.props.v[b.prop] = given;
+			else if (!!given !== inside$1(leaf, b.yes)) leaf = (given ? b.yes : b.no).lf;
+		}
+		return leaf;
+	},
+	hold(instance, rule) {
+		for (const b of bounds(instance.M)) {
+			if (!b.yes || instance.o[b.name] === void 0) continue;
+			const next = inside$1(rule.to.lf, b.yes);
+			if (inside$1(instance.s, b.yes) === next) continue;
+			run(rule.do, instance);
+			instance.p = {
+				to: rule.to,
+				event: instance.event,
+				b
+			};
+			instance.o[b.change]?.(next);
+			return true;
+		}
+		return false;
+	},
+	moved(instance, from) {
+		for (const b of bounds(instance.M)) {
+			if (!b.yes || instance.o[b.name] !== void 0) continue;
+			const now = inside$1(instance.s, b.yes);
+			if (now !== inside$1(from, b.yes)) {
+				instance.props.m |= b.bit;
+				instance.o[b.change]?.(now);
+			}
+		}
+	},
+	own(instance, previous) {
+		for (const b of bounds(instance.M)) {
+			const value = instance.o[b.name];
+			if (value !== previous[b.name]) {
+				instance.props.m |= b.bit;
+				if (b.changed && value !== void 0) instance.dispatch({
+					type: b.changed,
+					value
+				});
+			}
+			if (!b.yes) continue;
+			const pending = instance.p?.b === b ? instance.p : void 0;
+			if (pending) instance.p = void 0;
+			if (value === void 0 || !!value === inside$1(instance.s, b.yes)) continue;
+			if (pending && inside$1(pending.to.lf, b.yes) === !!value) {
+				instance.event = pending.event;
+				instance.move(pending.to, void 0);
+			} else {
+				instance.event = PROPS;
+				instance.move(value ? b.yes : b.no, void 0);
+			}
+		}
+	}
+};
+//#endregion
+//#region src/features/marks.ts
+/** The feature's mark on a raw state config, if it has one. */
+const markOf = (raw) => typeof raw?.type === "object" ? raw.type : void 0;
+//#endregion
+//#region src/features/records.ts
+const records = /* @__PURE__ */ new WeakMap();
+const recorded = (instance, history) => records.get(instance)?.get(history);
+function record(instance, history, states) {
+	let map = records.get(instance);
+	if (!map) records.set(instance, map = /* @__PURE__ */ new Map());
+	map.set(history, states);
+}
+//#endregion
+//#region src/features/resume.ts
+function wireHistory(tables) {
+	const states = tables.ss;
+	const histories = states.filter((s) => s.h !== void 0);
+	/** History state → the state its parent enters when nothing is recorded yet: its initial child. */
+	const initial = /* @__PURE__ */ new Map();
+	for (const h of histories) {
+		const parent = h.up;
+		let child = parent.lf;
+		while (child.up !== parent) child = child.up;
+		initial.set(h, child);
+		const deep = h.h;
+		const keep = (view) => {
+			const leaf = view.s;
+			let child = leaf;
+			while (child.up !== parent) child = child.up;
+			record(view, h, [deep ? leaf : child]);
+		};
+		parent.ex = [keep, ...parent.ex ?? []];
+	}
+	const all = /* @__PURE__ */ new Set();
+	for (const state of [states[0].up, ...states]) {
+		for (const handler of state.on.values()) for (const rule of handler.ru) all.add(rule);
+		for (const rule of state.al ?? []) all.add(rule);
+		for (const [, rules] of state.af ?? []) for (const rule of rules) all.add(rule);
+	}
+	for (const rule of all) {
+		const h = rule.to;
+		if (!h || !initial.has(h)) continue;
+		const guard = rule.if;
+		const routed = rule;
+		routed.h = h;
+		routed.if = (view) => (!guard || guard(view)) && !!(routed.to = recorded(view, h)?.[0] ?? initial.get(h));
+	}
+}
+//#endregion
+//#region src/features/history.ts
+/**
+* `history()` (PLAN §4.9): a pseudo-state that stands for where its parent
+* was when last exited. A transition to it enters that again: the parent's
+* active child (shallow, its own initial states below it) or its active
+* leaves (`history("deep")`); before the parent was ever exited, the
+* parent's initial state. It is never active itself.
+*
+* Its mark carries what prepares a machine's tables, which the normaliser
+* calls when it meets the mark: each history state is marked (`h`: deep or
+* not) and checked; `resume.ts` wires them. Importing it has no effect. A
+* machine with parallel states leaves both to `parallel`'s configurations,
+* which read the same marker and the same records. A compiled machine (M7)
+* has its tables prepared at build time, so it ships `resume.ts` alone.
+*/
+/** The machines whose history states are prepared. */
+const done = /* @__PURE__ */ new WeakSet();
+/** Prepares a machine's history states, then wires them: what the marks carry. */
+const prepare$1 = (tables, raws) => {
+	if (done.has(tables) || raws.some((raw) => markOf(raw)?.kind === "parallel")) return;
+	done.add(tables);
+	tables.ss.forEach((state, k) => {
+		const mark = markOf(raws[k + 1]);
+		if (mark?.kind !== "history") return;
+		const parent = state.up;
+		if (CHECK) {
+			if (parent.i < 0) fail("HISTORY", tables.name, `"${state.path}" is a history state of the machine itself, which is never exited; put it inside the state whose history it keeps.`);
+			if (`${parent.path}.${raws[parent.i + 1].initial}` === state.path) fail("HISTORY", tables.name, `"${parent.path}" starts in its history state "${state.path}"; make another state its \`initial\`.`);
+		}
+		state.h = !!mark.deep;
+	});
+	if (wiring) wireHistory(tables);
+};
+const SHALLOW = /* @__PURE__ */ Object.freeze({
+	kind: "history",
+	deep: false,
+	f: prepare$1
+});
+const DEEP = /* @__PURE__ */ Object.freeze({
+	kind: "history",
+	deep: true,
+	f: prepare$1
+});
+/**
+* A history pseudo-state: `resume: history()` returns to the child its
+* parent was last in, `history("deep")` to the very states inside it.
+*/
+const history = (type) => ({ type: type === "deep" ? DEEP : SHALLOW });
+//#endregion
+//#region src/features/chart.ts
+/**
+* The runtime of `type: parallel` (PLAN §4.9, D12): what a machine with
+* parallel states runs on, wired by {@link wireParallel} once its tables are
+* prepared (`parallel.ts`, which the normaliser runs, or the plugin at build
+* time for a compiled machine, M7). Only a machine that declares a parallel
+* state ships this module.
+*
+* The core keeps one leaf (`instance.s`). In a machine with parallel
+* states that leaf is a configuration: an object shaped like a state, one
+* per set of active states, made once per machine and reused, whose `path`
+* lists the active leaves, whose `on` holds every event an active state
+* handles, and whose `up` chain names every active state for `is()`. Each
+* of its handlers is one rule whose guard selects the transitions (SCXML's
+* selection: per active leaf in document order, its own handler first,
+* then its ancestors'; of two whose exits overlap, the one declared deeper,
+* else the earlier) and whose action takes them all as one microstep:
+* exits in reverse document order, the transitions' actions, entries in
+* document order. The core's own `move` is never used; it runs the queue,
+* `always`, timers, effects and notifications as for any machine.
+*
+* Where a transition's exits stop is the core's rule: at the nearest common
+* ancestor of the leaf it was found from and the target's parent, so a
+* transition into a state's own subtree never exits that state; when that
+* ancestor is parallel, the next one up, so every region is left together.
+*
+* A region whose active child is a `type: "final"` state is done; when
+* every region of a parallel state is, the state's `done` transition is
+* taken after the event that finished it (an internal `machine.done`).
+* History states inside parallel machines are handled here too, with the
+* records `history` keeps.
+*/
+const DONE = { type: "machine.done" };
+/** Each parallel machine's chart, by its tables. */
+const charts = /* @__PURE__ */ new WeakMap();
+/** `at` strictly inside `up`: depth-first numbering puts a subtree in one range. */
+const inside = (at, up) => at.i > up.i && at.i <= up.e;
+/** What a leaf takes events through: a final state in a region has none of its own, its region's apply. */
+const handlersOf = (chart, leaf) => leaf.fi && leaf.up !== chart.r ? leaf.up.on : leaf.on;
+const configOf = (instance) => instance.s;
+/** The configuration of these active states (document order), made once per machine. */
+function configuration(chart, a) {
+	const key = a.map((s) => s.i).join();
+	let made = chart.m.get(key);
+	if (!made) {
+		const l = a.filter((s, k) => !(a[k + 1] && inside(a[k + 1], s)));
+		let up;
+		for (const s of a) up = {
+			path: s.path,
+			up
+		};
+		const on = /* @__PURE__ */ new Map();
+		for (const leaf of l) for (const [type, handler] of handlersOf(chart, leaf)) if (!on.has(type)) on.set(type, {
+			ev: handler.ev,
+			ru: chart.e
+		});
+		if (a.some((s) => s.dn)) on.set(DONE.type, {
+			ev: DONE,
+			ru: chart.f
+		});
+		chart.m.set(key, made = {
+			i: -2,
+			path: l.map((s) => s.path).join(" "),
+			up,
+			fi: l.length === 1 && l[0].fi && l[0].up === chart.r,
+			on,
+			al: l.some((s) => s.al) ? chart.a : void 0,
+			a,
+			l
+		});
+	}
+	return made;
+}
+/**
+* The transitions a guard selected, read by the action right after it: the
+* core runs a rule's action as soon as its guard passed (`take`), so one
+* module binding is enough.
+*/
+let picked = [];
+/**
+* Keeps the transitions found (rule, leaf, …) that SCXML would: one per
+* rule, and of two whose exits overlap the one declared deeper, else the
+* earlier. True when any is left, kept in {@link picked}.
+*/
+function choose(instance, found) {
+	const taken = [];
+	next: for (let k = 0; k < found.length; k += 2) {
+		const rule = found[k];
+		const leaf = found[k + 1];
+		if (taken.some((t) => t[0] === rule)) continue;
+		let domain;
+		if (rule.to) {
+			domain = leaf;
+			let b = rule.to.up;
+			while (domain !== b) if (domain.i > b.i) domain = domain.up;
+			else b = b.up;
+			while (domain.p) domain = domain.up;
+		}
+		const exits = domain ? configOf(instance).a.filter((s) => inside(s, domain)) : [];
+		for (let j = 0; j < taken.length; j++) {
+			const other = taken[j];
+			if (!exits.some((s) => other[2].includes(s))) continue;
+			if (inside(rule.s ?? leaf, other[0].s ?? leaf)) taken.splice(j--, 1);
+			else continue next;
+		}
+		taken.push([
+			rule,
+			domain,
+			exits
+		]);
+	}
+	picked = taken;
+	return taken.length > 0;
+}
+/** Pushes the first rule of `rules` whose guard passes, found from `leaf`. */
+function first(instance, rules, leaf, found) {
+	for (const rule of rules) if (!rule.if || rule.if(instance)) return found.push(rule, leaf);
+}
+/** Per active leaf, its first transition for the event being handled, or (`always`) its first eventless one. */
+function pick(chart, instance, always) {
+	const found = [];
+	for (const leaf of configOf(instance).l) {
+		const rules = always ? leaf.al : handlersOf(chart, leaf).get(instance.event.type)?.ru;
+		if (rules) first(instance, rules, leaf, found);
+	}
+	return choose(instance, found);
+}
+/** A state's own rules (a timer's, a `done`): taken from the first active leaf inside it. */
+function pickFrom(instance, rules, state) {
+	const { a, l } = configOf(instance);
+	const found = [];
+	if (a.includes(state)) first(instance, rules, l.find((s) => s === state || inside(s, state)), found);
+	return choose(instance, found);
+}
+/** A rule whose guard picks the transitions and whose action takes them. */
+const routed = (pick) => ({
+	to: void 0,
+	if: pick,
+	do: [step]
+});
+/** The action of every configuration rule: the microstep of what its guard picked. */
+const step = (view) => {
+	const instance = view;
+	const taken = picked;
+	const { a, l } = configOf(instance);
+	const exits = /* @__PURE__ */ new Set();
+	for (const t of taken) for (const s of t[2]) exits.add(s);
+	for (const s of exits) for (const h of s.hs) record(instance, h, h.h ? l.filter((leaf) => inside(leaf, s)) : a.filter((c) => c.up === s));
+	for (const s of [...exits].sort((x, y) => y.i - x.i)) instance.exit(s);
+	for (const t of taken) run(t[0].do, instance);
+	const enter = /* @__PURE__ */ new Set();
+	for (const [rule, domain] of taken) if (rule.to) {
+		descend(instance, rule.to, enter);
+		ascend(instance, rule.to, domain, enter);
+	}
+	settle(instance, a.filter((s) => !exits.has(s)), enter);
+};
+/** Adds `state` and what entering it enters (SCXML's addDescendantStatesToEnter). */
+function descend(instance, state, enter) {
+	if (state.h !== void 0) {
+		const parent = state.up;
+		const states = recorded(instance, state) ?? (parent.p ? parent.k : [parent.n]);
+		for (const s of states) descend(instance, s, enter);
+		for (const s of states) ascend(instance, s, parent, enter);
+	} else {
+		enter.add(state);
+		if (state.p) for (const region of state.k) regions(instance, region, enter);
+		else if (state.n) descend(instance, state.n, enter);
+	}
+}
+/** Enters `region` by default unless a state in it is entered already. */
+function regions(instance, region, enter) {
+	for (const s of enter) if (s === region || inside(s, region)) return;
+	descend(instance, region, enter);
+}
+/** Adds the ancestors of `state` below `stop`, and the other regions of the parallel ones. */
+function ascend(instance, state, stop, enter) {
+	for (let up = state.up; up !== stop && up.i >= 0; up = up.up) {
+		enter.add(up);
+		if (up.p) for (const region of up.k) regions(instance, region, enter);
+	}
+}
+/**
+* Enters the new states in document order, each added to the configuration
+* just before its entry actions run (so `is()` there sees it and its
+* ancestors, not what is entered after it, as in the core): their timers
+* and effects start once the event settles, and a final state that
+* completes a parallel state queues that state's `done`.
+*/
+function settle(instance, kept, enter) {
+	const chart = charts.get(instance.M);
+	let active = kept;
+	instance.s = configuration(chart, active);
+	for (const s of [...enter].sort((x, y) => x.i - y.i)) {
+		active = [...active, s].sort((x, y) => x.i - y.i);
+		instance.s = configuration(chart, active);
+		instance.d = 1;
+		run(s.en, instance);
+		if (s.af || s.ef) (instance.x ??= []).push(s);
+		const done = s.fi && s.up.up?.dn;
+		if (done && !instance.q?.includes(done.event) && complete(instance, s.up.up)) {
+			const q = instance.q ??= [];
+			let k = 0;
+			while (k < q.length && chart.d.has(q[k])) k++;
+			q.splice(k, 0, done.event);
+		}
+	}
+}
+/** SCXML's isInFinalState: a compound state whose active child is final, a parallel one whose regions all are. */
+const complete = (instance, state) => state.p ? state.k.every((region) => complete(instance, region)) : configOf(instance).a.some((s) => s.up === state && s.fi);
+/** The runtime of a machine whose tables `parallel.ts` prepared: its chart, its timers' rules, its first configuration. */
+function wireParallel(tables) {
+	const states = tables.ss;
+	const root = states[0].up;
+	const chart = {
+		r: root,
+		m: /* @__PURE__ */ new Map(),
+		d: /* @__PURE__ */ new Map(),
+		e: [routed((view) => pick(chart, view))],
+		a: [routed((view) => pick(chart, view, true))],
+		f: [routed((view) => {
+			const state = chart.d.get(view.event);
+			return !!state && complete(view, state) && pickFrom(view, state.dn.rules, state);
+		})]
+	};
+	charts.set(tables, chart);
+	for (const s of [root, ...states]) {
+		if (s.af) s.af = s.af.map(([ms, list]) => [ms, [{
+			...routed((view) => pickFrom(view, list, s)),
+			w: list
+		}]]);
+		if (s.dn) chart.d.set(s.dn.event, s);
+	}
+	tables.i0 = {
+		i: -2,
+		up: root,
+		en: [(view) => {
+			const enter = /* @__PURE__ */ new Set();
+			descend(view, root.n, enter);
+			settle(view, [], enter);
+		}]
+	};
+}
+//#endregion
+//#region src/features/parallel.ts
+/**
+* `type: parallel` (PLAN §4.9, D12): a state whose children, its regions,
+* are all active at once. Only a machine that declares one ships this
+* module: `parallel` is imported to be written, and the mark carries what
+* prepares the machine's tables for the configurations of `chart.ts` (the
+* regions, initial children and subtrees of each state, the state that
+* declares each rule, a parallel state's `done`) and wires them, which the
+* normaliser calls when it meets the mark. Importing it has no effect.
+* A compiled machine (M7) has its tables prepared at build time, so it ships
+* `chart.ts` without this module.
+*/
+/** Prepares a machine with parallel states, then wires it: what the mark carries. */
+const prepare = (tables, raws, rules) => {
+	const states = tables.ss;
+	const root = states[0].up;
+	if (root.k) return;
+	const all = [root, ...states];
+	const byPath = new Map(states.map((s) => [s.path, s]));
+	for (const s of all) {
+		const k = s.i + 1;
+		const mark = markOf(raws[k]);
+		const first = raws[k].initial;
+		s.k = [];
+		s.hs = [];
+		s.p = mark?.kind === "parallel";
+		s.h = mark?.kind === "history" ? !!mark.deep : void 0;
+		s.n = first === void 0 ? void 0 : byPath.get(s === root ? first : `${s.path}.${first}`);
+		for (let up = s; up; up = up.up) up.e = s.i;
+		if (s.up) (s.h === void 0 ? s.up.k : s.up.hs).push(s);
+	}
+	if (CHECK) {
+		for (const s of states) if (s.h !== void 0 && s.up.n === s) fail("HISTORY", tables.name, `"${s.up.path}" starts in its history state "${s.path}"; make another state its \`initial\`.`);
+		if (tables.bd.some((b) => b.yes)) fail("PARALLEL", tables.name, "a bindable prop follows states (`bindable(…, { states })`) in a machine with parallel states, which is not supported yet; bind the value to data and move with events.");
+	}
+	/** Marks the first `count` rules of `list` as declared by `s`. */
+	const own = (list, count, s) => {
+		for (let k = 0; k < count; k++) list[k].s = s;
+	};
+	for (const s of all) {
+		for (const [type, handler] of s.on) {
+			const outer = s.up?.on.get(type);
+			if (outer !== handler) own(handler.ru, handler.ru.length - (outer?.ru.length ?? 0), s);
+		}
+		if (s.al && s.al !== s.up?.al) own(s.al, s.al.length - (s.up?.al?.length ?? 0), s);
+		for (const [, list] of s.af ?? []) own(list, list.length, s);
+		const done = raws[s.i + 1]?.done;
+		if (done && s.p) {
+			const list = rules(done, s);
+			own(list, list.length, s);
+			s.dn = {
+				rules: list,
+				event: { type: DONE.type }
+			};
+		}
+	}
+	if (wiring) wireParallel(tables);
+};
+/** Marks a state whose regions are all active at once: `editor: { type: parallel, states: { … } }`. */
+const parallel = /* @__PURE__ */ Object.freeze({
+	kind: "parallel",
+	f: prepare
+});
+//#endregion
+//#region src/vite/compile/analyse.ts
+/** Why a config cannot be compiled, and where. */
+var NotLiteral = class extends Error {
+	node;
+	/** What to write instead, when it is not "write the structure out". */
+	fix;
+	constructor(node, reason, fix) {
+		super(reason);
+		this.node = node;
+		this.fix = fix;
+	}
+};
+/** The fix for a target or a name the build cannot read. */
+const WRITE_IT = "Write the target or name as a string literal in the config, or the function in place, to compile it.";
+/** An identifier's or a private name's text. */
+const nameOf = (node) => node.type === "Identifier" || node.type === "PrivateIdentifier" ? node.name : "…";
+/** Strips what TypeScript adds around an expression (`as const`, `!`, parentheses). */
+function bare(node) {
+	for (;;) switch (node.type) {
+		case "TSAsExpression":
+		case "TSSatisfiesExpression":
+		case "TSNonNullExpression":
+		case "TSTypeAssertion":
+		case "ParenthesizedExpression":
+			node = node.expression;
+			break;
+		default: return node;
+	}
+}
+/** A property's key as the runtime sees it, or undefined when computed. */
+function keyOf(property) {
+	if (property.computed) return void 0;
+	const { key } = property;
+	if (key.type === "Identifier") return key.name;
+	if (key.type === "Literal" && (typeof key.value === "string" || typeof key.value === "number")) return String(key.value);
+}
+/** A literal object's properties in order; NotLiteral on a spread, a computed key or a method. */
+function entries(node, what) {
+	const object = bare(node);
+	if (object.type !== "ObjectExpression") throw new NotLiteral(node, `${what} is not an object literal`);
+	return object.properties.map((property) => {
+		if (property.type !== "Property") throw new NotLiteral(property, `${what} has a spread`);
+		const key = keyOf(property);
+		if (key === void 0) throw new NotLiteral(property, `${what} has a computed key`);
+		if (property.kind !== "init") throw new NotLiteral(property, `${what}.${key} is an accessor`);
+		if (property.method) throw new NotLiteral(property, `${what}.${key} is a method`, `Write it as \`${key}: (view) => …\` to compile it.`);
+		return [key, property];
+	});
+}
+const PLAIN_KEY$1 = /^[A-Za-z_$][\w$]*$/;
+const member = (object, key) => PLAIN_KEY$1.test(key) ? `${object}.${key}` : `${object}[${JSON.stringify(key)}]`;
+/**
+* Reads the config `node` of a `defineMachine` call; NotLiteral when its
+* structure is not written out.
+*/
+function analyse(node, scope) {
+	const kept = [];
+	const refs = /* @__PURE__ */ new Map();
+	const unseen = /* @__PURE__ */ new Map();
+	const c = /* @__PURE__ */ new Map();
+	const context = [];
+	const props = [];
+	const derived = [];
+	const written = /* @__PURE__ */ new Map();
+	const keep = (value) => kept.push(value) - 1;
+	const placeholder = (ref) => {
+		const fn = function() {};
+		refs.set(fn, ref);
+		return fn;
+	};
+	/** The imported name `local` stands for, when it comes from this package. */
+	const imported = (local) => {
+		const from = scope.imports.get(local);
+		return from && scope.isPackage(from[0]) ? from[1] : void 0;
+	};
+	/** A string written in place or held by a module `const`. */
+	const string = (value) => {
+		const n = bare(value);
+		if (n.type === "Literal" && typeof n.value === "string") return n.value;
+		if (n.type === "TemplateLiteral" && n.expressions.length === 0) return n.quasis[0]?.value.cooked ?? void 0;
+		if (n.type === "Identifier" && !scope.imports.has(n.name)) {
+			const init = scope.values.get(n.name);
+			if (init && init !== "function") return string(init);
+		}
+	};
+	/** A literal the runtime would reject (`null`, a number), passed through for its error. */
+	const other = (value) => {
+		const n = bare(value);
+		if (n.type === "Literal") return n.value;
+		if (n.type === "Identifier" && n.name === "undefined") return void 0;
+		return NaN;
+	};
+	/**
+	* A function: written in place or declared in the module. Where a target
+	* or a name may stand, an identifier or a member whose value the build
+	* cannot see (an import, a \`let\`, an enum's member) may be a string as
+	* well as a function, so the machine is left to the runtime normaliser,
+	* which reads the value (D14: both forms behave the same). A call's
+	* result, in place or in a module \`const\`, is taken for a function, and
+	* checked when the machine loads in development (\`unseen\`).
+	*/
+	const fn = (value, where) => {
+		const n = bare(value);
+		const ph = placeholder(`$[${keep(value)}]`);
+		if (n.type === "ArrowFunctionExpression" || n.type === "FunctionExpression") return ph;
+		if (n.type === "Identifier") {
+			const init = scope.imports.has(n.name) ? void 0 : scope.values.get(n.name);
+			if (init === "function") return ph;
+			const i = init && bare(init);
+			if (i?.type === "ArrowFunctionExpression" || i?.type === "FunctionExpression") return ph;
+			if (i?.type === "ObjectExpression" || i?.type === "ArrayExpression") throw new NotLiteral(value, `${where} is \`${n.name}\`, written outside the config`);
+			if (!init) {
+				const from = scope.imports.get(n.name)?.[0];
+				throw new NotLiteral(value, `${where} is \`${n.name}\`, ${from === void 0 ? "not a module `const`" : `imported from "${from}"`}, which may be a target or a name as well as a function`, WRITE_IT);
+			}
+		}
+		if (n.type === "MemberExpression") throw new NotLiteral(value, `${where} is \`${n.object.type === "Identifier" ? n.object.name : "…"}${n.computed ? "[…]" : `.${nameOf(n.property)}`}\`, a member the build cannot read, which may be a target or a name as well as a function`, WRITE_IT);
+		unseen.set(ph, where);
+		return ph;
+	};
+	/** One function or name, or a list of them (`entry`, `do`). */
+	const fns = (value, where) => {
+		const n = bare(value);
+		if (n.type === "ArrayExpression") return n.elements.map((element, k) => {
+			if (!element || element.type === "SpreadElement") throw new NotLiteral(value, `${where} has a spread or a hole`);
+			return string(element) ?? fn(element, `${where}[${k}]`);
+		});
+		return string(value) ?? fn(value, where);
+	};
+	/** A transition: a target, a function, `{ to, if, do }`, or a list of them. */
+	const transition = (value, where) => {
+		const n = bare(value);
+		const target = string(value);
+		if (target !== void 0) return target;
+		if (n.type === "ArrayExpression") return n.elements.map((element, k) => {
+			if (!element || element.type === "SpreadElement") throw new NotLiteral(value, `${where} has a spread or a hole`);
+			return transition(element, `${where}[${k}]`);
+		});
+		if (n.type === "ObjectExpression") {
+			const rule = {};
+			for (const [key, property] of entries(n, where)) if (key === "to") {
+				const to = string(property.value);
+				if (to === void 0 && bare(property.value).type !== "Literal") throw new NotLiteral(property.value, `${where}.to is not a string literal`);
+				rule.to = to ?? other(property.value);
+			} else if (key === "if") rule.if = fns(property.value, `${where}.if`);
+			else if (key === "do") rule.do = fns(property.value, `${where}.do`);
+			else rule[key] = other(property.value);
+			return rule;
+		}
+		if (n.type === "Literal") return n.value;
+		return fn(value, where);
+	};
+	const transitions = (value, where) => {
+		const out = {};
+		for (const [key, property] of entries(value, where)) out[key] = transition(property.value, member(where, key));
+		return out;
+	};
+	const state = (value, path, where, at = value.start) => {
+		const n = bare(value);
+		if (n.type === "CallExpression" && n.callee.type === "Identifier" && imported(n.callee.name) === "history") {
+			const [arg] = n.arguments;
+			if (arg && arg.type !== "SpreadElement" && string(arg) !== "deep") throw new NotLiteral(arg, `${where}: history() takes nothing or "deep"`);
+			written.set(path, {
+				node: value,
+				at,
+				keys: /* @__PURE__ */ new Map()
+			});
+			return history(arg ? "deep" : void 0);
+		}
+		const keys = /* @__PURE__ */ new Map();
+		const out = {};
+		for (const [key, property] of entries(value, where)) {
+			keys.set(key, property);
+			const at = member(where, key);
+			const v = property.value;
+			switch (key) {
+				case "initial": {
+					const initial = string(v);
+					if (initial === void 0) throw new NotLiteral(v, `${at} is not a string literal`);
+					out.initial = initial;
+					break;
+				}
+				case "states": {
+					const states = {};
+					for (const [name, child] of entries(v, at)) states[name] = state(child.value, path ? `${path}.${name}` : name, member(at, name), child.start);
+					out.states = states;
+					break;
+				}
+				case "on":
+				case "after":
+					out[key] = transitions(v, at);
+					break;
+				case "entry":
+				case "exit":
+				case "effect":
+					out[key] = fns(v, at);
+					break;
+				case "always":
+				case "done":
+					out[key] = transition(v, at);
+					break;
+				case "type": {
+					const b = bare(v);
+					if (b.type === "Identifier" && imported(b.name) === "parallel") out.type = parallel;
+					else if (string(v) !== void 0) out.type = string(v);
+					else if (b.type === "Literal") out.type = b.value;
+					else throw new NotLiteral(v, `${at} is not "final" or \`parallel\``);
+					break;
+				}
+				default: out[key] = machineKey(key, v, at) ?? other(v);
+			}
+		}
+		written.set(path, {
+			node: value,
+			at,
+			keys
+		});
+		return out;
+	};
+	/** The keys only the machine has; undefined for any other. */
+	const machineKey = (key, v, at) => {
+		switch (key) {
+			case "name":
+			case "expose":
+				c.set(key, keep(v));
+				return key === "name" ? string(v) : {};
+			case "parts":
+				c.set(key, keep(v));
+				return parts(v);
+			case "events": {
+				const b = bare(v);
+				if (b.type !== "ObjectExpression") return void 0;
+				try {
+					return Object.fromEntries(entries(b, at).map(([event]) => [event, null]));
+				} catch {
+					return;
+				}
+			}
+			case "context":
+			case "props":
+			case "derived": {
+				const list = key === "context" ? context : key === "props" ? props : derived;
+				const out = {};
+				for (const [field, property] of entries(v, at)) {
+					list.push([field, keep(property.value)]);
+					out[field] = key === "derived" ? function() {} : null;
+					if (key === "props") out[field] = bound(property.value) ?? null;
+				}
+				return out;
+			}
+			case "actions":
+			case "guards":
+			case "effects": {
+				const named = entries(v, at);
+				c.set(key, keep(v));
+				return Object.fromEntries(named.map(([name]) => [name, placeholder(member(member("c", key), name))]));
+			}
+			default: return;
+		}
+	};
+	/**
+	* What the normaliser checks of `parts` (each handler's event, each key's
+	* spelling), read where written; parts built elsewhere are checked when
+	* the compiled machine loads in development. The code itself stays in place.
+	*/
+	const parts = (value) => {
+		const out = {};
+		try {
+			for (const [name, part] of entries(value, "parts")) {
+				const read = {};
+				for (const [key, property] of entries(part.value, name)) {
+					const n = bare(property.value);
+					read[key] = string(property.value) ?? (n.type === "Literal" ? n.value : () => {});
+				}
+				out[name] = read;
+			}
+		} catch {
+			return {};
+		}
+		return out;
+	};
+	/** `bindable(…, { states, changed })` with literal options, so the build checks its states. */
+	const bound = (value) => {
+		const n = bare(value);
+		if (n.type !== "CallExpression" || n.callee.type !== "Identifier" || imported(n.callee.name) !== "bindable") return void 0;
+		const options = n.arguments[1];
+		if (!options) return bindable(null);
+		try {
+			const read = {};
+			for (const [key, property] of entries(options, "bindable")) if (key === "states") {
+				const states = {};
+				for (const [side, s] of entries(property.value, "states")) states[side] = string(s.value);
+				read.states = states;
+			} else read[key] = string(property.value);
+			return bindable(null, read);
+		} catch {
+			return;
+		}
+	};
+	return {
+		raw: state(node, "", "the config"),
+		kept,
+		refs,
+		unseen,
+		c,
+		context,
+		props,
+		derived,
+		written
+	};
+}
+//#endregion
+//#region src/vite/compile/emit.ts
+const PLAIN_KEY = /^[A-Za-z_$][\w$]*$/;
+const key = (k) => PLAIN_KEY.test(k) ? k : JSON.stringify(k);
+/** `function <name>($, c = {…}) { … }`: builds `analysis`'s tables. */
+function emit(tables, analysis, options) {
+	const { runtime: use } = options;
+	const states = tables.ss;
+	const all = [states[0]?.up ?? tables.i0.up, ...states];
+	const names = new Map(all.map((s, k) => [s, k ? `s${k - 1}` : "r"]));
+	const count = /* @__PURE__ */ new Map();
+	const visit = (value) => {
+		if (typeof value !== "object" || value === null || names.has(value)) return;
+		const n = (count.get(value) ?? 0) + 1;
+		count.set(value, n);
+		if (n > 1) return;
+		if (value instanceof Map) for (const [, v] of value) visit(v);
+		else if (Array.isArray(value)) for (const v of value) visit(v);
+		else for (const v of Object.values(value)) visit(v);
+	};
+	for (const s of all) for (const v of Object.values(s)) visit(v);
+	const lines = [];
+	let shared = 0;
+	const declared = /* @__PURE__ */ new Map();
+	const val = (value, where) => {
+		if (value === void 0) return "void 0";
+		if (value === null) return "null";
+		if (typeof value === "boolean") return value ? "!0" : "!1";
+		if (typeof value === "number" || typeof value === "string") return JSON.stringify(value);
+		if (typeof value === "function") {
+			const ref = analysis.refs.get(value);
+			if (ref === void 0) throw new Error(`[machine:COMPILE] ${where}: a function the build did not place`);
+			const unseen = analysis.unseen.get(value);
+			return unseen !== void 0 && options.dev ? `${use("fn")}(${ref}, ${JSON.stringify(unseen)}, ${JSON.stringify(options.machine)})` : ref;
+		}
+		if (typeof value !== "object") throw new Error(`[machine:COMPILE] ${where}: ${typeof value}`);
+		const named = names.get(value) ?? declared.get(value);
+		if (named) return named;
+		let out;
+		if (value instanceof Map) out = `new Map(${value.size ? `[${[...value].map(([k, v]) => `[${JSON.stringify(k)},${val(v, `${where}.${k}`)}]`).join(",")}]` : ""})`;
+		else if (Array.isArray(value)) out = `[${value.map((v, k) => val(v, `${where}[${k}]`)).join(",")}]`;
+		else out = `{${Object.entries(value).map(([k, v]) => `${key(k)}:${val(v, `${where}.${k}`)}`).join(",")}}`;
+		if ((count.get(value) ?? 0) > 1) {
+			const name = `o${shared++}`;
+			lines.push(`const ${name}=${out};`);
+			declared.set(value, name);
+			return name;
+		}
+		return out;
+	};
+	const later = [];
+	const done = /* @__PURE__ */ new Set();
+	/** Whether `value` reaches a state not declared yet. */
+	const ahead = (value, seen = /* @__PURE__ */ new Set()) => {
+		if (typeof value !== "object" || value === null || seen.has(value)) return false;
+		if (names.has(value)) return !done.has(value);
+		seen.add(value);
+		return (value instanceof Map ? [...value.values()] : Object.values(value)).some((v) => ahead(v, seen));
+	};
+	for (const s of all) {
+		const fields = Object.entries(s).map(([k, v]) => {
+			if (typeof v !== "object" || v === null) return `${key(k)}:${val(v, `${s.path}.${k}`)}`;
+			if (done.has(v) || !ahead(v)) return `${key(k)}:${val(v, `${s.path}.${k}`)}`;
+			later.push([s, k]);
+			return `${key(k)}:void 0`;
+		});
+		lines.push(`const ${names.get(s)}={${fields.join(",")}};`);
+		done.add(s);
+	}
+	for (const [s, k] of later) {
+		const value = val(s[k], `${s.path}.${k}`);
+		lines.push(`${names.get(s)}.${k}=${value};`);
+	}
+	const fields = analysis.context.map(([f]) => f);
+	const propNames = analysis.props.map(([p]) => p);
+	const effects = states.some((s) => s.af || s.ef);
+	const ref = (k) => `$[${k}]`;
+	const list = (items) => `[${items.map((i) => JSON.stringify(i)).join(",")}]`;
+	if (propNames.length) lines.push(`const p=${list(propNames)};`);
+	const props = propNames.length > 0;
+	const t = [
+		`ss:[${states.map((s) => names.get(s)).join(",")}]`,
+		`i0:${val(tables.i0, "initial")}`,
+		fields.length && `df:[${analysis.context.map(([, k]) => ref(k)).join(",")}]`,
+		fields.length && `C:${use("storeClass")}(${list(fields)},1,!0)`,
+		`pn:${props ? "p" : "[]"}`,
+		props && "pd:[]",
+		props && `Q:${use("storeClass")}(p,${1 + fields.length},!1)`,
+		props && "pl:[]",
+		`nm:${list([...fields, ...propNames])}`,
+		analysis.derived.length && `D:${use("derivedClass")}(${list(analysis.derived.map(([d]) => d))},[${analysis.derived.map(([, k]) => ref(k)).join(",")}])`,
+		"k:void 0",
+		props && "bd:[]",
+		"c",
+		`r:(c)=>${options.name}($,c)`,
+		effects && `A:${use("activate")}`,
+		effects && `X:${use("release")}`,
+		props && `P:${use("own")}`
+	].filter(Boolean);
+	lines.push(`const t={${t.join(",")}};`);
+	if (options.dev) lines.push(`${use("devTables")}(t);`);
+	if (propNames.length) lines.push(`${use("bind")}(t,{${analysis.props.map(([p, k]) => `${key(p)}:${ref(k)}`).join(",")}});`);
+	if (states.some((s) => s.p)) lines.push(`${use("wireParallel")}(t);`);
+	else if (states.some((s) => s.h !== void 0)) lines.push(`${use("wireHistory")}(t);`);
+	lines.push("return t;");
+	const c = [...analysis.c].map(([k, index]) => `${k}:${ref(index)}`).join(",");
+	return `function ${options.name}($,c={${c}}){${lines.join("")}}`;
+}
+//#endregion
+//#region src/vite/compile/module.ts
+/**
+* Compiling the machines of one module (PLAN §5.6, D14, M7). Each top-level
+* `const x = defineMachine({ … })` whose structure is literal is checked by
+* the runtime normaliser at build time (its dev errors become build errors,
+* with the file, line and column) and replaced by a call that builds its
+* tables: `__machine0([…])`, the array holding the config's code where it
+* is written (functions, context and props values, parts…), so every other
+* line and column stays. The builders and their imports are appended to the
+* module. A config that is not literal stays a `defineMachine` call,
+* normalised at runtime, with a warning that says why.
+*/
+checkAlways();
+/** A machine's config the normaliser rejects: the build fails with it. */
+var CompileError = class extends Error {
+	file;
+	offset;
+	line;
+	column;
+	constructor(file, at) {
+		super(`${at.message}\n  at ${file}:${at.line}:${at.column + 1}`);
+		this.file = file;
+		this.offset = at.offset;
+		this.line = at.line;
+		this.column = at.column;
+	}
+};
+/** `code`'s machines compiled, or null when it has none to compile or warn about. */
+async function compileModule(code, file, options) {
+	if (!code.includes("defineMachine")) return null;
+	const { program, errors } = parseSync(file, code);
+	if (errors.length) return null;
+	const imports = /* @__PURE__ */ new Map();
+	const values = /* @__PURE__ */ new Map();
+	const sources = /* @__PURE__ */ new Set();
+	for (const node of program.body) {
+		if (node.type === "ImportDeclaration") {
+			if (node.importKind === "type") continue;
+			for (const specifier of node.specifiers) {
+				if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type") continue;
+				const name = specifier.imported.type === "Identifier" ? specifier.imported.name : String(specifier.imported.value);
+				imports.set(specifier.local.name, [node.source.value, name]);
+				sources.add(node.source.value);
+			}
+			continue;
+		}
+		const declaration = node.type === "ExportNamedDeclaration" ? node.declaration : node;
+		if (declaration?.type === "FunctionDeclaration" && declaration.id) values.set(declaration.id.name, "function");
+		if (declaration?.type === "VariableDeclaration" && declaration.kind === "const") {
+			for (const { id, init } of declaration.declarations) if (id.type === "Identifier" && init) values.set(id.name, init);
+		}
+	}
+	const ours = /* @__PURE__ */ new Set();
+	for (const source of sources) if (await options.isPackage(source)) ours.add(source);
+	const scope = {
+		imports,
+		values,
+		isPackage: (source) => ours.has(source)
+	};
+	const define = [...imports].filter(([, [s, n]]) => ours.has(s) && n === "defineMachine");
+	if (!define.length) return null;
+	const defines = new Set(define.map(([local]) => local));
+	const lines = [0];
+	for (let i = code.indexOf("\n"); i >= 0; i = code.indexOf("\n", i + 1)) lines.push(i + 1);
+	const at = (offset, message) => {
+		let low = 0;
+		let high = lines.length - 1;
+		while (low < high) {
+			const mid = low + high + 1 >> 1;
+			if (lines[mid] <= offset) low = mid;
+			else high = mid - 1;
+		}
+		return {
+			message,
+			offset,
+			line: low + 1,
+			column: offset - lines[low]
+		};
+	};
+	let prefix = "__machine";
+	while (code.includes(prefix)) prefix += "$";
+	const used = /* @__PURE__ */ new Set();
+	const runtime = (name) => (used.add(name), `${prefix}_${name}`);
+	const s = new MagicString(code);
+	const builders = [];
+	const compiled = [];
+	const warnings = [];
+	for (const node of program.body) {
+		const declaration = node.type === "ExportNamedDeclaration" ? node.declaration : node;
+		if (declaration?.type !== "VariableDeclaration" || declaration.kind !== "const") continue;
+		for (const { id, init } of declaration.declarations) {
+			const call = init && bare(init);
+			if (id.type !== "Identifier" || call?.type !== "CallExpression" || call.callee.type !== "Identifier" || !defines.has(call.callee.name)) continue;
+			const [config] = call.arguments;
+			if (!config || config.type === "SpreadElement" || call.arguments.length !== 1) continue;
+			let analysis;
+			try {
+				analysis = analyse(config, scope);
+			} catch (error) {
+				if (!(error instanceof NotLiteral)) throw error;
+				warnings.push(at(error.node.start, `[machine:NOT_COMPILED] ${id.name}: ${error.message}, so this machine is normalised at runtime, as without the plugin. ${error.fix ?? "Write its states, targets and names out in the config to compile it."}`));
+				continue;
+			}
+			let tables;
+			try {
+				tables = prepared(analysis.raw);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : "";
+				if (!message.startsWith("[machine:")) throw error;
+				throw new CompileError(file, at(locate(message, analysis, config), message));
+			}
+			const name = `${prefix}${compiled.length}`;
+			builders.push(emit(tables, analysis, {
+				name,
+				runtime,
+				dev: options.dev,
+				machine: analysis.raw.name ?? id.name
+			}));
+			replace(s, code, call, analysis.kept, `/* @__PURE__ */ ${name}([`, "])");
+			compiled.push(id.name);
+		}
+	}
+	if (!compiled.length && !warnings.length) return null;
+	if (compiled.length) {
+		const names = [...used].sort().map((n) => `${n} as ${prefix}_${n}`);
+		s.append(`\n${builders.join("\n")}\n`);
+		if (names.length) s.append(`import { ${names.join(", ")} } from ${JSON.stringify(options.runtime)};\n`);
+	}
+	return {
+		code: s.toString(),
+		map: s.generateMap({
+			hires: "boundary",
+			source: file,
+			includeContent: true
+		}),
+		compiled,
+		warnings
+	};
+}
+/**
+* Overwrites `call` around the nodes it keeps, so each stays where it is
+* written: `open` before the first, a comma between two, `close` after the
+* last. Each gap keeps its line breaks, so no line moves.
+*/
+function replace(s, code, call, kept, open, close) {
+	const breaks = (from, to) => code.slice(from, to).replace(/[^\n]/g, "");
+	let from = call.start;
+	let text = open;
+	for (const node of kept) {
+		if (node.start < from) throw new Error("[machine:COMPILE] kept code out of order");
+		s.overwrite(from, node.start, text + breaks(from, node.start));
+		from = node.end;
+		text = ",";
+	}
+	s.overwrite(from, call.end, (kept.length ? "" : open) + breaks(from, call.end) + close);
+}
+/**
+* Where a normaliser's message points in the config: the state it names
+* (its first quoted path, or the machine), then, inside that state's own
+* keys, a key or string it quotes after it.
+*/
+function locate(message, analysis, config) {
+	const quoted = [...message.matchAll(/"([^"]*)"|`([^`]*)`/g)].flatMap((m) => m[1] !== void 0 ? [m[1]] : m[2].match(/[\w$]+/g) ?? []);
+	const k = quoted.findIndex((q) => analysis.written.has(q));
+	const state = k >= 0 ? quoted[k] : "";
+	const written = analysis.written.get(state);
+	const tokens = new Set(quoted.slice(k + 1));
+	if (!written) return config.start;
+	let found;
+	const search = (node, top) => {
+		if (!node || found !== void 0) return;
+		const n = bare(node);
+		if (n.type === "ObjectExpression") for (const property of n.properties) {
+			if (property.type !== "Property") continue;
+			const name = keyOf(property);
+			if (top && name === "states") continue;
+			if (name !== void 0 && tokens.has(name)) return void (found = property.start);
+			search(property.value, false);
+			if (found !== void 0) return;
+		}
+		else if (n.type === "ArrayExpression") {
+			for (const element of n.elements) if (element && element.type !== "SpreadElement") search(element, false);
+		} else if (n.type === "Literal" && typeof n.value === "string" && tokens.has(n.value)) found = n.start;
+	};
+	search(written.node, true);
+	if (found === void 0 && state === "") for (const key of [
+		"props",
+		"actions",
+		"guards",
+		"effects"
+	]) search(written.keys.get(key)?.value, false);
+	return found ?? written.at;
+}
+//#endregion
+//#region src/vite/compile/plugin.ts
+function compilePlugin(options) {
+	let dev = true;
+	return {
+		name: "machine:compile",
+		enforce: "pre",
+		configResolved(config) {
+			dev = !config.isProduction;
+		},
+		transform: {
+			filter: {
+				id: {
+					include: /\.[cm]?[jt]sx?(?:\?|$)/,
+					exclude: /\/node_modules\//
+				},
+				code: "defineMachine"
+			},
+			async handler(code, id) {
+				if (id.startsWith("\0") || options.include && !options.include(id)) return null;
+				const isPackage = async (source) => source === "@menapo/machine" || source.startsWith(".") && (await this.resolve(source, id))?.id === options.index;
+				try {
+					const out = await compileModule(code, id.split("?")[0], {
+						runtime: options.runtime,
+						dev,
+						isPackage
+					});
+					if (!out) return null;
+					for (const warning of out.warnings) this.warn(warning.message, warning.offset);
+					return out.compiled.length ? {
+						code: out.code,
+						map: out.map
+					} : null;
+				} catch (error) {
+					if (error instanceof CompileError) this.error(error.message, error.offset);
+					throw error;
+				}
+			}
+		}
+	};
+}
+//#endregion
+//#region src/vite/config.ts
+/** The package's entries an app's code imports (`/vite` runs in Vite itself). */
+const ENTRIES = [
+	"@menapo/machine",
+	"@menapo/machine/compiled",
+	"@menapo/machine/dom",
+	"@menapo/machine/test",
+	"@menapo/machine/vicss"
+];
+/**
+* `machine:config`: every entry served as its own files, never pre-bundled,
+* and bundled into server builds, never left to Node. The glue modules the
+* plugin resolves `useMachine` to import the runtime's files directly; a
+* pre-bundled or external copy of the entries beside them would be a
+* second runtime, whose instances the first does not know (a context write
+* would throw, parts would stop tracking, `inspect` would see nothing).
+*/
+const configPlugin = () => ({
+	name: "machine:config",
+	config: () => ({ optimizeDeps: { exclude: ENTRIES } }),
+	configEnvironment(name, config) {
+		return (config.consumer ?? (name === "client" ? "client" : "server")) === "server" ? { resolve: { noExternal: ["@menapo/machine"] } } : void 0;
+	}
+});
+//#endregion
+//#region ../glue/src/devtools.ts
+/** A panel: an iframe of the page served at `<base><path>`. */
+const dockEntry$1 = (panel, base, path) => ({
+	...panel,
+	category: "framework",
+	type: "iframe",
+	url: base + path
+});
+/** Serves `page()` at `<anything>/<path>` while `on()` holds; other requests pass. */
+function serveDock(server, path, on, page) {
+	server.middlewares.use((req, res, next) => {
+		const pathname = new URL(req.url ?? "/", "http://localhost").pathname;
+		if (!on() || req.method !== "GET" || !pathname.endsWith(`/${path}`)) return next();
+		res.setHeader("content-type", "text/html; charset=utf-8");
+		res.setHeader("cache-control", "no-store");
+		res.end(page());
+	});
+}
+/**
+* The page's bridge as the panel finds it: the global `name` on the nearest
+* ancestor window that has it (Vite DevTools may nest the iframe). A panel
+* page runs from its own source text, so it is handed this function's
+* source (`${findBridge}`) rather than importing it.
+*/
+function findBridge(name) {
+	for (let w = window.parent;; w = w.parent) {
+		try {
+			const found = w[name];
+			if (found) return found;
+		} catch {}
+		if (w === w.parent) return void 0;
+	}
+}
+//#endregion
+//#region src/vite/devtools/protocol.ts
+/** The dock page Vite DevTools embeds, under the dev server's `base`. */
+const DOCK_PATH = "__machine/dock";
+/** The page module the plugin adds to every client module that imports `@menapo/machine`. */
+const PAGE_ID = "virtual:machine/devtools";
+/**
+* The page global through which the dock, a same-origin iframe, reaches the
+* page's machines: it is a document of its own, with no module graph.
+*/
+const BRIDGE = "__machineDevtools";
+//#endregion
+//#region src/vite/devtools/dock.ts
+/**
+* The Vite DevTools dock panel (PLAN §5.8): one self-contained document the
+* dev server serves at `<base>__machine/dock`, embedded by Vite DevTools as
+* a same-origin iframe of the app's page, as vi18n's dock is. It finds the
+* page's {@link Bridge} on an ancestor window and shows, for the instance
+* chosen:
+*
+* - its current state and its context and props;
+* - the events it took, newest first, each with the fields it changed;
+* - a form that sends it one of the events its state handles;
+* - its states as a read-only tree: the active ones marked, each state's own
+*   transitions, `after` timers and `always` rules, each linked to where it
+*   is written when the plugin found its source.
+*
+* `dock` runs from its own source text in the page, so it uses nothing but
+* its arguments and globals (the bridge lookup is `@menapo/glue`'s, handed
+* in as source); it reads the core's tables, typed by the core.
+*/
+function dock(global, find) {
+	const bridge = find(global);
+	const $ = (id) => document.getElementById(id);
+	const h = (tag, props = {}, ...children) => {
+		const element = Object.assign(document.createElement(tag), props);
+		for (const child of children) if (child) element.append(child);
+		return element;
+	};
+	const format = (value) => {
+		let text;
+		try {
+			text = typeof value === "function" ? "ƒ" : JSON.stringify(value) ?? String(value);
+		} catch {
+			text = String(value);
+		}
+		return text.length > 80 ? `${text.slice(0, 79)}…` : text;
+	};
+	const link = (source, at) => {
+		if (!source || !at) return null;
+		const where = `${source.file}:${at[0]}:${at[1]}`;
+		return h("a", {
+			className: "source",
+			textContent: "source",
+			title: where,
+			href: `../__open-in-editor?file=${encodeURIComponent(where)}`,
+			onclick(event) {
+				event.preventDefault();
+				fetch(this.href);
+			}
+		});
+	};
+	const nameOf = ({ instance, source }) => instance.M.name !== "machine" ? instance.M.name : source?.binding ?? "machine";
+	if (!bridge) {
+		$("empty").textContent = "No machines here: open this panel from the app's page, where Vite DevTools shows it.";
+		return;
+	}
+	let chosen = 0;
+	let current;
+	const instances = $("instances");
+	const type = $("type");
+	const data = $("payload");
+	const error = $("error");
+	/** A state's own transitions, `after` timers and `always` rules, as list items. */
+	const transitions = (state, up, source) => {
+		const own = source?.states[state.path];
+		const items = [];
+		const add = (label, rules, at) => {
+			for (const rule of rules.flatMap((r) => r.w ?? [r])) {
+				const to = rule.h ?? rule.to;
+				const target = to ? to.path : "(stays)";
+				items.push(h("li", {}, h("code", { textContent: label }), ` → ${target}`, rule.if ? " if …" : "", " ", link(source, at)));
+			}
+		};
+		for (const [event, handler] of state.on) {
+			if (up?.on.get(event) === handler) continue;
+			const inherited = up?.on.get(event)?.ru.length ?? 0;
+			add(event, handler.ru.slice(0, handler.ru.length - inherited), own?.on[event]);
+		}
+		for (const [ms, rules] of state.af ?? []) add(`after ${ms} ms`, rules, own?.after[ms]);
+		if (state.al && state.al !== up?.al) {
+			const inherited = up?.al?.length ?? 0;
+			add("always", state.al.slice(0, state.al.length - inherited), own?.always);
+		}
+		return items.length ? h("ul", { className: "transitions" }, ...items) : null;
+	};
+	const graph = ({ instance, source }) => {
+		const tree = h("ul");
+		const lists = /* @__PURE__ */ new Map();
+		const root = instance.M.ss[0]?.up;
+		const anywhere = root && transitions(root, void 0, source);
+		const chain = [];
+		for (let at = instance.s; at; at = at.up) chain.push(at);
+		const actives = new Set(instance.s.a ?? chain);
+		for (const state of instance.M.ss) {
+			const active = actives.has(state);
+			const leaf = active && !instance.M.ss.some((s) => s.up === state && actives.has(s));
+			const parent = state.up === root ? tree : lists.get(state.up);
+			const name = state.path.slice(state.path.lastIndexOf(".") + 1);
+			const item = h("li", {}, h("span", {
+				className: active ? "state active" : "state",
+				textContent: name + (state.fi ? " (final)" : ""),
+				ariaCurrent: leaf ? "true" : null
+			}), " ", link(source, source?.states[state.path]?.at), transitions(state, state.up, source));
+			parent.append(item);
+			const children = h("ul");
+			lists.set(state, children);
+			item.append(children);
+		}
+		for (const list of lists.values()) if (!list.childElementCount) list.remove();
+		return h("div", {}, anywhere && h("div", {}, h("span", {
+			className: "muted",
+			textContent: "In any state"
+		}), anywhere), tree);
+	};
+	const render = () => {
+		queued = false;
+		const live = bridge.live();
+		current = live.find((l) => l.n === chosen) ?? live[0];
+		chosen = current?.n ?? 0;
+		instances.replaceChildren(...live.map((l) => h("option", {
+			value: String(l.n),
+			textContent: `${nameOf(l)} #${l.n}`,
+			selected: l === current
+		})));
+		$("main").hidden = !current;
+		$("empty").textContent = current ? "" : "No machine is running on this page.";
+		if (!current) return;
+		const { instance, steps } = current;
+		$("state").textContent = instance.s.path;
+		const { nm: names, pn: propNames } = instance.M;
+		const fields = names.length - propNames.length;
+		$("data").replaceChildren(...names.map((name, n) => {
+			const store = n < fields ? instance.context : instance.props;
+			return h("tr", {}, h("th", {
+				scope: "row",
+				textContent: name
+			}), h("td", {
+				className: "muted",
+				textContent: n < fields ? "context" : "prop"
+			}), h("td", {}, h("code", { textContent: format(store[name]) })));
+		}));
+		const events = [...instance.s.on.keys()];
+		if (events.join("\0") !== [...type.options].map((o) => o.value).join("\0")) type.replaceChildren(...events.map((e) => h("option", {
+			value: e,
+			textContent: e
+		})));
+		$("submit").disabled = !events.length;
+		$("log").replaceChildren(...steps.slice().reverse().map(({ event, state, changed }) => {
+			const { type: name, ...payload } = event;
+			return h("tr", {}, h("td", {}, h("code", { textContent: name }), Object.keys(payload).length ? ` ${format(payload)}` : ""), h("td", { textContent: state }), h("td", {}, ...Object.entries(changed).map(([field, value]) => h("div", {}, h("code", { textContent: `${field} = ${format(value)}` })))));
+		}));
+		$("graph").replaceChildren(graph(current));
+	};
+	let queued = false;
+	const schedule = () => {
+		if (!queued) {
+			queued = true;
+			setTimeout(render, 0);
+		}
+	};
+	instances.onchange = () => {
+		chosen = Number(instances.value);
+		error.value = "";
+		render();
+	};
+	$("send").onsubmit = (event) => {
+		event.preventDefault();
+		error.value = "";
+		try {
+			const payload = data.value.trim() ? JSON.parse(data.value) : void 0;
+			if (payload !== void 0 && (typeof payload !== "object" || !payload || Array.isArray(payload))) throw new Error("the data is an object of the event's fields, like {\"by\": 2}");
+			current?.instance.send(type.value, payload);
+		} catch (thrown) {
+			error.value = thrown instanceof Error ? thrown.message : String(thrown);
+		}
+		render();
+	};
+	const stop = bridge.subscribe(schedule);
+	addEventListener("pagehide", stop);
+	render();
+}
+const STYLE = `
+:root { color-scheme: light dark; font: 13px/1.4 system-ui, sans-serif; }
+body { margin: 0; padding: 8px 12px; background: Canvas; color: CanvasText; }
+header, form { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; }
+h2 { font-size: 12px; text-transform: uppercase; letter-spacing: .04em; margin: 16px 0 4px; opacity: .8; }
+table { width: 100%; border-collapse: collapse; }
+th, td { padding: 3px 6px; border-top: 1px solid #8883; text-align: left; vertical-align: top; }
+th[scope=row] { font-weight: 500; }
+code { font: 12px ui-monospace, monospace; }
+ul { margin: 0; padding-left: 16px; list-style: none; }
+.transitions { padding-left: 12px; opacity: .85; }
+.state.active { font-weight: 700; }
+.state.active::after { content: " ●"; }
+#data td:last-child { width: 100%; }
+.muted, .source { opacity: .7; }
+input { flex: 1; min-width: 120px; font: inherit; }
+output { color: #d33; }
+`;
+/** The dock's page: one self-contained document. */
+function dockPage() {
+	return `<!doctype html>
+<html lang="en">
+<head><meta charset="utf-8"><title>Machines</title><style>${STYLE}</style></head>
+<body>
+<p id="empty" role="status"></p>
+<main id="main" hidden>
+<header>
+  <label>Machine <select id="instances"></select></label>
+  <span>State <b id="state"></b></span>
+</header>
+<h2 id="h-data">Context and props</h2>
+<table aria-labelledby="h-data"><tbody id="data"></tbody></table>
+<h2 id="h-send">Send</h2>
+<form id="send" aria-labelledby="h-send">
+  <select id="type" aria-label="Event"></select>
+  <input id="payload" aria-label="Event data, as JSON" placeholder='{"by": 2}' autocomplete="off">
+  <button id="submit">Send</button>
+  <output id="error" role="alert"></output>
+</form>
+<h2 id="h-log">Events</h2>
+<table aria-labelledby="h-log">
+<thead><tr><th scope="col">Event</th><th scope="col">State after</th><th scope="col">Changed</th></tr></thead>
+<tbody id="log"></tbody>
+</table>
+<h2 id="h-graph">States</h2>
+<div id="graph" role="region" aria-labelledby="h-graph"></div>
+</main>
+<script type="module">(${dock.toString()})(${JSON.stringify(BRIDGE)}, ${findBridge.toString()});<\/script>
+</body>
+</html>
+`;
+}
+//#endregion
+//#region src/vite/devtools/page.ts
+/** Returns the function the plugin's transform registers each machine's source with. */
+function page(inspect, global, keep, limit) {
+	const entries = [];
+	const byInstance = /* @__PURE__ */ new WeakMap();
+	const sources = /* @__PURE__ */ new WeakMap();
+	const listeners = /* @__PURE__ */ new Set();
+	let count = 0;
+	/** Drops stopped (2) and collected instances: gone from the page, so from the panel. */
+	const prune = () => {
+		for (let k = 0; k < entries.length; k++) {
+			const instance = entries[k].ref.deref();
+			if (!instance || instance.b === 2) entries.splice(k--, 1);
+		}
+	};
+	inspect(({ instance, event, state, changed }) => {
+		let entry = byInstance.get(instance);
+		if (!entry) {
+			entry = {
+				n: ++count,
+				ref: new WeakRef(instance),
+				steps: []
+			};
+			byInstance.set(instance, entry);
+			if (entries.push(entry) > limit) {
+				prune();
+				if (entries.length > limit) entries.splice(0, entries.length - limit);
+			}
+		}
+		if (entry.steps.push({
+			event,
+			state,
+			changed
+		}) > keep) entry.steps.shift();
+		for (const listener of listeners) listener();
+	});
+	globalThis[global] = {
+		live() {
+			const live = [];
+			prune();
+			for (const { n, ref, steps } of entries) {
+				const instance = ref.deref();
+				live.push({
+					n,
+					instance,
+					steps,
+					source: sources.get(instance.M)
+				});
+			}
+			return live;
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => void listeners.delete(listener);
+		}
+	};
+	return (machine, source) => void sources.set(machine, source);
+}
+//#endregion
+//#region src/vite/devtools/sources.ts
+/**
+* Where machines are written, for the panel's links to each state and
+* transition (PLAN §5.8). In dev with Vite DevTools on, every client module
+* that imports `@menapo/machine` gets two things appended, so no line or
+* column of its own code moves:
+*
+* - an import of the page module, which then runs before the module does,
+*   so the panel sees every instance from the first one started;
+* - for each `const x = defineMachine({ … })` at the top level with a
+*   literal config, a call that registers `x`'s source: the file, and per
+*   state path where the state, each `on` event, each `after` delay and its
+*   `always` are written.
+*
+* A config built by helpers is registered as far as it is literal, as M7's
+* compilation will take it (D14).
+*/
+const PACKAGE = "@menapo/machine";
+/** A literal object's properties by key; computed keys and spreads are skipped. */
+function properties(node) {
+	const map = /* @__PURE__ */ new Map();
+	if (node?.type !== "ObjectExpression") return map;
+	for (const property of node.properties) {
+		if (property.type !== "Property" || property.computed) continue;
+		const { key } = property;
+		if (key.type === "Identifier") map.set(key.name, property);
+		else if (key.type === "Literal" && (typeof key.value === "string" || typeof key.value === "number")) map.set(String(key.value), property);
+	}
+	return map;
+}
+/** `code` with the page module's import and its machines' sources appended, or null when it imports nothing from the package. */
+function withSources(code, file) {
+	const { program, errors } = parseSync(file, code);
+	if (errors.length) return null;
+	const define = /* @__PURE__ */ new Set();
+	let imports = false;
+	for (const node of program.body) {
+		if (node.type !== "ImportDeclaration" || node.source.value !== PACKAGE) continue;
+		imports = true;
+		for (const specifier of node.specifiers) if (specifier.type === "ImportSpecifier" && (specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value) === "defineMachine") define.add(specifier.local.name);
+	}
+	if (!imports) return null;
+	const lines = [0];
+	for (let i = code.indexOf("\n"); i >= 0; i = code.indexOf("\n", i + 1)) lines.push(i + 1);
+	const loc = (offset) => {
+		let low = 0;
+		let high = lines.length - 1;
+		while (low < high) {
+			const mid = low + high + 1 >> 1;
+			if (lines[mid] <= offset) low = mid;
+			else high = mid - 1;
+		}
+		return [low + 1, offset - lines[low] + 1];
+	};
+	const keys = (node) => {
+		const out = {};
+		for (const [key, property] of properties(node)) out[key] = loc(property.start);
+		return out;
+	};
+	let out = `\nimport { source as __machineSource } from ${JSON.stringify(PAGE_ID)};\n`;
+	for (const statement of program.body) {
+		const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+		if (declaration?.type !== "VariableDeclaration") continue;
+		for (const { id, init } of declaration.declarations) {
+			if (id.type !== "Identifier" || init?.type !== "CallExpression" || init.callee.type !== "Identifier" || !define.has(init.callee.name) || init.arguments[0]?.type !== "ObjectExpression") continue;
+			const config = properties(init.arguments[0]);
+			const states = { "": {
+				at: loc(init.start),
+				on: keys(config.get("on")?.value),
+				after: {}
+			} };
+			const walk = (node, prefix) => {
+				for (const [key, property] of properties(node)) {
+					const path = prefix ? `${prefix}.${key}` : key;
+					const state = properties(property.value);
+					const always = state.get("always");
+					states[path] = {
+						at: loc(property.start),
+						on: keys(state.get("on")?.value),
+						after: keys(state.get("after")?.value),
+						...always ? { always: loc(always.start) } : {}
+					};
+					walk(state.get("states")?.value, path);
+				}
+			};
+			walk(config.get("states")?.value, "");
+			const source = {
+				file,
+				binding: id.name,
+				states
+			};
+			out += `__machineSource(${id.name}, ${JSON.stringify(source)});\n`;
+		}
+	}
+	return code + out;
+}
+//#endregion
+//#region src/vite/devtools/plugin.ts
+/**
+* `machine:devtools` (PLAN §5.8): the panel in the Vite DevTools dock, by
+* the mechanism vi18n's dock uses. Vite DevTools calls a plugin's
+* `devtools.setup` only when the user turned it on and installed
+* `@vitejs/devtools`, so the plugin imports nothing from it and, until
+* `setup` runs, does nothing: no page module, no transform, no route.
+*
+* Once on, in dev only:
+*
+* - `setup` registers the dock: an iframe of `<base>__machine/dock`, served
+*   here as one self-contained document (`dock.ts`);
+* - every client module that imports `@menapo/machine` imports the page
+*   module (`virtual:machine/devtools`), which watches instances through
+*   `inspect` (D17) and puts the bridge the dock reads on the page, and
+*   registers its machines' sources (`sources.ts`).
+*
+* A build never runs this plugin, so production bundles import neither the
+* page module nor `inspect`, and the core's hook calls drop out with them.
+*/
+const dockEntry = (base) => dockEntry$1({
+	id: "machine",
+	title: "Machines",
+	icon: "ph:graph-duotone"
+}, base, DOCK_PATH);
+/** The page module: the app's own `inspect`, handed to {@link page}'s source. */
+const pageModule = () => `import { inspect } from "@menapo/machine";\nexport const source = (${page.toString()})(inspect, ${JSON.stringify(BRIDGE)}, 100, 500);\n`;
+const RESOLVED = "\0" + PAGE_ID;
+function devtoolsPlugin() {
+	let on = false;
+	return {
+		name: "machine:devtools",
+		apply: "serve",
+		enforce: "pre",
+		devtools: { setup(context) {
+			on = true;
+			context.docks.register(dockEntry(context.viteConfig.base));
+		} },
+		configureServer(server) {
+			serveDock(server, DOCK_PATH, () => on, dockPage);
+		},
+		resolveId: {
+			filter: { id: /^virtual:machine\/devtools$/ },
+			handler: (id) => "\0" + id
+		},
+		load: {
+			filter: { id: /^\0virtual:machine\/devtools$/ },
+			handler: (id) => id === RESOLVED ? {
+				code: pageModule(),
+				moduleType: "js"
+			} : null
+		},
+		transform: {
+			filter: {
+				id: {
+					include: /\.[cm]?[jt]sx?(?:\?|$)/,
+					exclude: /\/node_modules\//
+				},
+				code: "@menapo/machine"
+			},
+			handler(code, id) {
+				if (!on || this.environment.config.consumer !== "client") return null;
+				const out = withSources(code, id.split("?")[0]);
+				return out === null ? null : {
+					code: out,
+					map: null
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region src/vite.ts
+/**
+* `@menapo/machine/vite`: the plugin that resolves `useMachine` per
+* framework, validates and precompiles machines, and adds the DevTools panel
+* (PLAN §5.5, §5.6, §5.8). The only entry that may import from the build side.
+*
+* M3 brought the resolution: each module's `useMachine` comes from the glue
+* of its framework (`src/glue/`), on `@menapo/glue`'s adapters. M6 brought
+* the DevTools panel, M7 the compilation of literal machines (`compile/`).
+*/
+const GLUE = posix(fileURLToPath(new URL("./glue/", import.meta.url)));
+const EXT = import.meta.url.endsWith(".ts") ? ".ts" : ".js";
+const INDEX = posix(fileURLToPath(new URL("./index" + EXT, import.meta.url)));
+/** `plugins: [machine()]` in a Vite config. */
+function machine(options = {}) {
+	return [
+		configPlugin(),
+		devtoolsPlugin(),
+		...options.compile === false ? [] : [compilePlugin({
+			runtime: "@menapo/machine/compiled",
+			index: INDEX
+		})],
+		gluePlugin({
+			name: "machine:glue",
+			package: "@menapo/machine",
+			hooks: ["useMachine"],
+			module: (framework) => GLUE + (framework === "svelte" ? "svelte.svelte" : framework) + EXT,
+			dirs: [GLUE],
+			framework: options.framework
+		})
+	];
+}
+//#endregion
+export { machine };