@swiftuijs/twill 0.1.2 → 0.3.0

package/dist/{compiler-Bi9TNOhX.js → compiler-CbNSBUI2.js}

@@ -2,7 +2,7 @@ import MagicString from "magic-string";
 import { Parser, tokTypes } from "acorn";
 import { tsPlugin } from "acorn-typescript";
 import jsx from "acorn-jsx";
-import { GREATEST_LOWER_BOUND, TraceMap, generatedPositionFor, originalPositionFor } from "@jridgewell/trace-mapping";
+import { GREATEST_LOWER_BOUND, TraceMap, decodedMappings, encodedMappings, generatedPositionFor, originalPositionFor } from "@jridgewell/trace-mapping";
 //#region src/parser.js
 var options = {
 	ecmaVersion: "latest",
@@ -80,7 +80,8 @@ function exits(node) {
 		case "BreakStatement":
 		case "ContinueStatement": return true;
 		case "BlockStatement": return node.body.some(exits);
-		case "IfStatement": return !!node.alternate && exits(node.consequent) && exits(node.alternate);
+		case "IfStatement":
+		case "TwillIfBinding": return !!node.alternate && exits(node.consequent) && exits(node.alternate);
 		default: return false;
 	}
 }
@@ -174,17 +175,83 @@ function moveNodes(node, delta, locate) {
 	}
 }
 var parsers = /* @__PURE__ */ new Map();
