@swiftuijs/twill 0.1.0

package/dist/compiler-Bi9TNOhX.js

@@ -0,0 +1,1127 @@
+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";
+//#region src/parser.js
+var options = {
+	ecmaVersion: "latest",
+	sourceType: "module",
+	locations: true
+};
+var bases = {
+	js: Parser,
+	jsx: Parser.extend(jsx()),
+	ts: Parser.extend(tsPlugin({ allowSatisfies: true })),
+	tsx: Parser.extend(tsPlugin({ allowSatisfies: true }))
+};
+function guardAt(input, offset, implicitMember = false) {
+	const lexer = Parser.tokenizer(input.slice(offset), { ecmaVersion: "latest" });
+	const stack = [];
+	let first = true;
+	try {
+		for (;;) {
+			const label = lexer.getToken().type.label;
+			if (first && [
+				"=",
+				".",
+				"?.",
+				":",
+				"++/--",
+				"*",
+				"/",
+				"%",
+				"==/!=/===/!==",
+				"in",
+				"instanceof"
+			].includes(label) && !(implicitMember && label === ".")) return false;
+			if (!stack.length && [
+				"if",
+				"for",
+				"while",
+				"switch",
+				"try",
+				"return",
+				"throw",
+				"var",
+				"export"
+			].includes(label)) return false;
+			if (!first && !stack.length && label === "const") return false;
+			first = false;
+			if (!stack.length && label === "else") return true;
+			if (!stack.length && [
+				"eof",
+				";",
+				"}"
+			].includes(label)) return false;
+			if ([
+				"(",
+				"[",
+				"{",
+				"${"
+			].includes(label)) stack.push(label);
+			else if ([
+				")",
+				"]",
+				"}"
+			].includes(label)) {
+				if (!stack.length) return false;
+				stack.pop();
+			}
+		}
+	} catch {
+		return false;
+	}
+}
+function exits(node) {
+	switch (node.type) {
+		case "ReturnStatement":
+		case "ThrowStatement":
+		case "BreakStatement":
+		case "ContinueStatement": return true;
+		case "BlockStatement": return node.body.some(exits);
+		case "IfStatement": return !!node.alternate && exits(node.consequent) && exits(node.alternate);
+		default: return false;
+	}
+}
+function awaits(node) {
+	if (!node || typeof node !== "object") return false;
+	if (node.type === "AwaitExpression" || node.await === true || node.kind === "await using") return true;
+	if (node.type === "DeferStatement") return node.awaited;
+	if ([
+		"FunctionDeclaration",
+		"FunctionExpression",
+		"ArrowFunctionExpression"
+	].includes(node.type)) return false;
+	if (["ClassDeclaration", "ClassExpression"].includes(node.type)) return awaits(node.superClass) || node.body.body.some((member) => member.computed && awaits(member.key));
+	return Object.entries(node).some(([key, value]) => {
+		if (key === "loc" || key === "trailing") return false;
+		return Array.isArray(value) ? value.some(awaits) : !!value?.type && awaits(value);
+	});
+}
+function deferAt(input, offset) {
+	try {
+		const next = Parser.tokenizer(input.slice(offset), { ecmaVersion: "latest" }).getToken();
+		return next.type === tokTypes.braceL && !/[\r\n\u2028\u2029]/.test(input.slice(offset, offset + next.start));
+	} catch {
+		return false;
+	}
+}
+function headerAt(input, offset) {
+	const lexer = Parser.tokenizer(input.slice(offset), options);
+	const stack = [];
+	let first = true;
+	const tokens = [];
+	try {
+		for (;;) {
+			const token = lexer.getToken();
+			const label = token.type.label;
+			if (first && label !== "name" && label !== "(") return null;
+			first = false;
+			if (!stack.length && label === "in") {
+				const async = tokens.length > 1 && tokens[0].value === "async";
+				const firstParam = tokens[async ? 1 : 0];
+				return {
+					start: offset,
+					end: offset + token.end,
+					inStart: offset + token.start,
+					text: input.slice(offset + tokens[0].start, offset + tokens.at(-1).end),
+					textStart: offset + tokens[0].start,
+					async,
+					asyncEnd: async ? offset + tokens[0].end : null,
+					parenthesized: firstParam.type.label === "("
+				};
+			}
+			if (label === "eof" || !stack.length && [
+				";",
+				"{",
+				"}",
+				"=>"
+			].includes(label)) return null;
+			if ([
+				"(",
+				"[",
+				"{"
+			].includes(label)) stack.push(label);
+			if ([
+				")",
+				"]",
+				"}"
+			].includes(label)) {
+				if (!stack.length) return null;
+				stack.pop();
+			}
+			tokens.push(token);
+		}
+	} catch {
+		return null;
+	}
+}
+function moveNodes(node, delta, locate) {
+	if (!node || typeof node !== "object") return;
+	if (typeof node.start === "number") {
+		node.start += delta;
+		node.end += delta;
+		node.loc = {
+			start: locate(node.start),
+			end: locate(node.end)
+		};
+	}
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "loc") continue;
+		if (Array.isArray(value)) value.forEach((item) => moveNodes(item, delta, locate));
+		else if (value && typeof value === "object") moveNodes(value, delta, locate);
+	}
+}
+var parsers = /* @__PURE__ */ new Map();
+function parserFor(language) {
+	if (parsers.has(language)) return parsers.get(language);
+	const Base = bases[language];
+	class TwillParser extends Base {
+		skipHeader = null;
+		closures = [];
+		lineStarts = null;
+		classSuperDepth = null;
+		subscriptDepth = 0;
+		derivedClassElement = false;
+		implicitClosure = null;
+		locate(offset) {
+			if (!this.lineStarts) {
+				this.lineStarts = [0];
+				const breaks = /\r\n?|\n|\u2028|\u2029/g;
+				while (breaks.exec(this.input)) this.lineStarts.push(breaks.lastIndex);
+			}
+			let low = 0;
+			let high = this.lineStarts.length;
+			while (low + 1 < high) {
+				const mid = low + high >>> 1;
+				if (this.lineStarts[mid] <= offset) low = mid;
+				else high = mid;
+			}
+			return {
+				line: low + 1,
+				column: offset - this.lineStarts[low]
+			};
+		}
+		parseStatement(context, ...args) {
+			if (this.isContextual("defer") && deferAt(this.input, this.end)) {
+				const node = this.startNode();
+				const async = this.canAwait;
+				this.next();
+				const enclosing = this.implicitClosure;
+				const implicit = enclosing && this.currentVarScope() === this.scopeStack[enclosing.scopeIndex] ? enclosing : null;
+				const previousScope = implicit?.scopeIndex;
+				if (implicit) implicit.scopeIndex = this.scopeStack.length;
+				let cleanup;
+				try {
+					cleanup = this.parseArrowExpression(this.startNode(), [], async, false);
+				} finally {
+					if (implicit) implicit.scopeIndex = previousScope;
+				}
+				node.awaited = awaits(cleanup.body);
+				cleanup.async = node.awaited;
+				node.cleanup = cleanup;
+				return this.finishNode(node, "DeferStatement");
+			}
+			if (!this.isContextual("guard") || !guardAt(this.input, this.end, !!this.implicitClosure)) return super.parseStatement(context, ...args);
+			const node = this.startNode();
+			node.singleStatement = !!context;
+			this.next();
+			node.binding = null;
+			if (this.type === tokTypes._const) {
+				if (context) this.raise(node.start, "A guard binding requires a block; add braces around this body.");
+				const declaration = this.startNode();
+				this.next();
+				this.parseVar(declaration, false, "const");
+				node.binding = this.finishNode(declaration, "VariableDeclaration");
+				if (node.binding.declarations.length !== 1) this.raise(node.start, "guard const requires one binding declaration.");
+			} else node.test = this.parseExpression();
+			node.elseStart = this.start;
+			this.expect(tokTypes._else);
+			if (this.type !== tokTypes.braceL) this.unexpected();
+			node.failure = this.parseBlock();
+			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");
+		}
+		tsParseTypeParameter(...args) {
+			const start = this.start;
+			const loc = this.startLoc;
+			const constant = this.type === tokTypes._const;
+			if (constant) this.next();
+			const parameter = super.tsParseTypeParameter(...args);
+			if (constant) {
+				parameter.const = true;
+				parameter.start = start;
+				parameter.loc.start = loc;
+			}
+			return parameter;
+		}
+		parseExprSubscripts(...args) {
+			this.subscriptDepth++;
+			try {
+				return super.parseExprSubscripts(...args);
+			} finally {
+				this.subscriptDepth--;
+			}
+		}
+		parseClassSuper(...args) {
+			const previous = this.classSuperDepth;
+			this.classSuperDepth = this.subscriptDepth;
+			try {
+				return super.parseClassSuper(...args);
+			} finally {
+				this.classSuperDepth = previous;
+			}
+		}
+		parseClassElement(...args) {
+			const previous = this.derivedClassElement;
+			this.derivedClassElement = !!args[0];
+			try {
+				return super.parseClassElement(...args);
+			} finally {
+				this.derivedClassElement = previous;
+			}
+		}
+		raise(position, message, ...args) {
+			if (language.startsWith("ts") && this.derivedClassElement && typeof message === "string" && message.includes("cannot have an 'override' modifier")) return;
+			return super.raise(position, message, ...args);
+		}
+		readToken(code) {
+			if (language === "ts" && code === 60 && !this.inType && this.exprAllowed) return this.readToken_lt_gt(code);
+			return super.readToken(code);
+		}
+		parseExprAtom(...args) {
+			if (this.type === tokTypes.dot) {
+				const closure = this.implicitClosure;
+				if (!closure || this.currentVarScope() !== this.scopeStack[closure.scopeIndex]) this.raise(this.start, "Implicit member access requires a trailing closure without a parameter header.");
+				const node = this.startNode();
+				node.name = "__twillImplicit";
+				closure.members.push(node);
+				return this.finishNodeAt(node, "Identifier", this.start, this.startLoc);
+			}
+			if (this.type === tokTypes._switch) return this.parseSwitchExpression();
+			if (language === "ts" && this.type === tokTypes.relational && this.value === "<") {
+				const node = this.startNode();
+				this.tsInType(() => {
+					this.next();
+					node.typeAnnotation = this.tsParseType();
+					if (!this.tsMatchRightRelational()) this.unexpected();
+					this.next();
+				});
+				node.expression = this.parseMaybeUnary(null, false, false, args[1]);
+				if (node.expression.type === "ArrowFunctionExpression") this.unexpected(node.start);
+				return this.finishNode(node, "TSTypeAssertion");
+			}
+			return super.parseExprAtom(...args);
+		}
+		parseSwitchExpression() {
+			const node = this.startNode();
+			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;
+			while (this.type !== tokTypes.braceR) {
+				const branch = this.startNode();
+				const isCase = this.type === tokTypes._case;
+				if (!isCase && this.type !== tokTypes._default) this.unexpected();
+				this.next();
+				this.enterScope(0);
+				if (!isCase) {
+					if (sawDefault) this.raise(branch.start, "Multiple default clauses.");
+					sawDefault = true;
+					branch.test = null;
+				} else if (this.type === tokTypes.braceL) {
+					if (mode === "value") this.raise(branch.start, "Cannot mix object patterns and value cases.");
+					mode = "pattern";
+					const errors = {
+						shorthandAssign: -1,
+						trailingComma: -1,
+						parenthesizedAssign: -1,
+						parenthesizedBind: -1,
+						doubleProto: -1
+					};
+					const pattern = this.parseObj(false, errors);
+					const tags = pattern.properties.filter((property) => property.type === "Property" && !property.computed && !property.method && property.kind === "init" && (property.value.type === "Literal" && !property.value.regex || property.value.type === "UnaryExpression" && ["+", "-"].includes(property.value.operator) && property.value.argument.type === "Literal" && typeof property.value.argument.value === "number"));
+					if (tags.length !== 1) this.raise(pattern.start, "An object case needs exactly one literal discriminator; other properties bind values.");
+					const tag = tags[0];
+					const key = String(tag.key.name ?? tag.key.value);
+					if (discriminator !== void 0 && key !== discriminator) this.raise(tag.start, "Object cases must use the same discriminator property.");
+					discriminator = key;
+					pattern.properties = pattern.properties.filter((property) => property !== tag);
+					this.toAssignable(pattern, true, errors);
+					this.checkLValPattern(pattern, 2, false);
+					pattern.properties.push(tag);
+					pattern.properties.sort((a, b) => a.start - b.start);
+					branch.pattern = pattern;
+					branch.tag = tag;
+				} else {
+					if (mode === "pattern") this.raise(branch.start, "Cannot mix object patterns and value cases.");
+					mode = "value";
+					branch.test = this.parseExpression();
+				}
+				branch.colonStart = this.start;
+				this.expect(tokTypes.colon);
+				if (this.type === tokTypes._throw) {
+					const thrown = this.parseThrowStatement(this.startNode());
+					branch.value = thrown.argument;
+					branch.throw = true;
+					branch.valueEnd = thrown.end;
+				} else {
+					branch.value = this.parseMaybeAssign();
+					branch.valueEnd = this.lastTokEnd;
+					this.semicolon();
+				}
+				this.exitScope();
+				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.");
+			node.discriminator = discriminator;
+			return this.finishNode(node, "TwillSwitchExpression");
+		}
+		next(...args) {
+			super.next(...args);
+			if (this.skipHeader !== null) {
+				const end = this.skipHeader;
+				this.skipHeader = null;
+				while (this.start < end && this.type !== tokTypes.eof) super.next(...args);
+			}
+		}
+		parseTrailingClosure(callee, label) {
+			const start = this.start;
+			const header = headerAt(this.input, this.end);
+			let params = [];
+			let async = false;
+			let parameterText = "()";
+			if (header) {
+				let text = header.text.trim();
+				async = header.async;
+				if (async) text = text.replace(/^async\s+/, "");
+				parameterText = text.startsWith("(") ? text : `(${text})`;
+				const prefix = async ? "async " : "";
+				try {
+					params = Base.parse(`${prefix}${parameterText} => {}`, {
+						...options,
+						sourceType: this.options.sourceType
+					}).body[0].expression.params;
+					const sourceStart = header.textStart + header.text.indexOf(text);
+					const addedParen = text.startsWith("(") ? 0 : 1;
+					params.forEach((param) => moveNodes(param, sourceStart - prefix.length - addedParen, (offset) => this.locate(offset)));
+				} catch (error) {
+					this.raise(start, `Invalid trailing closure parameters: ${error.message}`);
+				}
+			}
+			const node = this.startNode();
+			this.skipHeader = header?.end ?? null;
+			const previous = this.implicitClosure;
+			const implicit = header ? null : {
+				scopeIndex: this.scopeStack.length,
+				members: []
+			};
+			this.implicitClosure = implicit;
+			let arrow;
+			try {
+				arrow = this.parseArrowExpression(node, params, async, false);
+			} finally {
+				this.implicitClosure = previous;
+			}
+			this.closures.push({
+				node: arrow,
+				callee,
+				label,
+				header,
+				parameterText,
+				async,
+				implicitMembers: implicit?.members ?? []
+			});
+			return arrow;
+		}
+		parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit) {
+			const classBody = this.classSuperDepth !== null && this.subscriptDepth === this.classSuperDepth + 1;
+			if (!noCalls && !classBody && this.tsMatchLeftRelational?.() && this.start === base.end) {
+				const parameters = this.tsTryParseAndCatch(() => {
+					const parsed = this.tsParseTypeArgumentsInExpression();
+					return parsed && this.type === tokTypes.braceL && !/[\r\n\u2028\u2029]/.test(this.input.slice(parsed.end, this.start)) ? parsed : void 0;
+				});
+				if (parameters) {
+					const instantiation = this.startNodeAt(startPos, startLoc);
+					instantiation.expression = base;
+					instantiation.typeParameters = parameters;
+					base = this.finishNode(instantiation, "TSInstantiationExpression");
+				}
+			}
+			const supported = [
+				"CallExpression",
+				"Identifier",
+				"MemberExpression",
+				"TSInstantiationExpression"
+			].includes(base.type);
+			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;
+				const hadParens = base.type === "CallExpression" && base.end === this.lastTokEnd;
+				const callee = hadParens ? base.callee : base.type === "TSInstantiationExpression" ? base.expression : base;
+				const node = this.startNodeAt(startPos, startLoc);
+				node.callee = callee;
+				node.arguments = hadParens ? [...base.arguments] : [];
+				node.optional = base.optional ?? false;
+				if ((hadParens || base.type === "TSInstantiationExpression") && base.typeParameters) node.typeParameters = base.typeParameters;
+				const callEnd = this.lastTokEnd;
+				const args = [this.parseTrailingClosure(callee, null)];
+				while (this.type === tokTypes.name) {
+					const tail = this.input.slice(this.end);
+					const lexer = Parser.tokenizer(tail, options);
+					if (lexer.getToken().type !== tokTypes.colon || lexer.getToken().type !== tokTypes.braceL) break;
+					const label = {
+						name: this.value,
+						start: this.start,
+						end: this.end
+					};
+					this.next();
+					this.expect(tokTypes.colon);
+					args.push(this.parseTrailingClosure(callee, label));
+				}
+				node.arguments.push(...args);
+				node.trailing = {
+					callEnd,
+					hadParens,
+					originalArgs: hadParens ? base.arguments : [],
+					closures: args
+				};
+				return this.finishNode(node, "CallExpression");
+			}
+			return super.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit);
+		}
+	}
+	parsers.set(language, TwillParser);
+	return TwillParser;
+}
+function parse(source, language = "ts", sourceType = "module") {
+	const TwillParser = parserFor(language);
+	const comments = [];
+	const parser = new TwillParser({
+		...options,
+		sourceType,
+		allowHashBang: true,
+		onComment: comments
+	}, source);
+	const ast = parser.parse();
+	const live = /* @__PURE__ */ new Set();
+	const calls = [];
+	const guards = [];
+	const defers = [];
+	const switches = [];
+	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 === "DeferStatement") defers.push(node);
+		if (node.type === "TwillSwitchExpression") switches.push(node);
+		for (const [key, value] of Object.entries(node)) {
+			if (key === "trailing" || key === "loc") continue;
+			if (Array.isArray(value)) value.forEach(visit);
+			else if (value?.type) visit(value);
+		}
+	};
+	visit(ast);
+	return {
+		ast,
+		calls,
+		guards,
+		defers,
+		switches,
+		comments,
+		closures: parser.closures.filter((closure) => live.has(closure.node)).map((closure) => ({
+			...closure,
+			implicitMembers: closure.implicitMembers.filter((node) => live.has(node)).map((node) => node.start)
+		}))
+	};
+}
+//#endregion
+//#region src/defer.ts
+var functions = /* @__PURE__ */ new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+function children(node, visit) {
+	for (const [key, value] of Object.entries(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);
+	}
+}
+/** Scope-local cleanup callbacks; dynamic registrations use lazy stacks. */
+function lowerDefers(source, ast, code, language, usedNames, contentStarts, comments, fail) {
+	const scopes = [];
+	const visit = (node, scope, parent) => {
+		if (functions.has(node.type) || [
+			"Program",
+			"TSModuleBlock",
+			"SwitchCase"
+		].includes(node.type)) scope = void 0;
+		if (node.type === "BlockStatement" || node.type === "StaticBlock") {
+			scope = {
+				block: node,
+				functionBody: !!parent && functions.has(parent.type) && parent.body === node,
+				defers: []
+			};
+			scopes.push(scope);
+		}
+		if (node.type === "DeferStatement") {
+			if (!scope) fail(node, "defer requires an explicit block or function body; wrap a switch case in braces.");
+			scope.defers.push(node);
+			const check = (item) => {
+				if (functions.has(item.type)) return;
+				if (item.type === "ReturnStatement") fail(item, "A defer cleanup cannot return; use a nested function for local early returns.");
+				children(item, check);
+			};
+			check(node.cleanup.body);
+		}
+		children(node, (child) => visit(child, scope, node));
+	};
+	visit(ast, void 0);
+	let counter = 0;
+	const fresh = (part) => {
+		let name;
+		do
+			name = `__twill${part}${counter++}`;
+		while (usedNames.has(name));
+		usedNames.add(name);
+		return name;
+	};
+	const sortedComments = [...comments].sort((a, b) => b.end - a.end);
+	const leadingComment = (statement, minimum) => {
+		let start = statement.start;
+		for (const comment of sortedComments) {
+			if (comment.end > start || comment.start < minimum) continue;
+			if (/\S/.test(source.slice(comment.end, start))) break;
+			if (comment.type === "Block" && comment.value.startsWith("*")) start = comment.start;
+			else break;
+		}
+		return start;
+	};
+	for (const scope of scopes) {
+		if (!scope.defers.length) continue;
+		const { block } = scope;
+		const statements = block.body;
+		const single = scope.defers.length === 1 && statements.includes(scope.defers[0]);
+		const stack = fresh(single ? "Cleanup" : "Defers");
+		const failure = single ? "" : fresh("Failure");
+		const failed = single ? "" : fresh("Failed");
+		const callback = single ? stack : fresh("Cleanup");
+		const error = single ? "" : fresh("Error");
+		const anyAsync = scope.defers.some((node) => node.awaited);
+		const allAsync = scope.defers.every((node) => node.awaited);
+		const mixed = anyAsync && !allAsync;
+		const storageType = single ? "(() => unknown) | undefined" : `Array<${mixed ? "{ run: () => unknown; async: boolean }" : "() => unknown"}> | undefined`;
+		const annotation = language.startsWith("ts") ? `: ${storageType}` : "";
+		const jsdoc = language.startsWith("js") ? `\n/** @type {${storageType}} */\n` : "";
+		let start = contentStarts.get(block) ?? block.start + 1;
+		if (block.type === "StaticBlock") start = statements[0].start;
+		let index = 0;
+		while (statements[index]?.directive) start = statements[index++].end;
+		const ordinary = statements.slice(index);
+		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`);
+		let anchor = start;
+		const initial = /* @__PURE__ */ new Set();
+		for (const statement of ordinary) {
+			if (statement.type !== "FunctionDeclaration") break;
+			initial.add(statement);
+			anchor = statement.end;
+		}
+		for (const declaration of declarations) {
+			const commentStart = leadingComment(declaration, start);
+			if (!initial.has(declaration)) code.move(commentStart, declaration.end, anchor);
+			if (commentStart < declaration.start) code.prependLeft(commentStart, "\n");
+			code.move(declaration.start, declaration.id.start, declaration.id.end);
+			code.appendLeft(declaration.id.end, " = ");
+			code.appendLeft(declaration.end, ";");
+		}
+		for (const node of scope.defers) {
+			const arrow = `${node.awaited ? "async " : ""}() => `;
+			const prefix = single ? `${stack} = ${arrow}` : `(${stack} ??= []).push(${mixed ? `{ async: ${node.awaited}, run: ` : ""}${arrow}`;
+			code.overwrite(node.start, node.cleanup.body.start, prefix);
+			code.appendLeft(node.end, single ? ";" : `${mixed ? "}" : ""});`);
+		}
+		if (single) {
+			const call = allAsync ? `if (${stack}) await ${stack}();` : `${stack}?.();`;
+			code.prependLeft(block.end - 1, `\n} finally { ${call} }\n`);
+			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}; }`);
+	}
+}
+//#endregion
+//#region src/branches.ts
+function suspension(node) {
+	if (["AwaitExpression", "YieldExpression"].includes(node.type)) return node;
+	if ([
+		"FunctionDeclaration",
+		"FunctionExpression",
+		"ArrowFunctionExpression"
+	].includes(node.type)) return;
+	for (const [key, value] of Object.entries(node)) {
+		if ([
+			"loc",
+			"trailing",
+			"tag"
+		].includes(key)) continue;
+		for (const child of Array.isArray(value) ? value : [value]) if (child?.type) {
+			const found = suspension(child);
+			if (found) return found;
+		}
+	}
+}
+/** 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) {
+	const returns = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		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 [key, value] of Object.entries(node)) {
+			if ([
+				"loc",
+				"trailing",
+				"tag"
+			].includes(key)) continue;
+			for (const child of Array.isArray(value) ? value : [value]) if (child?.type) visit(child);
+		}
+	};
+	visit(ast);
+	let counter = 0;
+	const fresh = (part) => {
+		let name;
+		do
+			name = `__twill${part}${counter++}`;
+		while (usedNames.has(name));
+		usedNames.add(name);
+		return name;
+	};
+	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.");
+		const subject = fresh("Subject");
+		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) {
+			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, "; }");
+			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;` : "";
+		const failure = hasDefault ? "" : `${check} throw new TypeError('Non-exhaustive switch expression');`;
+		code.overwrite(node.end - 1, node.end, `}${failure}${direct ? "}" : "})()"}`);
+	}
+}
+//#endregion
+//#region src/compiler.ts
+var extensions = [".twill", ".twillx"];
+function isTwillFile(id) {
+	return extensions.some((extension) => id.split(/[?#]/, 1)[0].endsWith(extension));
+}
+function inferLanguage(filename) {
+	if (/\.(?:twillx|tsx)$/.test(filename)) return "tsx";
+	if (/\.jsx$/.test(filename)) return "jsx";
+	if (/\.(?:js|mjs|cjs)$/.test(filename)) return "js";
+	return "ts";
+}
+var TwillSyntaxError = class extends SyntaxError {
+	filename;
+	line;
+	column;
+	offset;
+	frame;
+	constructor(source, filename, error) {
+		const line = error.loc?.line ?? 1;
+		const column = error.loc?.column ?? 0;
+		super(`${filename}:${line}:${column + 1}: ${error.message.replace(/\s*\(\d+:\d+\)$/, "")}`);
+		this.name = "TwillSyntaxError";
+		this.filename = filename;
+		this.line = line;
+		this.column = column;
+		this.offset = error.pos ?? 0;
+		this.frame = `${source.split(/\r\n|[\r\n\u2028\u2029]/)[line - 1] ?? ""}\n${" ".repeat(column)}^`;
+	}
+};
+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);
+	}
+}
+function calleeName(node) {
+	if (node.type === "Identifier") return node.start === node.end ? void 0 : node.name;
+	if (node.type === "MemberExpression" && !node.computed) {
+		const object = calleeName(node.object);
+		if (object) return `${object}.${node.property.name}`;
+	}
+}
+function transform(source, options = {}) {
+	const filename = options.filename ?? "input.twill";
+	let parsed;
+	try {
+		parsed = parse(source, options.language ?? inferLanguage(filename), options.sourceType ?? "module");
+	} catch (error) {
+		throw new TwillSyntaxError(source, filename, error);
+	}
+	const code = new MagicString(source);
+	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);
+	});
+	let guardCounter = 0;
+	for (const guard of parsed.guards) {
+		if (guard.singleStatement) {
+			code.prependLeft(guard.start, "{");
+			code.appendLeft(guard.end, "}");
+		}
+		if (guard.binding) {
+			const binding = guard.binding.declarations[0].id;
+			if (binding.type === "Identifier") code.remove(guard.start, guard.start + 5);
+			else {
+				let temporary;
+				do
+					temporary = `__twillGuard${guardCounter++}`;
+				while (usedNames.has(temporary));
+				usedNames.add(temporary);
+				const patternEnd = binding.typeAnnotation?.start ?? binding.end;
+				code.overwrite(guard.start, binding.start, `const ${temporary}`);
+				code.move(binding.start, patternEnd, guard.end);
+				code.prependRight(binding.start, "; const ");
+				code.appendLeft(patternEnd, ` = ${temporary};`);
+				code.overwrite(guard.elseStart, guard.elseStart + 4, `; if (${temporary} == null)`);
+				continue;
+			}
+			code.overwrite(guard.elseStart, guard.elseStart + 4, `; if (${binding.name} == null)`);
+		} else {
+			code.overwrite(guard.start, guard.start + 5, "if (!(");
+			code.overwrite(guard.elseStart, guard.elseStart + 4, "))");
+		}
+	}
+	const uiFile = /\.twillx$/.test(filename.split(/[?#]/, 1)[0]);
+	const metadataByNode = new Map(parsed.closures.map((item) => [item.node, item]));
+	const componentCalls = new Set(parsed.calls.filter((node) => {
+		const name = calleeName(node.callee);
+		return uiFile && node.start === node.callee.start && !!name && /^[A-Z]/.test(name.split(".").at(-1));
+	}));
+	for (const call of componentCalls) {
+		const implicit = call.trailing.closures.flatMap((closure) => metadataByNode.get(closure).implicitMembers)[0];
+		if (implicit !== void 0) throw new TwillSyntaxError(source, filename, {
+			message: "Implicit member access is for ordinary callbacks. Use explicit parameters for component render props or slots.",
+			pos: implicit,
+			loc: {
+				line: source.slice(0, implicit).split(/\r\n|[\r\n\u2028\u2029]/).length,
+				column: source.slice(0, implicit).split(/\r\n|[\r\n\u2028\u2029]/).at(-1).length
+			}
+		});
+	}
+	let implicitCounter = 0;
+	for (const metadata of parsed.closures) {
+		if (!metadata.implicitMembers.length) continue;
+		let name;
+		do
+			name = `__twillArg${implicitCounter++}`;
+		while (usedNames.has(name));
+		usedNames.add(name);
+		code.overwrite(metadata.node.start, metadata.node.start + 1, `(${name}) => {`);
+		for (const offset of metadata.implicitMembers) code.appendLeft(offset, name);
+	}
+	const pragma = [...parsed.comments.filter((comment) => comment.start < (parsed.ast.body[0]?.start ?? source.length)).map((comment) => comment.value).join("\n").matchAll(/@jsxImportSource\s+(\S+)/g)].at(-1)?.[1];
+	const imports = parsed.ast.body.filter((node) => node.type === "ImportDeclaration").map((node) => node.source.value);
+	const vueImport = imports.some((name) => name === "vue" || name.startsWith("@vue/"));
+	const reactImport = imports.some((name) => name === "react" || name.startsWith("react/"));
+	if (componentCalls.size && !pragma && !options.jsxImportSource && vueImport && reactImport) throw new TwillSyntaxError(source, filename, {
+		message: "Both React and Vue are imported. Select the standard JSX runtime with @jsxImportSource or tsconfig jsxImportSource.",
+		pos: parsed.calls[0].start,
+		loc: parsed.calls[0].loc.start
+	});
+	const jsxImportSource = pragma ?? options.jsxImportSource ?? (vueImport ? "vue" : "react");
+	const vue = jsxImportSource === "vue";
+	if (uiFile && !pragma && jsxImportSource !== "react") {
+		const start = source.startsWith("#!") ? source.indexOf("\n") + 1 : 0;
+		code.appendLeft(start, `/** @jsxImportSource ${jsxImportSource} */\n`);
+	}
+	const attributeClosings = [];
+	const componentProps = [];
+	const stripPunctuation = (start, end, types) => {
+		const text = source.slice(start, end);
+		const lexer = Parser.tokenizer(text, { ecmaVersion: "latest" });
+		const edits = new MagicString(text);
+		for (let token = lexer.getToken(); token.type !== tokTypes.eof; token = lexer.getToken()) if (types.includes(token.type)) edits.remove(token.start, token.end);
+		return edits.toString();
+	};
+	let counter = 0;
+	for (const node of parsed.calls) {
+		const { callEnd, hadParens, originalArgs, closures } = node.trailing;
+		const component = componentCalls.has(node);
+		if (component) {
+			if (originalArgs.length > 1 || originalArgs[0]?.type === "SpreadElement" || node.optional || node.callee.optional) throw new TwillSyntaxError(source, filename, {
+				message: "Component syntax accepts one props object and children; optional calls use ordinary callbacks.",
+				pos: node.start,
+				loc: node.loc.start
+			});
+			if (closures.length > 1 && !vue) throw new TwillSyntaxError(source, filename, {
+				message: "React components accept one children closure. Supply render props in the props object.",
+				pos: closures[1].start,
+				loc: closures[1].loc.start
+			});
+			if (vue) {
+				const labels = /* @__PURE__ */ new Set(["default"]);
+				for (const closure of closures.slice(1)) {
+					const label = metadataByNode.get(closure).label;
+					const name = source.slice(label.start, label.end);
+					if (labels.has(name)) throw new TwillSyntaxError(source, filename, {
+						message: `Duplicate Vue slot: ${name}`,
+						pos: label.start,
+						loc: closure.loc.start
+					});
+					labels.add(name);
+				}
+			}
+			const opening = vue ? ">{({default: " : ">{(";
+			const tagEnd = node.typeParameters?.end ?? node.callee.end;
+			code.appendLeft(node.callee.start, "(<");
+			const props = originalArgs[0];
+			if (!vue && props?.type === "ObjectExpression" && props.properties.every((property) => property.type === "SpreadElement" || property.kind === "init" && !property.method && !property.computed && (property.key.name ?? property.key.value) !== "__proto__" && /^[A-Za-z_$][\w$.:-]*$/.test(String(property.key.name ?? property.key.value)))) {
+				componentProps.push({
+					start: props.start,
+					end: props.end,
+					properties: props.properties.filter((property) => property.type !== "SpreadElement").map((property) => ({
+						name: String(property.key.name ?? property.key.value),
+						start: property.key.start,
+						end: property.key.end,
+						shorthand: Boolean(property.shorthand)
+					}))
+				});
+				code.overwrite(tagEnd, props.start + 1, " " + stripPunctuation(tagEnd, props.start, [tokTypes.parenL]));
+				let previous = props.start + 1;
+				for (const property of props.properties) {
+					if (previous < property.start) code.overwrite(previous, property.start, stripPunctuation(previous, property.start, [tokTypes.comma]) + " ");
+					if (property.type === "SpreadElement") code.prependLeft(property.start, "{");
+					else {
+						const name = String(property.key.name ?? property.key.value);
+						if (property.shorthand) code.prependLeft(property.start, `${name}={`);
+						else {
+							code.overwrite(property.key.start, property.key.end, name);
+							const start = property.key.end;
+							const colon = Parser.tokenizer(source.slice(start, property.value.start), { ecmaVersion: "latest" }).getToken();
+							code.overwrite(start + colon.start, start + colon.end, "={");
+						}
+					}
+					attributeClosings.push(property.end);
+					previous = property.end;
+				}
+				const end = props.end - 1;
+				code.overwrite(previous, callEnd, stripPunctuation(previous, end, [tokTypes.comma]) + stripPunctuation(props.end, callEnd, [tokTypes.parenR, tokTypes.comma]) + opening);
+			} else if (originalArgs.length) {
+				const head = source.slice(tagEnd, originalArgs[0].start);
+				const paren = Parser.tokenizer(head, { ecmaVersion: "latest" }).getToken();
+				code.overwrite(tagEnd, originalArgs[0].start, " {...(" + head.slice(0, paren.start) + head.slice(paren.end));
+				const tailStart = originalArgs[0].end;
+				const tail = Parser.tokenizer(source.slice(tailStart, callEnd - 1), { ecmaVersion: "latest" });
+				for (let token = tail.getToken(); token.type !== tokTypes.eof; token = tail.getToken()) if (token.type === tokTypes.comma) code.remove(tailStart + token.start, tailStart + token.end);
+				code.overwrite(callEnd - 1, callEnd, ")}" + opening);
+			} else if (hadParens) {
+				const gap = source.slice(tagEnd, callEnd);
+				const tokens = Parser.tokenizer(gap, { ecmaVersion: "latest" });
+				const first = tokens.getToken();
+				const last = tokens.getToken();
+				code.overwrite(tagEnd, callEnd, opening + gap.slice(first.end, last.start));
+			} else code.appendLeft(callEnd, opening);
+		} else if (hadParens) {
+			const tailStart = originalArgs.at(-1)?.end ?? callEnd - 1;
+			const tail = source.slice(tailStart, callEnd - 1);
+			const token = Parser.tokenizer(tail, { ecmaVersion: "latest" }).getToken();
+			if (token.type === tokTypes.comma) code.remove(tailStart + token.start, tailStart + token.end);
+			code.overwrite(callEnd - 1, callEnd, originalArgs.length ? "," : "");
+		} else code.appendLeft(callEnd, "(");
+		let directChild = false;
+		for (const closure of closures) {
+			const metadata = metadataByNode.get(closure);
+			const body = closure.body.body;
+			const content = component && (vue || !metadata.header);
+			const expressions = body.filter((statement) => statement.type === "ExpressionStatement");
+			const singleContent = content && expressions.length === 1 && body.every((statement) => [
+				"ExpressionStatement",
+				"VariableDeclaration",
+				"FunctionDeclaration",
+				"ClassDeclaration",
+				"DeferStatement",
+				"EmptyStatement"
+			].includes(statement.type)) && body.filter((statement) => statement.type !== "EmptyStatement").at(-1) === expressions[0];
+			if (singleContent && body.length === 1 && !vue) {
+				directChild = true;
+				code.remove(closure.start, closure.start + 1);
+				code.remove(closure.end - 1, closure.end);
+				const statement = expressions[0];
+				if (source[statement.end - 1] === ";") code.remove(statement.end - 1, statement.end);
+				continue;
+			}
+			if (metadata.label) {
+				const label = source.slice(metadata.label.start, metadata.label.end).replace(/\s*:\s*$/, "");
+				code.overwrite(metadata.label.start, closure.start, component && vue ? `, [${JSON.stringify(label)}]: ` : ", ");
+			}
+			if (metadata.header) {
+				const header = metadata.header;
+				code.overwrite(closure.start, closure.start + 1, header.parenthesized || metadata.async ? "" : "(");
+				if (metadata.async && !header.parenthesized) code.appendLeft(header.asyncEnd, " (");
+				code.overwrite(header.inStart, header.end, `${header.parenthesized ? "" : ") "}=> {`);
+			} else if (!metadata.implicitMembers.length) code.overwrite(closure.start, closure.start + 1, "() => {");
+			if (content && !singleContent) {
+				let collector;
+				do
+					collector = `__twillChildren${counter++}`;
+				while (usedNames.has(collector));
+				const bodyStart = metadata.header?.end ?? closure.start + 1;
+				const collect = (statement) => {
+					switch (statement.type) {
+						case "ExpressionStatement":
+							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":
+							collect(statement.consequent);
+							if (statement.alternate) collect(statement.alternate);
+							break;
+						case "GuardStatement":
+							collect(statement.failure);
+							break;
+						case "ForStatement":
+						case "ForOfStatement":
+						case "ForInStatement":
+						case "WhileStatement":
+						case "DoWhileStatement":
+							collect(statement.body);
+							break;
+						case "SwitchStatement":
+							statement.cases.forEach((branch) => branch.consequent.forEach(collect));
+							break;
+						case "TryStatement":
+							collect(statement.block);
+							if (statement.handler) collect(statement.handler.body);
+							if (statement.finalizer) collect(statement.finalizer);
+							break;
+						case "LabeledStatement":
+							collect(statement.body);
+							break;
+						case "ReturnStatement": throw new TwillSyntaxError(source, filename, {
+							message: "Component children collect expressions; use expressions instead of return.",
+							pos: statement.start,
+							loc: statement.loc.start
+						});
+					}
+				};
+				body.forEach(collect);
+				code.prependLeft(bodyStart, `const ${collector} = [];`);
+				code.prependLeft(closure.end - 1, vue ? `;return ${collector};` : `;return ${collector}.length === 1 ? ${collector}[0] : ${collector};`);
+			} else if (singleContent || options.implicitReturn !== false && body.length === 1 && body[0].type === "ExpressionStatement") {
+				const statement = singleContent ? expressions[0] : body[0];
+				code.prependLeft(statement.start, "return (");
+				code.appendLeft(source[statement.end - 1] === ";" ? statement.end - 1 : statement.end, ")");
+			}
+		}
+		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) => {
+		throw new TwillSyntaxError(source, filename, {
+			message,
+			pos: node.start,
+			loc: node.loc.start
+		});
+	});
+	for (const end of attributeClosings) code.appendLeft(end, "}");
+	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) => {
+			throw new TwillSyntaxError(source, filename, {
+				message,
+				pos: node.start,
+				loc: node.loc.start
+			});
+		});
+	}
+	const map = code.generateMap({
+		source: filename,
+		file: filename.replace(/\.twillx?$/, ".js"),
+		includeContent: true,
+		hires: true
+	});
+	return {
+		code: code.toString(),
+		map,
+		changed: code.hasChanged(),
+		closures: parsed.closures.length,
+		guards: parsed.guards.length,
+		defers: parsed.defers.length,
+		switches: parsed.switches.length,
+		componentProps
+	};
+}
+var traceMaps = /* @__PURE__ */ new WeakMap();
+function traceMap(result) {
+	let map = traceMaps.get(result);
+	if (!map) {
+		map = new TraceMap(result.map);
+		traceMaps.set(result, map);
+	}
+	return map;
+}
+function originalPosition(result, line, column) {
+	return originalPositionFor(traceMap(result), {
+		line,
+		column,
+		bias: GREATEST_LOWER_BOUND
+	});
+}
+function generatedPosition(result, line, column) {
+	return generatedPositionFor(traceMap(result), {
+		source: result.map.sources[0],
+		line,
+		column,
+		bias: GREATEST_LOWER_BOUND
+	});
+}
+//#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 };
+
+//# sourceMappingURL=compiler-Bi9TNOhX.js.map