+function associatedEnumAt(input, offset) {
+	try {
+		const tokens = Parser.tokenizer(input.slice(offset), { ecmaVersion: "latest" });
+		tokens.getToken();
+		const next = tokens.getToken();
+		return next.value === "<" || next.type === tokTypes.braceL && tokens.getToken().type === tokTypes._case && tokens.getToken().type === tokTypes.name;
+	} catch {
+		return false;
+	}
+}
 function parserFor(language) {
 	if (parsers.has(language)) return parsers.get(language);
 	const Base = bases[language];
 	class TwillParser extends Base {
+		declareName(name, bindingType, position) {
+			if (bindingType === 6 || bindingType === 7) {
+				const scope = this.currentScope();
+				(scope.types ??= []).push(name);
+				if (this.inModule && scope.flags & 1) delete this.undefinedExports[name];
+				return;
+			}
+			super.declareName(name, bindingType, position);
+		}
 		skipHeader = null;
 		closures = [];
 		lineStarts = null;
 		classSuperDepth = null;
 		subscriptDepth = 0;
+		conditionDepth = null;
 		derivedClassElement = false;
 		implicitClosure = null;
+		tsParseEnumDeclaration(node, modifiers = {}) {
+			if (!associatedEnumAt(this.input, this.end)) return super.tsParseEnumDeclaration(node, modifiers);
+			if (modifiers.const || modifiers.declare || this.isAmbientContext) this.raise(node.start, "Associated-value enums cannot be const or ambient declarations.");
+			this.expectContextual("enum");
+			node.id = this.parseIdent();
+			this.checkLValSimple(node.id, 2);
+			node.typeParameters = this.tsTryParseTypeParameters(() => {
+				if (this.type === tokTypes._in || this.isContextual("out") && this.lookahead().type === tokTypes.name) this.raise(this.start, "Associated-value enum type parameters cannot have const/in/out modifiers.");
+			});
+			const constant = node.typeParameters?.params.find((parameter) => parameter.const);
+			if (constant) this.raise(constant.start, "Associated-value enum type parameters cannot have const/in/out modifiers.");
+			node.braceStart = this.start;
+			this.expect(tokTypes.braceL);
+			node.cases = [];
+			const names = /* @__PURE__ */ new Set();
+			while (this.type !== tokTypes.braceR) {
+				const branch = this.startNode();
+				this.expect(tokTypes._case);
+				branch.id = this.parseIdent();
+				if (names.has(branch.id.name)) this.raise(branch.id.start, "Duplicate enum case.");
+				names.add(branch.id.name);
+				branch.params = [];
+				branch.hasParens = this.eat(tokTypes.parenL);
+				if (branch.hasParens) {
+					const fields = /* @__PURE__ */ new Set();
+					while (this.type !== tokTypes.parenR) {
+						const field = this.parseIdent();
+						this.checkLValSimple(field);
+						if (field.name === "kind") this.raise(field.start, "Enum payload fields cannot use the discriminator name kind.");
+						if (fields.has(field.name)) this.raise(field.start, "Duplicate enum payload field.");
+						fields.add(field.name);
+						if (this.type !== tokTypes.colon) this.raise(this.start, "Enum payload fields require a name and type; optional/default/rest fields are unsupported.");
+						field.typeAnnotation = this.tsParseTypeAnnotation();
+						branch.params.push(field);
+						if (!this.eat(tokTypes.comma)) break;
+					}
+					this.expect(tokTypes.parenR);
+				}
+				branch.valueEnd = this.lastTokEnd;
+				this.semicolon();
+				node.cases.push(this.finishNode(branch, "TwillEnumCase"));
+			}
+			if (!node.cases.length) this.raise(node.start, "An associated-value enum needs at least one case.");
+			this.next();
+			return this.finishNode(node, "TwillEnumDeclaration");
+		}
 		locate(offset) {
 			if (!this.lineStarts) {
 				this.lineStarts = [0];
@@ -223,7 +290,11 @@ function parserFor(language) {
 				node.cleanup = cleanup;
 				return this.finishNode(node, "DeferStatement");
 			}
-			if (!this.isContextual("guard") || !guardAt(this.input, this.end, !!this.implicitClosure)) return super.parseStatement(context, ...args);
+			if (!this.isContextual("guard") || !guardAt(this.input, this.end, !!this.implicitClosure)) {
+				const statement = super.parseStatement(context, ...args);
+				if (context && statement.type === "TwillEnumDeclaration") this.raise(statement.start, "An associated-value enum requires a block; add braces around this body.");
+				return statement;
+			}
 			const node = this.startNode();
 			node.singleStatement = !!context;
 			this.next();
@@ -243,6 +314,36 @@ function parserFor(language) {
 			if (!exits(node.failure)) this.raise(node.failure.start, "Every guard else path must exit with return, throw, break or continue.");
 			return this.finishNode(node, "GuardStatement");
 		}
+		parseIfStatement(node) {
+			if (/^\s*\(/.test(this.input.slice(this.end))) return super.parseIfStatement(node);
+			let binding;
+			try {
+				binding = Parser.tokenizer(this.input.slice(this.end), options).getToken().type;
+			} catch {}
+			if (binding !== tokTypes._const) return super.parseIfStatement(node);
+			this.next();
+			const declaration = this.startNode();
+			this.next();
+			this.enterScope(0);
+			const previous = this.conditionDepth;
+			this.conditionDepth = this.subscriptDepth;
+			try {
+				this.parseVar(declaration, false, "const");
+			} finally {
+				this.conditionDepth = previous;
+			}
+			node.binding = this.finishNode(declaration, "VariableDeclaration");
+			if (node.binding.declarations.length !== 1) this.raise(node.start, "if const requires one binding declaration.");
+			if (this.type !== tokTypes.braceL) this.raise(this.start, "if const requires a braced success branch.");
+			node.consequent = this.parseBlock(false);
+			this.exitScope();
+			node.alternate = null;
+			if (this.eat(tokTypes._else)) {
+				if (this.type !== tokTypes.braceL && this.type !== tokTypes._if) this.raise(this.start, "if const else requires a block or another if.");
+				node.alternate = this.parseStatement("if");
+			}
+			return this.finishNode(node, "TwillIfBinding");
+		}
 		tsParseTypeParameter(...args) {
 			const start = this.start;
 			const loc = this.startLoc;
@@ -314,12 +415,21 @@ function parserFor(language) {
 			}
 			return super.parseExprAtom(...args);
 		}
-		parseSwitchExpression() {
-			const node = this.startNode();
-			this.next();
-			node.parenStart = this.start;
-			node.discriminant = this.parseParenExpression();
-			node.parenEnd = this.lastTokStart;
+		parseSwitchExpression(call) {
+			const node = call ? this.startNodeAt(call.start, call.loc.start) : this.startNode();
+			node.keyword = call ? "match" : "switch";
+			if (call) {
+				if (call.arguments.length !== 1 || call.arguments[0].type === "SpreadElement") this.raise(call.start, "A match expression requires one subject; parenthesize comma expressions.");
+				const opening = Parser.tokenizer(this.input.slice(call.callee.end), options).getToken();
+				node.parenStart = call.callee.end + opening.start;
+				node.discriminant = call.arguments[0];
+				node.parenEnd = call.end - 1;
+			} else {
+				this.next();
+				node.parenStart = this.start;
+				node.discriminant = this.parseParenExpression();
+				node.parenEnd = this.lastTokStart;
+			}
 			this.expect(tokTypes.braceL);
 			node.cases = [];
 			let mode, discriminator, sawDefault = false;
@@ -333,6 +443,34 @@ function parserFor(language) {
 					if (sawDefault) this.raise(branch.start, "Multiple default clauses.");
 					sawDefault = true;
 					branch.test = null;
+				} else if (call && this.type !== tokTypes.braceL || !call && this.type.label === "name" && this.value === "enum" && !this.containsEsc) {
+					if (mode === "value") this.raise(branch.start, "Cannot mix enum patterns and value cases.");
+					if (discriminator !== void 0 && discriminator !== "kind") this.raise(branch.start, "Enum patterns require the kind discriminator.");
+					mode = "pattern";
+					discriminator = "kind";
+					const pattern = this.startNode();
+					pattern.explicitKeyword = !call;
+					if (!call) this.next();
+					let reference = this.parseIdent();
+					while (this.eat(tokTypes.dot)) {
+						const member = this.startNodeAt(reference.start, reference.loc.start);
+						member.object = reference;
+						member.property = this.parseIdent(true);
+						member.computed = false;
+						member.optional = false;
+						reference = this.finishNode(member, "MemberExpression");
+					}
+					if (reference.type !== "MemberExpression") this.raise(reference.start, "An enum pattern requires a qualified case reference.");
+					pattern.reference = reference;
+					pattern.parenStart = this.start;
+					this.expect(tokTypes.parenL);
+					if (this.type === tokTypes.braceL) {
+						pattern.binding = this.parseObj(true);
+						this.checkLValPattern(pattern.binding, 2, false);
+					}
+					pattern.parenEnd = this.start;
+					this.expect(tokTypes.parenR);
+					branch.enumPattern = this.finishNode(pattern, "TwillEnumPattern");
 				} else if (this.type === tokTypes.braceL) {
 					if (mode === "value") this.raise(branch.start, "Cannot mix object patterns and value cases.");
 					mode = "pattern";
@@ -378,7 +516,7 @@ function parserFor(language) {
 				node.cases.push(this.finishNode(branch, "TwillSwitchCase"));
 			}
 			this.next();
-			if (!node.cases.length) this.raise(node.start, "A switch expression requires at least one arm.");
+			if (!node.cases.length) this.raise(node.start, `A ${node.keyword} expression requires at least one arm.`);
 			node.discriminator = discriminator;
 			return this.finishNode(node, "TwillSwitchExpression");
 		}
@@ -441,6 +579,13 @@ function parserFor(language) {
 		}
 		parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit) {
 			const classBody = this.classSuperDepth !== null && this.subscriptDepth === this.classSuperDepth + 1;
+			if (!noCalls && !classBody && this.type === tokTypes.braceL && base.type === "CallExpression" && !base.optional && !base.typeParameters && base.callee.type === "Identifier" && base.callee.name === "match" && base.callee.start === base.start && this.input.slice(base.callee.start, base.callee.end) === "match") {
+				let first;
+				try {
+					first = Parser.tokenizer(this.input.slice(this.end), options).getToken().type;
+				} catch {}
+				if (first === tokTypes._case || first === tokTypes._default) return this.parseSwitchExpression(base);
+			}
 			if (!noCalls && !classBody && this.tsMatchLeftRelational?.() && this.start === base.end) {
 				const parameters = this.tsTryParseAndCatch(() => {
 					const parsed = this.tsParseTypeArgumentsInExpression();
@@ -459,6 +604,7 @@ function parserFor(language) {
 				"MemberExpression",
 				"TSInstantiationExpression"
 			].includes(base.type);
+			if (this.conditionDepth !== null && this.subscriptDepth === this.conditionDepth + 1 && this.type === tokTypes.braceL) return base;
 			if (!noCalls && supported && this.type === tokTypes.braceL && !classBody) {
 				if (base.trailing) this.raise(this.start, "Additional trailing closures require labels (for example completion: { ... }).");
 				if (base.type !== "CallExpression" && /[\r\n]/.test(this.input.slice(base.end, this.start))) return base;
@@ -512,18 +658,23 @@ function parse(source, language = "ts", sourceType = "module") {
 	const live = /* @__PURE__ */ new Set();
 	const calls = [];
 	const guards = [];
+	const ifBindings = [];
 	const defers = [];
 	const switches = [];
+	const enums = [];
 	const visit = (node) => {
 		if (!node || typeof node !== "object") return;
 		if (node.type === "ArrowFunctionExpression" || node.type === "Identifier" && node.start === node.end && node.name === "__twillImplicit") live.add(node);
 		if (node.trailing) calls.push(node);
 		if (node.type === "GuardStatement") guards.push(node);
+		if (node.type === "TwillIfBinding") ifBindings.push(node);
 		if (node.type === "DeferStatement") defers.push(node);
 		if (node.type === "TwillSwitchExpression") switches.push(node);
-		for (const [key, value] of Object.entries(node)) {
+		if (node.type === "TwillEnumDeclaration") enums.push(node);
+		for (const key of Object.keys(node)) {
 			if (key === "trailing" || key === "loc") continue;
-			if (Array.isArray(value)) value.forEach(visit);
+			const value = node[key];
+			if (Array.isArray(value)) for (const child of value) visit(child);
 			else if (value?.type) visit(value);
 		}
 	};
@@ -532,8 +683,10 @@ function parse(source, language = "ts", sourceType = "module") {
 		ast,
 		calls,
 		guards,
+		ifBindings,
 		defers,
 		switches,
+		enums,
 		comments,
 		closures: parser.closures.filter((closure) => live.has(closure.node)).map((closure) => ({
 			...closure,
@@ -542,6 +695,11 @@ function parse(source, language = "ts", sourceType = "module") {
 	};
 }
 //#endregion
+//#region src/defer-helper.ts
+function syncDeferBody(names) {
+	return "\n  let " + names.failed + " = false,\n    " + names.failure + ";\n  while (" + names.stack + "?.length) {\n    const " + names.cleanup + " = " + names.stack + ".pop();\n    if (" + names.cleanup + ") {\n      try {\n        " + names.cleanup + "();\n      } catch (" + names.error + ") {\n        " + names.failed + " = true;\n        " + names.failure + " = " + names.error + ";\n      }\n    }\n  }\n  if (" + names.failed + ") throw " + names.failure + ";\n";
+}
+//#endregion
 //#region src/defer.ts
 var functions = /* @__PURE__ */ new Set([
 	"FunctionDeclaration",
@@ -549,16 +707,16 @@ var functions = /* @__PURE__ */ new Set([
 	"ArrowFunctionExpression"
 ]);
 function children(node, visit) {
-	for (const [key, value] of Object.entries(node)) {
+	for (const key of Object.keys(node)) {
 		if (key === "loc" || key === "trailing") continue;
-		if (Array.isArray(value)) value.forEach((child) => {
-			if (child?.type) visit(child);
-		});
-		else if (value?.type) visit(value);
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const child of value) if (child?.type) visit(child);
+		} else if (value?.type) visit(value);
 	}
 }
-/** Scope-local cleanup callbacks; dynamic registrations use lazy stacks. */
-function lowerDefers(source, ast, code, language, usedNames, contentStarts, comments, fail) {
+/** Native finally where scope permits; callbacks retain dynamic registration semantics. */
+function lowerDefers(source, ast, code, language, usedNames, contentStarts, comments, runtime, sourceType, fail) {
 	const scopes = [];
 	const visit = (node, scope, parent) => {
 		if (functions.has(node.type) || [
@@ -607,10 +765,40 @@ function lowerDefers(source, ast, code, language, usedNames, contentStarts, comm
 		}
 		return start;
 	};
+	let sharedHelper;
 	for (const scope of scopes) {
 		if (!scope.defers.length) continue;
 		const { block } = scope;
 		const statements = block.body;
+		const first = statements.indexOf(scope.defers[0]);
+		let native = first >= 0 && scope.defers.every((node) => !node.awaited && statements.includes(node));
+		if (native) {
+			native = !statements.some((node, index) => node.type === "FunctionDeclaration" || node.type === "TSDeclareFunction" || node.type === "VariableDeclaration" && node.kind.endsWith("using") || index > first && (node.type === "VariableDeclaration" && node.kind !== "var" || node.type.endsWith("Declaration") && node.type !== "VariableDeclaration" || node.type === "GuardStatement" && node.binding));
+			const check = (node) => {
+				if (node.type === "WithStatement" || node.type === "ThisExpression" || node.type === "VariableDeclarator" && !node.init || node.type === "VariableDeclaration" && node.kind === "var" && (!statements.includes(node) || node.start > scope.defers[0].start) || node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "eval") native = false;
+				children(node, check);
+			};
+			if (native) check(block);
+			const cleanupScope = (node) => {
+				if (node.type === "FunctionDeclaration" || node.directive || node.type === "VariableDeclaration" && node.kind === "var") native = false;
+				if (!functions.has(node.type)) children(node, cleanupScope);
+			};
+			if (native) for (const node of scope.defers) cleanupScope(node.cleanup.body);
+		}
+		if (native) {
+			for (const node of [...scope.defers].reverse()) {
+				code.overwrite(node.start, node.cleanup.body.start, ";try {");
+				if (!node.cleanup.body.body.length) {
+					code.remove(node.cleanup.body.start, node.cleanup.body.end);
+					code.appendLeft(block.end - 1, "\n} finally " + source.slice(node.cleanup.body.start, node.cleanup.body.end) + "\n");
+					continue;
+				}
+				code.prependRight(node.cleanup.body.start, "\n} finally ");
+				code.appendLeft(node.cleanup.body.end, "\n");
+				if (node.cleanup.body.end !== block.end - 1) code.move(node.cleanup.body.start, node.cleanup.body.end, block.end - 1);
+			}
+			continue;
+		}
 		const single = scope.defers.length === 1 && statements.includes(scope.defers[0]);
 		const stack = fresh(single ? "Cleanup" : "Defers");
 		const failure = single ? "" : fresh("Failure");
@@ -631,7 +819,7 @@ function lowerDefers(source, ast, code, language, usedNames, contentStarts, comm
 		const declarations = scope.functionBody ? ordinary.filter((node) => node.type === "FunctionDeclaration") : [];
 		if (scope.functionBody && ordinary.some((node) => node.type === "TSDeclareFunction")) fail(ordinary.find((node) => node.type === "TSDeclareFunction"), "Function overloads/ambient function declarations in a defer scope are not supported; move them to a separate scope.");
 		const names = [...new Set(declarations.map((node) => node.id.name))];
-		code.appendLeft(start, `;${jsdoc}let ${stack}${annotation};${names.length ? `var ${names.join(",")};` : ""}try {\n`);
+		code.prependLeft(start, `;${jsdoc}let ${stack}${annotation};${names.length ? `var ${names.join(",")};` : ""}try {\n`);
 		let anchor = start;
 		const initial = /* @__PURE__ */ new Set();
 		for (const statement of ordinary) {
@@ -655,11 +843,37 @@ function lowerDefers(source, ast, code, language, usedNames, contentStarts, comm
 		}
 		if (single) {
 			const call = allAsync ? `if (${stack}) await ${stack}();` : `${stack}?.();`;
-			code.prependLeft(block.end - 1, `\n} finally { ${call} }\n`);
+			code.appendLeft(block.end - 1, `\n} finally { ${call} }\n`);
+			continue;
+		}
+		if (!anyAsync) {
+			let body;
+			if (runtime === "external") {
+				if (sourceType !== "module") fail(scope.defers[0], "External runtime helpers require module sourceType; use runtime: inline for scripts.");
+				sharedHelper ??= fresh("RunDefers");
+				body = `${sharedHelper}(${stack});`;
+			} else body = syncDeferBody({
+				stack,
+				failed,
+				failure,
+				cleanup: callback,
+				error
+			});
+			code.appendLeft(block.end - 1, `} finally { ${body} }`);
 			continue;
 		}
 		const call = mixed ? `if (${callback}.async) await ${callback}.run(); else ${callback}.run();` : `${allAsync ? "await " : ""}${callback}();`;
-		code.prependLeft(block.end - 1, `} finally { let ${failed} = false, ${failure}; while (${stack}?.length) { const ${callback} = ${stack}.pop(); if (${callback}) { try { ${call} } catch (${error}) { ${failed} = true; ${failure} = ${error}; } } } if (${failed}) throw ${failure}; }`);
+		code.appendLeft(block.end - 1, `} finally { let ${failed} = false, ${failure}; while (${stack}?.length) { const ${callback} = ${stack}.pop(); if (${callback}) { try { ${call} } catch (${error}) { ${failed} = true; ${failure} = ${error}; } } } if (${failed}) throw ${failure}; }`);
+	}
+	if (sharedHelper) {
+		let start = ast.body.find((node) => !node.directive).start;
+		for (const comment of sortedComments) {
+			if (comment.end > start) continue;
+			if (/\S/.test(source.slice(comment.end, start))) break;
+			if ((source.startsWith("/**", comment.start) || /@ts-(?:ignore|expect-error)\b/.test(comment.value)) && !/@(?:ts-(?:check|nocheck)|jsxImportSource|jsxRuntime)\b/.test(comment.value)) start = comment.start;
+			else break;
+		}
+		code.prependLeft(start, `\nimport { runDefers as ${sharedHelper} } from '@swiftuijs/twill-runtime/helpers/v1';\n`);
 	}
 }
 //#endregion
@@ -683,22 +897,68 @@ function suspension(node) {
 		}
 	}
 }
-/** Native switches with per-arm scopes; expression contexts use a synchronous
-* lexical IIFE. Direct returns need no extra function or scheduling. */
-function lowerSwitchExpressions(source, ast, switches, code, language, usedNames, fail) {
+/** Native switches with per-arm scopes. Direct returns and standalone variable
+* initializers need no extra function; other expressions keep a lexical IIFE. */
+function lowerSwitchExpressions(source, ast, switches, code, language, usedNames, comments, fail) {
 	const returns = /* @__PURE__ */ new Set();
-	const visit = (node) => {
+	const initializers = /* @__PURE__ */ new Map();
+	const leadingDoc = (start) => {
+		let low = 0, high = comments.length;
+		while (low < high) {
+			const middle = low + high >>> 1;
+			if (comments[middle].end <= start) low = middle + 1;
+			else high = middle;
+		}
+		const comment = comments[low - 1];
+		return comment && /^\s*$/.test(source.slice(comment.end, start)) ? comment : void 0;
+	};
+	const directEval = (node) => {
+		if ([
+			"FunctionDeclaration",
+			"FunctionExpression",
+			"ArrowFunctionExpression"
+		].includes(node.type)) return false;
+		if (node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "eval" && !node.optional) return true;
+		return Object.entries(node).some(([key, value]) => ![
+			"loc",
+			"trailing",
+			"tag"
+		].includes(key) && (Array.isArray(value) ? value : [value]).some((child) => child?.type && directEval(child)));
+	};
+	const grouping = (start, end, initializer = false) => {
+		const parentheses = [];
+		const tokens = Parser.tokenizer(source.slice(start, end), { ecmaVersion: "latest" });
+		for (;;) {
+			const token = tokens.getToken();
+			if (token.type === tokTypes.eof) break;
+			if (initializer && token.type === tokTypes.eq) parentheses.length = 0;
+			if (token.type === tokTypes.parenL || token.type === tokTypes.parenR) parentheses.push(token);
+		}
+		for (const token of parentheses) code.remove(start + token.start, start + token.end);
+	};
+	const visit = (node, parent) => {
+		if (node.type === "VariableDeclaration" && node.declarations.length === 1) {
+			const declaration = node.declarations[0];
+			if (declaration.id.type === "Identifier" && declaration.init?.type === "TwillSwitchExpression" && [
+				"Program",
+				"BlockStatement",
+				"SwitchCase",
+				"ExportNamedDeclaration"
+			].includes(parent?.type ?? "")) {
+				const statement = parent?.type === "ExportNamedDeclaration" ? parent : node;
+				const comment = leadingDoc(statement.start);
+				const prefixStart = comment && source.startsWith("/**", comment.start) ? comment.start : statement.start;
+				if (!(comment && /@ts-(?:ignore|expect-error|nocheck|check)\b/.test(source.slice(comment.start, comment.end))) && !directEval(declaration.init) && (language.startsWith("ts") || prefixStart === statement.start)) initializers.set(declaration.init, {
+					declaration,
+					statement,
+					prefixStart
+				});
+			}
+		}
 		if (node.type === "ReturnStatement" && node.argument?.type === "TwillSwitchExpression") {
 			returns.add(node.argument);
 			code.remove(node.start, node.start + 6);
-			for (const [start, end] of [[node.start + 6, node.argument.start], [node.argument.end, node.end]]) {
-				const tokens = Parser.tokenizer(source.slice(start, end), { ecmaVersion: "latest" });
-				for (;;) {
-					const token = tokens.getToken();
-					if (token.type === tokTypes.eof) break;
-					if (token.type === tokTypes.parenL || token.type === tokTypes.parenR) code.remove(start + token.start, start + token.end);
-				}
-			}
+			for (const [start, end] of [[node.start + 6, node.argument.start], [node.argument.end, node.end]]) grouping(start, end);
 		}
 		for (const [key, value] of Object.entries(node)) {
 			if ([
@@ -706,7 +966,7 @@ function lowerSwitchExpressions(source, ast, switches, code, language, usedNames
 				"trailing",
 				"tag"
 			].includes(key)) continue;
-			for (const child of Array.isArray(value) ? value : [value]) if (child?.type) visit(child);
+			for (const child of Array.isArray(value) ? value : [value]) if (child?.type) visit(child, node);
 		}
 	};
 	visit(ast);
@@ -722,34 +982,268 @@ function lowerSwitchExpressions(source, ast, switches, code, language, usedNames
 	for (const node of switches) {
 		const direct = returns.has(node);
 		const suspended = !direct && suspension(node);
-		if (suspended) fail(suspended, "await/yield inside a switch expression requires a direct return. Bind the subject first, or await the whole result explicitly.");
+		if (suspended) fail(suspended, `await/yield inside a ${node.keyword} expression requires a direct return. Bind the subject first, or await the whole result explicitly.`);
+		const initializer = initializers.get(node);
+		const result = initializer ? fresh("Result") : void 0;
+		const exit = initializer ? fresh("Exit") : void 0;
 		const subject = fresh("Subject");
-		code.appendLeft(node.start, `${direct ? "{" : "(() => {"}const ${subject} = `);
+		if (initializer) {
+			const { declaration, statement, prefixStart } = initializer;
+			const annotation = language.startsWith("ts") && declaration.id.typeAnnotation ? `: typeof ${declaration.id.name}` : "";
+			grouping(declaration.id.end, node.start, true);
+			grouping(node.end, statement.end);
+			code.appendLeft(prefixStart, `let ${result}${annotation}; ${exit}: {const ${subject} = `);
+			if (prefixStart < statement.start) code.prependRight(prefixStart, "\n");
+			code.move(prefixStart, node.start, node.end);
+			code.appendRight(node.end, ` ${result}`);
+		}
+		const valuePrefix = result ? `${result} = (` : "return ";
+		const valueSuffix = result ? `); break ${exit};` : ";";
+		const kind = node.cases.some((branch) => branch.enumPattern) ? fresh("Kind") : void 0;
+		if (!initializer) code.appendLeft(node.start, `${direct ? "{" : "(() => {"}const ${subject} = `);
 		code.remove(node.parenStart, node.parenStart + 1);
-		code.move(node.start, node.start + 6, node.parenEnd);
-		code.appendLeft(node.parenEnd, "; ");
-		code.overwrite(node.parenEnd, node.parenEnd + 1, ` (${subject}${node.discriminator === void 0 ? "" : `[${JSON.stringify(node.discriminator)}]`})`);
-		for (const branch of node.cases) if (branch.pattern) {
+		if (node.keyword === "match") {
+			const tokens = Parser.tokenizer(source.slice(node.discriminant.end, node.parenEnd), { ecmaVersion: "latest" });
+			for (;;) {
+				const token = tokens.getToken();
+				if (token.type === tokTypes.eof) break;
+				if (token.type === tokTypes.comma) code.remove(node.discriminant.end + token.start, node.discriminant.end + token.end);
+			}
+		}
+		const keywordEnd = node.start + (node.keyword === "match" ? 5 : 6);
+		if (node.keyword === "match") code.overwrite(node.start, keywordEnd, "switch");
+		code.move(node.start, keywordEnd, node.parenEnd);
+		code.appendLeft(node.parenEnd, `; ${kind ? `const ${kind} = ${subject}["kind"]; ` : ""}`);
+		code.overwrite(node.parenEnd, node.parenEnd + 1, ` (${kind ?? subject}${kind || node.discriminator === void 0 ? "" : `[${JSON.stringify(node.discriminator)}]`})`);
+		for (const branch of node.cases) if (branch.enumPattern) {
+			const { reference, binding, start, parenStart, parenEnd, explicitKeyword } = branch.enumPattern;
+			const tag = JSON.stringify(reference.property.name);
+			if (language.startsWith("ts")) {
+				const witness = `(${tag} satisfies (typeof `;
+				if (explicitKeyword) code.overwrite(start, start + 4, witness);
+				else code.appendLeft(start, witness);
+				code.appendLeft(reference.end, ` extends (...args: never[]) => { readonly kind: ${tag} } ? ${tag} : never))`);
+			} else if (explicitKeyword) {
+				code.overwrite(start, start + 4, tag);
+				code.remove(reference.start, reference.end);
+			} else code.overwrite(reference.start, reference.end, tag);
+			code.remove(parenStart, parenStart + 1);
+			code.remove(parenEnd, parenEnd + 1);
+			if (binding) {
+				code.appendLeft(binding.start, ": { const ");
+				code.overwrite(branch.colonStart, branch.colonStart + 1, ` = ${subject}; ${branch.throw ? "" : valuePrefix}`);
+				code.appendLeft(branch.valueEnd, `${branch.throw ? ";" : valueSuffix} }`);
+				if (source[branch.end - 1] === ";") code.remove(branch.end - 1, branch.end);
+			} else if (!branch.throw) {
+				code.appendLeft(branch.colonStart + 1, ` ${valuePrefix}`);
+				if (result) {
+					code.appendLeft(branch.valueEnd, valueSuffix);
+					if (source[branch.end - 1] === ";") code.remove(branch.end - 1, branch.end);
+				}
+			}
+		} else if (branch.pattern) {
 			const { pattern, tag } = branch;
 			code.appendLeft(tag.value.start, fresh("Tag"));
 			code.move(tag.value.start, tag.value.end, pattern.start);
 			code.appendLeft(tag.value.end, ": { const ");
-			code.overwrite(branch.colonStart, branch.colonStart + 1, ` = ${subject}; ${branch.throw ? "" : "return "}`);
-			code.appendLeft(branch.valueEnd, "; }");
+			code.overwrite(branch.colonStart, branch.colonStart + 1, ` = ${subject}; ${branch.throw ? "" : valuePrefix}`);
+			code.appendLeft(branch.valueEnd, `${branch.throw ? ";" : valueSuffix} }`);
 			if (source[branch.end - 1] === ";") code.remove(branch.end - 1, branch.end);
-		} else if (!branch.throw) code.appendLeft(branch.colonStart + 1, " return ");
-		const hasDefault = node.cases.some((branch) => !branch.pattern && branch.test === null);
-		const check = !hasDefault && language.startsWith("ts") ? ` ${subject} satisfies never;` : "";
+		} else if (!branch.throw) {
+			code.appendLeft(branch.colonStart + 1, ` ${valuePrefix}`);
+			if (result) {
+				code.appendLeft(branch.valueEnd, valueSuffix);
+				if (source[branch.end - 1] === ";") code.remove(branch.end - 1, branch.end);
+			}
+		}
+		const hasDefault = node.cases.some((branch) => !branch.pattern && !branch.enumPattern && branch.test === null);
+		const check = !hasDefault && language.startsWith("ts") ? ` ${kind ? `(0 as unknown as typeof ${kind})` : subject} satisfies never;` : "";
 		const failure = hasDefault ? "" : `${check} throw new TypeError('Non-exhaustive switch expression');`;
-		code.overwrite(node.end - 1, node.end, `}${failure}${direct ? "}" : "})()"}`);
+		code.overwrite(node.end - 1, node.end, `}${failure}${direct || initializer ? "}" : "})()"}`, { contentOnly: true });
 	}
 }
 //#endregion
-//#region src/compiler.ts
-var extensions = [".twill", ".twillx"];
-function isTwillFile(id) {
-	return extensions.some((extension) => id.split(/[?#]/, 1)[0].endsWith(extension));
+//#region src/enums.ts
+/** Find free type references, respecting generic function/mapped/infer binders. */
+function references(node, names, found = /* @__PURE__ */ new Set(), bound = /* @__PURE__ */ new Set()) {
+	const local = new Set(bound);
+	for (const parameter of node.typeParameters?.params ?? []) local.add(parameter.name);
+	if (node.type === "TSMappedType") local.add(node.typeParameter.name);
+	if (node.type === "TSInferType") local.add(node.typeParameter.name);
+	if (node.type === "TSTypeReference" && node.typeName.type === "Identifier") {
+		const name = node.typeName.name;
+		if (names.has(name) && !local.has(name)) found.add(name);
+	}
+	for (const [key, value] of Object.entries(node)) {
+		if (["loc", "typeName"].includes(key)) continue;
+		for (const child of Array.isArray(value) ? value : [value]) {
+			if (!child?.type) continue;
+			const childBound = new Set(local);
+			if (node.type === "TSConditionalType" && key === "trueType") {
+				const bind = (part) => {
+					if (part.type === "TSInferType") childBound.add(part.typeParameter.name);
+					for (const [property, nested] of Object.entries(part)) {
+						if (property === "loc") continue;
+						if (part.type === "TSConditionalType" && property === "extendsType") continue;
+						for (const item of Array.isArray(nested) ? nested : [nested]) if (item?.type) bind(item);
+					}
+				};
+				bind(node.extendsType);
+			}
+			references(child, names, found, childBound);
+		}
+	}
+	return found;
+}
+function enumTypeParameters(node, branch) {
+	const parameters = node.typeParameters?.params ?? [];
+	const names = new Set(parameters.map((parameter) => parameter.name));
+	const used = /* @__PURE__ */ new Set();
+	for (const field of branch.params) references(field.typeAnnotation, names, used);
+	for (let size = -1; size !== used.size;) {
+		size = used.size;
+		for (const parameter of parameters) {
+			if (!used.has(parameter.name)) continue;
+			if (parameter.constraint) references(parameter.constraint, names, used);
+			if (parameter.default) references(parameter.default, names, used);
+		}
+	}
+	return parameters.filter((parameter) => used.has(parameter.name));
 }
+/** Tagged records and precise factories; no application runtime is introduced. */
+function lowerEnums(source, ast, enums, code) {
+	const insertions = [];
+	const exported = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (node.type === "ExportNamedDeclaration") exported.add(node.declaration);
+		for (const [key, value] of Object.entries(node)) {
+			if (["loc", "trailing"].includes(key)) continue;
+			for (const child of Array.isArray(value) ? value : [value]) if (child?.type) visit(child);
+		}
+	};
+	visit(ast);
+	for (const node of enums) {
+		const replacement = {
+			anchor: node.braceStart,
+			before: false,
+			text: "= ",
+			copies: []
+		};
+		for (const [index, branch] of node.cases.entries()) {
+			if (index) replacement.text += " | ";
+			replacement.text += `{ readonly kind: ${JSON.stringify(branch.id.name)}; `;
+			for (const field of branch.params) {
+				replacement.text += "readonly ";
+				const text = source.slice(field.start, field.typeAnnotation.end);
+				replacement.copies.push({
+					start: replacement.text.length,
+					sourceStart: field.start,
+					length: text.length
+				});
+				replacement.text += text + "; ";
+			}
+			replacement.text += "}";
+		}
+		replacement.text += `; ${exported.has(node) ? "export " : ""}const `;
+		replacement.copies.push({
+			start: replacement.text.length,
+			sourceStart: node.id.start,
+			length: node.id.end - node.id.start
+		});
+		replacement.text += source.slice(node.id.start, node.id.end) + " = {";
+		insertions.push(replacement);
+		code.overwrite(node.start, node.start + 4, "type");
+		code.overwrite(node.braceStart, node.braceStart + 1, replacement.text);
+		for (const branch of node.cases) {
+			code.remove(branch.start, branch.start + 4);
+			const parameters = enumTypeParameters(node, branch);
+			const copied = {
+				anchor: branch.id.end,
+				before: true,
+				text: parameters.length ? "<" : "",
+				copies: []
+			};
+			for (const [index, parameter] of parameters.entries()) {
+				if (index) copied.text += ", ";
+				const text = source.slice(parameter.start, parameter.end);
+				copied.copies.push({
+					start: copied.text.length,
+					sourceStart: parameter.start,
+					length: text.length
+				});
+				copied.text += text;
+			}
+			if (parameters.length) copied.text += ">";
+			const generic = copied.text;
+			if (generic) insertions.push(copied);
+			code.appendLeft(branch.id.end, generic + (branch.hasParens ? "" : "()"));
+			const fields = branch.params.map((field) => field.name);
+			code.appendLeft(branch.valueEnd, `{ return { kind: ${JSON.stringify(branch.id.name)}${fields.length ? ", " + fields.join(", ") : ""} } as const; },`);
+			if (source[branch.end - 1] === ";") code.remove(branch.end - 1, branch.end);
+		}
+		code.appendLeft(node.end, ";");
+	}
+	return insertions;
+}
+/** Generated type copies map to their actual source tokens, including .d.ts maps. */
+function mapEnumCopies(source, generated, map, insertions) {
+	const starts = (text) => {
+		const result = [0];
+		for (let index = 0; index < text.length; index++) if (text[index] === "\n") result.push(index + 1);
+		return result;
+	};
+	const originalLines = starts(source), generatedLines = starts(generated);
+	const position = (lines, offset) => {
+		let line = 0;
+		while (line + 1 < lines.length && lines[line + 1] <= offset) line++;
+		return {
+			line,
+			column: offset - lines[line]
+		};
+	};
+	const trace = new TraceMap(map);
+	const decoded = decodedMappings(trace);
+	const copies = [];
+	for (const insertion of insertions) {
+		const anchor = position(originalLines, insertion.anchor);
+		const location = generatedPositionFor(trace, {
+			source: map.sources[0],
+			line: anchor.line + 1,
+			column: anchor.column
+		});
+		const offset = generatedLines[location.line - 1] + location.column - (insertion.before ? insertion.text.length : 0);
+		if (generated.slice(offset, offset + insertion.text.length) !== insertion.text) throw new Error("Enum mapping anchor does not match generated text.");
+		for (const copy of insertion.copies) {
+			copies.push({
+				generatedStart: offset + copy.start,
+				sourceStart: copy.sourceStart,
+				length: copy.length
+			});
+			for (let index = 0; index < copy.length; index++) {
+				const target = position(generatedLines, offset + copy.start + index);
+				const original = position(originalLines, copy.sourceStart + index);
+				const line = decoded[target.line];
+				const entry = [
+					target.column,
+					0,
+					original.line,
+					original.column
+				];
+				const existing = line.findIndex((segment) => segment[0] === target.column);
+				if (existing >= 0) line[existing] = entry;
+				else line.push(entry);
+			}
+		}
+	}
+	for (const line of decoded) line.sort((left, right) => left[0] - right[0]);
+	map.mappings = encodedMappings(new TraceMap({
+		...JSON.parse(map.toString()),
+		mappings: decoded
+	}));
+	return copies;
+}
+//#endregion
+//#region src/compiler.ts
 function inferLanguage(filename) {
 	if (/\.(?:twillx|tsx)$/.test(filename)) return "tsx";
 	if (/\.jsx$/.test(filename)) return "jsx";
@@ -776,12 +1270,12 @@ var TwillSyntaxError = class extends SyntaxError {
 };
 function walk(node, visit) {
 	visit(node);
-	for (const [key, value] of Object.entries(node)) {
-		if (["loc", "trailing"].includes(key)) continue;
-		if (Array.isArray(value)) value.forEach((child) => {
-			if (child?.type) walk(child, visit);
-		});
-		else if (value?.type) walk(value, visit);
+	for (const key of Object.keys(node)) {
+		if (key === "loc" || key === "trailing") continue;
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const child of value) if (child?.type) walk(child, visit);
+		} else if (value?.type) walk(value, visit);
 	}
 }
 function calleeName(node) {
@@ -792,6 +1286,7 @@ function calleeName(node) {
 	}
 }
 function transform(source, options = {}) {
+	if (options.runtime !== void 0 && !["inline", "external"].includes(options.runtime)) throw new TypeError("runtime must be inline or external");
 	const filename = options.filename ?? "input.twill";
 	let parsed;
 	try {
@@ -800,11 +1295,28 @@ function transform(source, options = {}) {
 		throw new TwillSyntaxError(source, filename, error);
 	}
 	const code = new MagicString(source);
+	const enumInsertions = parsed.enums.length ? lowerEnums(source, parsed.ast, parsed.enums, code) : [];
 	const usedNames = /* @__PURE__ */ new Set();
-	if (parsed.guards.filter((guard) => guard.binding && guard.binding.declarations[0].id.type !== "Identifier").length || parsed.switches.length || parsed.defers.length || parsed.closures.some((closure) => closure.implicitMembers.length) || /\.twillx$/.test(filename.split(/[?#]/, 1)[0])) walk(parsed.ast, (node) => {
-		if (node.type === "Identifier") usedNames.add(node.name);
+	if (parsed.guards.filter((guard) => guard.binding && guard.binding.declarations[0].id.type !== "Identifier").length || parsed.ifBindings.length || parsed.switches.length || parsed.defers.length || parsed.closures.some((closure) => closure.implicitMembers.length) || /\.twillx$/.test(filename.split(/[?#]/, 1)[0])) walk(parsed.ast, (node) => {
+		if (node.type === "Identifier" || node.type === "JSXIdentifier") usedNames.add(node.name);
 	});
 	let guardCounter = 0;
+	const ifBindingStarts = new Set(parsed.ifBindings.map((node) => node.consequent.start + 1));
+	for (const statement of parsed.ifBindings) {
+		const binding = statement.binding.declarations[0].id;
+		let temporary;
+		do
+			temporary = `__twillIf${guardCounter++}`;
+		while (usedNames.has(temporary));
+		usedNames.add(temporary);
+		const patternEnd = binding.typeAnnotation?.start ?? binding.end;
+		code.overwrite(statement.start, binding.start, `{const ${temporary}`);
+		code.move(binding.start, patternEnd, statement.consequent.start + 1);
+		code.prependRight(binding.start, "const ");
+		code.appendLeft(patternEnd, ` = ${temporary};`);
+		code.prependLeft(statement.consequent.start, `; if (${temporary} !== null && ${temporary} !== void 0) `);
+		code.appendLeft(statement.end, "}");
+	}
 	for (const guard of parsed.guards) {
 		if (guard.singleStatement) {
 			code.prependLeft(guard.start, "{");
@@ -1011,13 +1523,15 @@ function transform(source, options = {}) {
 				const collect = (statement) => {
 					switch (statement.type) {
 						case "ExpressionStatement":
-							code.prependLeft(statement.start, `${collector}.push(`);
+							if (ifBindingStarts.has(statement.start)) code.appendRight(statement.start, `${collector}.push(`);
+							else code.prependLeft(statement.start, `${collector}.push(`);
 							code.appendLeft(source[statement.end - 1] === ";" ? statement.end - 1 : statement.end, ")");
 							break;
 						case "BlockStatement":
 							statement.body.forEach(collect);
 							break;
 						case "IfStatement":
+						case "TwillIfBinding":
 							collect(statement.consequent);
 							if (statement.alternate) collect(statement.alternate);
 							break;
@@ -1061,7 +1575,7 @@ function transform(source, options = {}) {
 		if (component) code.prependLeft(closures.at(-1).end, (vue ? "})}" : directChild || metadataByNode.get(closures[0]).header ? ")}" : ")()}") + `</${calleeName(node.callee)}>)`);
 		else code.appendLeft(closures.at(-1).end, ")");
 	}
-	if (parsed.switches.length) lowerSwitchExpressions(source, parsed.ast, parsed.switches, code, options.language ?? inferLanguage(filename), usedNames, (node, message) => {
+	if (parsed.switches.length) lowerSwitchExpressions(source, parsed.ast, parsed.switches, code, options.language ?? inferLanguage(filename), usedNames, parsed.comments, (node, message) => {
 		throw new TwillSyntaxError(source, filename, {
 			message,
 			pos: node.start,
@@ -1072,7 +1586,7 @@ function transform(source, options = {}) {
 	if (parsed.defers.length) {
 		const starts = /* @__PURE__ */ new Map();
 		for (const metadata of parsed.closures) if (metadata.header) starts.set(metadata.node.body, metadata.header.end);
-		lowerDefers(source, parsed.ast, code, options.language ?? inferLanguage(filename), usedNames, starts, parsed.comments, (node, message) => {
+		lowerDefers(source, parsed.ast, code, options.language ?? inferLanguage(filename), usedNames, starts, parsed.comments, options.runtime ?? "inline", options.sourceType ?? "module", (node, message) => {
 			throw new TwillSyntaxError(source, filename, {
 				message,
 				pos: node.start,
@@ -1086,14 +1600,19 @@ function transform(source, options = {}) {
 		includeContent: true,
 		hires: true
 	});
+	const enumCopies = enumInsertions.length ? mapEnumCopies(source, code.toString(), map, enumInsertions) : [];
 	return {
 		code: code.toString(),
 		map,
 		changed: code.hasChanged(),
 		closures: parsed.closures.length,
 		guards: parsed.guards.length,
+		ifBindings: parsed.ifBindings.length,
 		defers: parsed.defers.length,
 		switches: parsed.switches.length,
+		associatedEnums: parsed.enums,
+		enumPatterns: parsed.switches.flatMap((node) => node.cases.flatMap((branch) => branch.enumPattern ? [branch.enumPattern] : [])),
+		enumCopies,
 		componentProps
 	};
 }
@@ -1122,6 +1641,6 @@ function generatedPosition(result, line, column) {
 	});
 }
 //#endregion
-export { isTwillFile as a, parse as c, inferLanguage as i, extensions as n, originalPosition as o, generatedPosition as r, transform as s, TwillSyntaxError as t };
+export { transform as a, originalPosition as i, generatedPosition as n, parse as o, inferLanguage as r, TwillSyntaxError as t };
 
-//# sourceMappingURL=compiler-Bi9TNOhX.js.map
+//# sourceMappingURL=compiler-CbNSBUI2.js.map