@lucidkiln/core 1.0.0 → 1.1.0

package/dist/parser-BU5dThuk.js

@@ -0,0 +1,2667 @@
+//#region src/parser/ast.ts
+/** The name of the default slot, filled by content outside any `fill`. */
+const DEFAULT_SLOT = "default";
+const ESCAPE_STRATEGIES = [
+	"html",
+	"attr",
+	"js",
+	"css",
+	"url"
+];
+/** The value types a prop can declare, named as in the docs' table of types. */
+const TYPE_NAMES = [
+	"null",
+	"boolean",
+	"number",
+	"string",
+	"array",
+	"hash",
+	"set",
+	"date",
+	"markup",
+	"object"
+];
+const PUNCTUATORS = [
+	"...",
+	"?.",
+	"??",
+	"?:",
+	"**",
+	"//",
+	"==",
+	"!=",
+	"<=",
+	">=",
+	"=>",
+	"..",
+	"+",
+	"-",
+	"*",
+	"/",
+	"%",
+	"~",
+	"<",
+	">",
+	"=",
+	"(",
+	")",
+	"[",
+	"]",
+	"{",
+	"}",
+	",",
+	":",
+	".",
+	"|",
+	"?"
+];
+/** Punctuators by their first character's code, longest first as in `PUNCTUATORS`, so lexing tries only a few. */
+const PUNCTUATORS_BY_CHARACTER = /* @__PURE__ */ new Map();
+for (const punct of PUNCTUATORS) {
+	const code = punct.charCodeAt(0);
+	const list = PUNCTUATORS_BY_CHARACTER.get(code);
+	if (list) list.push(punct);
+	else PUNCTUATORS_BY_CHARACTER.set(code, [punct]);
+}
+/**
+* The punctuator at `pos`, whose first two character codes are `code` and `next`, or null. Longest first, so `...` wins
+* over `..` and `.`, as in `PUNCTUATORS`.
+*/
+const punctuatorAt = (text, pos, code, next) => {
+	switch (code) {
+		case 46:
+			if (next === 46) return text.charCodeAt(pos + 2) === 46 ? "..." : "..";
+			return ".";
+		case 63: return next === 46 ? "?." : next === 63 ? "??" : next === 58 ? "?:" : "?";
+		case 42: return next === 42 ? "**" : "*";
+		case 47: return next === 47 ? "//" : "/";
+		case 61: return next === 61 ? "==" : next === 62 ? "=>" : "=";
+		case 33: return next === 61 ? "!=" : null;
+		case 60: return next === 61 ? "<=" : "<";
+		case 62: return next === 61 ? ">=" : ">";
+		default: {
+			const single = SINGLE_PUNCTUATORS[code];
+			return single === void 0 ? null : single;
+		}
+	}
+};
+/** Punctuators of one character that start no longer one, by character code. */
+const SINGLE_PUNCTUATORS = [];
+for (const punct of PUNCTUATORS) {
+	const code = punct.charCodeAt(0);
+	if (PUNCTUATORS_BY_CHARACTER.get(code).length === 1) SINGLE_PUNCTUATORS[code] = punct;
+}
+const CLOSED = {
+	closed: true,
+	trim: false
+};
+const CLOSED_TRIM = {
+	closed: true,
+	trim: true
+};
+const NOT_CLOSED = {
+	closed: false,
+	trim: false
+};
+const ESCAPES = {
+	n: "\n",
+	r: "\r",
+	t: "	",
+	"\\": "\\",
+	"'": "'",
+	"\"": "\""
+};
+const VERBATIM_END = /\{%(-?)\s*endverbatim\s*(-?)%\}/g;
+const isInlineSpace = (code) => code === 32 || code === 9 || code === 13 || code === 11 || code === 12;
+const isSpace = (code) => code === 10 || isInlineSpace(code);
+const isNameStart = (code) => code >= 97 && code <= 122 || code >= 65 && code <= 90 || code === 95;
+const isDigit = (code) => code >= 48 && code <= 57;
+const isNamePart = (code) => isNameStart(code) || isDigit(code);
+/**
+* Turns template source into tokens in one pass, then applies whitespace control.
+*
+* Text outside delimiters becomes `text` tokens. Comments produce no tokens. Lines holding only block tags and comments are removed, and `-` markers trim neighbouring whitespace.
+*/
+const lex = (text) => new Lexer(text).run();
+/**
+* Splits source into text, outputs, tags and comments as written, before whitespace control. Tools such as the formatter use it. Comments have no tokens.
+*/
+const scanParts = (text) => new Lexer(text).scan();
+/** Where a template's content starts: after a byte order mark, which is never content. */
+const contentStart = (text) => text.charCodeAt(0) === 65279 ? 1 : 0;
+var Lexer = class {
+	#text;
+	#pos;
+	/** How many string interpolations the lexer is inside. */
+	#interpolations = 0;
+	#tokens = [];
+	#problems = [];
+	constructor(text) {
+		this.#text = text;
+		this.#pos = contentStart(text);
+	}
+	scan() {
+		return {
+			parts: this.#scanParts(),
+			problems: this.#problems
+		};
+	}
+	run() {
+		const parts = this.#scanParts();
+		applyTrimMarkers(this.#text, parts);
+		const standalone = applyStandaloneLines(this.#text, parts);
+		const lines = textLines(this.#text, parts, standalone);
+		const tokens = [];
+		let line = 0;
+		for (const part of parts) {
+			const text = part.kind === "text";
+			const at = text ? part.from : part.start;
+			if (text && part.from < part.to) tokens.push({
+				type: "text",
+				value: this.#text.slice(part.from, part.to),
+				start: part.from,
+				end: part.to
+			});
+			else if (lines[line]?.start === at) tokens.push({
+				type: "text",
+				value: "",
+				start: at,
+				end: at
+			});
+			if (!text && part.kind !== "comment") for (const token of part.tokens) tokens.push(token);
+			const end = text ? part.to : part.start;
+			while ((lines[line]?.start ?? Infinity) <= end) line++;
+		}
+		tokens.push({
+			type: "eof",
+			value: "",
+			start: this.#text.length,
+			end: this.#text.length
+		});
+		return {
+			tokens,
+			problems: this.#problems,
+			standalone,
+			lines
+		};
+	}
+	#scanParts() {
+		const text = this.#text;
+		const parts = [];
+		const pushText = (start, end) => {
+			if (end > start) parts.push({
+				kind: "text",
+				start,
+				end,
+				from: start,
+				to: end
+			});
+		};
+		while (this.#pos < text.length) {
+			const open = this.#findOpen(this.#pos);
+			if (open === -1) {
+				pushText(this.#pos, text.length);
+				break;
+			}
+			pushText(this.#pos, open);
+			const kind = text[open + 1];
+			if (kind === "#") {
+				parts.push(this.#scanComment(open));
+				continue;
+			}
+			const part = this.#scanDelimited(open, kind === "{" ? "output" : "tag");
+			parts.push(part);
+			const inner = part.tokens;
+			if (part.kind === "tag" && inner.length === 3 && inner[1]?.type === "name" && inner[1].value === "verbatim") this.#scanVerbatim(part, parts);
+		}
+		return parts;
+	}
+	#findOpen(from) {
+		const text = this.#text;
+		let index = text.indexOf("{", from);
+		while (index !== -1) {
+			const next = text.charCodeAt(index + 1);
+			if (next === 123 || next === 37 || next === 35) return index;
+			index = text.indexOf("{", index + 1);
+		}
+		return -1;
+	}
+	#scanComment(open) {
+		const text = this.#text;
+		const close = text.indexOf("#}", open + 2);
+		const trimBefore = text[open + 2] === "-";
+		if (close === -1) {
+			this.#problem("unclosed-comment", "Comment is missing its closing \"#}\"", open, open + 2);
+			this.#pos = text.length;
+			return {
+				kind: "comment",
+				start: open,
+				end: text.length,
+				trimBefore,
+				trimAfter: false,
+				tokens: []
+			};
+		}
+		this.#pos = close + 2;
+		return {
+			kind: "comment",
+			start: open,
+			end: close + 2,
+			trimBefore,
+			trimAfter: close > open + 2 && text[close - 1] === "-",
+			tokens: []
+		};
+	}
+	#scanDelimited(open, kind) {
+		const text = this.#text;
+		const trimBefore = text[open + 2] === "-";
+		this.#tokens = [{
+			type: kind === "output" ? "outputOpen" : "tagOpen",
+			value: text.slice(open, open + (trimBefore ? 3 : 2)),
+			start: open,
+			end: open + 2
+		}];
+		this.#pos = open + (trimBefore ? 3 : 2);
+		const closeStart = this.#pos;
+		const { trim, closed } = this.#lexExpression(kind);
+		const end = this.#pos;
+		if (!closed) this.#problem("unclosed-tag", kind === "output" ? "Output is missing its closing \"}}\"" : "Tag is missing its closing \"%}\"", open, open + 2);
+		this.#tokens.push({
+			type: kind === "output" ? "outputClose" : "tagClose",
+			value: closed ? text.slice(trim ? end - 3 : end - 2, end) : "",
+			start: closed ? end - 2 : Math.max(closeStart, end),
+			end
+		});
+		return {
+			kind,
+			start: open,
+			end,
+			trimBefore,
+			trimAfter: trim,
+			tokens: this.#tokens
+		};
+	}
+	/** Treats everything up to `{% endverbatim %}` as text. */
+	#scanVerbatim(tag, parts) {
+		const text = this.#text;
+		VERBATIM_END.lastIndex = this.#pos;
+		const match = VERBATIM_END.exec(text);
+		if (!match) {
+			this.#problem("unclosed-block", "\"verbatim\" is missing its \"endverbatim\" tag", tag.start, tag.end);
+			parts.push({
+				kind: "text",
+				start: this.#pos,
+				end: text.length,
+				from: this.#pos,
+				to: text.length
+			});
+			this.#pos = text.length;
+			return;
+		}
+		const start = match.index;
+		const end = start + match[0].length;
+		if (start > this.#pos) parts.push({
+			kind: "text",
+			start: this.#pos,
+			end: start,
+			from: this.#pos,
+			to: start
+		});
+		const nameStart = text.indexOf("endverbatim", start);
+		const trimBefore = match[1] === "-";
+		const trimAfter = match[2] === "-";
+		parts.push({
+			kind: "tag",
+			start,
+			end,
+			trimBefore,
+			trimAfter,
+			tokens: [
+				{
+					type: "tagOpen",
+					value: trimBefore ? "{%-" : "{%",
+					start,
+					end: start + 2
+				},
+				{
+					type: "name",
+					value: "endverbatim",
+					start: nameStart,
+					end: nameStart + 11
+				},
+				{
+					type: "tagClose",
+					value: trimAfter ? "-%}" : "%}",
+					start: end - 2,
+					end
+				}
+			]
+		});
+		this.#pos = end;
+	}
+	/**
+	* Lexes expression tokens until the closing delimiter for `mode`.
+	*
+	* `closed` is false when the source ended, or a new tag started, before the delimiter.
+	*/
+	#lexExpression(mode) {
+		const text = this.#text;
+		const length = text.length;
+		const tokens = this.#tokens;
+		let depth = 0;
+		let pos = this.#pos;
+		for (;;) {
+			while (pos < length && isSpace(text.charCodeAt(pos))) pos++;
+			if (pos >= length) {
+				this.#pos = pos;
+				return NOT_CLOSED;
+			}
+			const code = text.charCodeAt(pos);
+			const next = text.charCodeAt(pos + 1);
+			if (mode === "tag") {
+				if (code === 45 && next === 37 && text.charCodeAt(pos + 2) === 125) {
+					this.#pos = pos + 3;
+					return CLOSED_TRIM;
+				}
+				if (code === 37 && next === 125) {
+					this.#pos = pos + 2;
+					return CLOSED;
+				}
+			} else if (mode === "output" && depth === 0) {
+				if (code === 45 && next === 125 && text.charCodeAt(pos + 2) === 125) {
+					this.#pos = pos + 3;
+					return CLOSED_TRIM;
+				}
+				if (code === 125 && next === 125) {
+					this.#pos = pos + 2;
+					return CLOSED;
+				}
+			} else if (mode === "interp" && depth === 0 && code === 125) {
+				tokens.push({
+					type: "interpClose",
+					value: "}",
+					start: pos,
+					end: pos + 1
+				});
+				this.#pos = pos + 1;
+				return CLOSED;
+			}
+			if (code === 123 && (next === 123 || next === 37 || next === 35)) {
+				this.#pos = pos;
+				return NOT_CLOSED;
+			}
+			if (mode === "interp" && code === 37 && next === 125) {
+				this.#pos = pos;
+				return NOT_CLOSED;
+			}
+			if (isNameStart(code)) {
+				let end = pos + 1;
+				while (end < length && isNamePart(text.charCodeAt(end))) end++;
+				tokens.push({
+					type: "name",
+					value: text.slice(pos, end),
+					start: pos,
+					end
+				});
+				pos = end;
+				continue;
+			}
+			if (isDigit(code)) {
+				this.#pos = pos;
+				this.#lexNumber();
+				pos = this.#pos;
+				continue;
+			}
+			if (code === 34 || code === 39) {
+				this.#pos = pos;
+				this.#lexString();
+				pos = this.#pos;
+				continue;
+			}
+			const punct = punctuatorAt(text, pos, code, next);
+			if (punct !== null) {
+				if (code === 123) depth++;
+				else if (code === 125 && depth > 0) depth--;
+				tokens.push({
+					type: "punct",
+					value: punct,
+					start: pos,
+					end: pos + punct.length
+				});
+				pos += punct.length;
+				continue;
+			}
+			const character = String.fromCodePoint(text.codePointAt(pos));
+			this.#problem("unexpected-character", `Unexpected character "${character}"`, pos, pos + character.length);
+			pos += character.length;
+		}
+	}
+	#lexNumber() {
+		const text = this.#text;
+		const start = this.#pos;
+		const previous = this.#tokens[this.#tokens.length - 1];
+		const integerOnly = previous?.type === "punct" && (previous.value === "." || previous.value === "?.");
+		const readDigits = () => {
+			while (this.#pos < text.length) {
+				const code = text.charCodeAt(this.#pos);
+				if (isDigit(code)) this.#pos++;
+				else if (code === 95 && isDigit(text.charCodeAt(this.#pos + 1))) this.#pos++;
+				else break;
+			}
+		};
+		readDigits();
+		if (!integerOnly && text[this.#pos] === "." && isDigit(text.charCodeAt(this.#pos + 1))) {
+			this.#pos++;
+			readDigits();
+		}
+		const raw = text.slice(start, this.#pos);
+		this.#push("number", raw.replaceAll("_", ""), start, this.#pos);
+	}
+	#lexString() {
+		const text = this.#text;
+		const start = this.#pos;
+		const quote = text[start];
+		let value = "";
+		let segmentStart = start;
+		let interpolated = false;
+		this.#pos++;
+		while (this.#pos < text.length) {
+			const char = text[this.#pos];
+			if (char === quote) {
+				this.#pos++;
+				if (interpolated) {
+					if (value !== "") this.#push("string", value, segmentStart, this.#pos - 1);
+					this.#push("stringEnd", quote, this.#pos - 1, this.#pos);
+				} else this.#push("string", value, start, this.#pos);
+				return;
+			}
+			if (char === "\\") {
+				value += this.#readEscape(quote);
+				continue;
+			}
+			if (quote === "\"" && char === "#" && text[this.#pos + 1] === "{") {
+				if (!interpolated) {
+					interpolated = true;
+					this.#push("stringStart", quote, start, start + 1);
+				}
+				if (value !== "") {
+					this.#push("string", value, segmentStart, this.#pos);
+					value = "";
+				}
+				this.#push("interpOpen", "#{", this.#pos, this.#pos + 2);
+				this.#pos += 2;
+				const interpStart = this.#pos;
+				if (this.#interpolations === 200) {
+					this.#problem("too-deep", `Template is nested more than 200 levels deep`, interpStart - 2, interpStart);
+					this.#skipInterpolation();
+					segmentStart = this.#pos;
+					continue;
+				}
+				this.#interpolations++;
+				const { closed } = this.#lexExpression("interp");
+				this.#interpolations--;
+				if (!closed) {
+					this.#problem("unclosed-interpolation", "Interpolation is missing its closing \"}\"", interpStart - 2, interpStart);
+					this.#push("interpClose", "", this.#pos, this.#pos);
+					this.#push("stringEnd", "", this.#pos, this.#pos);
+					return;
+				}
+				segmentStart = this.#pos;
+				continue;
+			}
+			value += char;
+			this.#pos++;
+		}
+		this.#problem("unclosed-string", "String is missing its closing quote", start, start + 1);
+		if (interpolated) {
+			if (value !== "") this.#push("string", value, segmentStart, this.#pos);
+			this.#push("stringEnd", "", this.#pos, this.#pos);
+		} else this.#push("string", value, start, this.#pos);
+	}
+	/** Skips the rest of an interpolation without lexing it, up to the `}` that balances its `#{`. */
+	#skipInterpolation() {
+		const text = this.#text;
+		let depth = 0;
+		while (this.#pos < text.length) {
+			const char = text[this.#pos++];
+			if (char === "{") depth++;
+			else if (char === "}" && depth-- === 0) {
+				this.#push("interpClose", "}", this.#pos - 1, this.#pos);
+				return;
+			}
+		}
+	}
+	/** Reads a backslash escape. `\#{` is only an escape in double-quoted strings, where `#{` would start interpolation. */
+	#readEscape(quote) {
+		const text = this.#text;
+		const start = this.#pos;
+		const next = text[start + 1];
+		if (next === void 0) {
+			this.#pos++;
+			return "";
+		}
+		if (next === "#" && quote === "\"" && text[start + 2] === "{") {
+			this.#pos += 2;
+			return "#";
+		}
+		const simple = ESCAPES[next];
+		if (simple !== void 0) {
+			this.#pos += 2;
+			return simple;
+		}
+		if (next === "u" && text[start + 2] === "{") {
+			const brace = text.slice(start + 3, start + 10).indexOf("}");
+			const close = brace === -1 ? -1 : start + 3 + brace;
+			const hex = close === -1 ? "" : text.slice(start + 3, close);
+			if (/^[0-9a-fA-F]{1,6}$/.test(hex)) {
+				const code = Number.parseInt(hex, 16);
+				if (code <= 1114111) {
+					this.#pos = close + 1;
+					return String.fromCodePoint(code);
+				}
+			}
+		}
+		this.#problem("invalid-escape", `Unknown escape sequence "\\${next}"`, start, start + 2);
+		this.#pos += 2;
+		return next;
+	}
+	#push(type, value, start, end) {
+		this.#tokens.push({
+			type,
+			value,
+			start,
+			end
+		});
+	}
+	#problem(code, message, start, end) {
+		this.#problems.push({
+			code,
+			message,
+			span: {
+				start,
+				end
+			}
+		});
+	}
+};
+/** Applies `-` markers, which remove all whitespace on their side. */
+const applyTrimMarkers = (text, parts) => {
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		if (part.kind === "text") continue;
+		const previous = parts[i - 1];
+		if (part.trimBefore && previous?.kind === "text") {
+			let end = previous.end;
+			while (end > previous.start && isSpace(text.charCodeAt(end - 1))) end--;
+			previous.to = Math.min(previous.to, end);
+		}
+		const next = parts[i + 1];
+		if (part.trimAfter && next?.kind === "text") {
+			let start = next.start;
+			while (start < next.end && isSpace(text.charCodeAt(start))) start++;
+			next.from = Math.max(next.from, start);
+		}
+	}
+};
+const isInlineBlank = (text, start, end) => {
+	for (let i = start; i < end; i++) if (!isInlineSpace(text.charCodeAt(i))) return false;
+	return true;
+};
+/**
+* The first line feed from `start` up to `end`, or -1. The search stops at `end`, unlike `indexOf`, so a template with
+* many tags on one long line stays linear.
+*/
+const newlineIn = (text, start, end) => {
+	for (let i = start; i < end; i++) if (text.charCodeAt(i) === 10) return i;
+	return -1;
+};
+/** The last line feed from `start` up to `end`, or -1. Stops at `start`, as `newlineIn` stops at `end`. */
+const lastNewlineIn = (text, start, end) => {
+	for (let i = end - 1; i >= start; i--) if (text.charCodeAt(i) === 10) return i;
+	return -1;
+};
+/**
+* Removes lines that hold only block tags and comments, including their indentation and line ending.
+*
+* Decisions use the original text, so they do not depend on what trim markers removed. Returns the start of each tag and comment it removed.
+*/
+const applyStandaloneLines = (text, parts) => {
+	const removed = /* @__PURE__ */ new Map();
+	const isBlockLike = (part) => part !== void 0 && (part.kind === "tag" || part.kind === "comment");
+	let i = 0;
+	while (i < parts.length) {
+		if (!isBlockLike(parts[i])) {
+			i++;
+			continue;
+		}
+		let last = i;
+		for (;;) {
+			const next = parts[last + 1];
+			if (isBlockLike(next)) {
+				last++;
+				continue;
+			}
+			if (next?.kind === "text" && isInlineBlank(text, next.start, next.end) && isBlockLike(parts[last + 2])) {
+				last += 2;
+				continue;
+			}
+			break;
+		}
+		let standalone = true;
+		let cutBefore = -1;
+		const previous = parts[i - 1];
+		if (previous) {
+			if (previous.kind !== "text") standalone = false;
+			else {
+				const newline = lastNewlineIn(text, previous.start, previous.end);
+				if (newline !== -1) {
+					if (isInlineBlank(text, newline + 1, previous.end)) cutBefore = newline + 1;
+					else standalone = false;
+				} else if (i - 1 === 0 && isInlineBlank(text, previous.start, previous.end)) cutBefore = previous.start;
+				else standalone = false;
+			}
+		}
+		let cutAfter = -1;
+		const next = parts[last + 1];
+		if (standalone && next) {
+			if (next.kind !== "text") standalone = false;
+			else {
+				const newline = newlineIn(text, next.start, next.end);
+				if (newline !== -1) {
+					if (isInlineBlank(text, next.start, newline)) cutAfter = newline + 1;
+					else standalone = false;
+				} else if (last + 1 === parts.length - 1 && isInlineBlank(text, next.start, next.end)) cutAfter = next.end;
+				else standalone = false;
+			}
+		}
+		if (standalone) {
+			if (previous?.kind === "text") previous.to = Math.min(previous.to, cutBefore);
+			for (let k = i; k <= last; k++) {
+				const part = parts[k];
+				if (part.kind === "text") part.from = part.to;
+				else removed.set(part.start, part.end);
+			}
+			if (next?.kind === "text") next.from = Math.max(next.from, cutAfter);
+		}
+		i = last + 1;
+	}
+	return removed;
+};
+/** Finds the lines of text that hold content. See `TextLine`. */
+const textLines = (text, parts, removed) => {
+	const lines = [];
+	const add = (start) => {
+		let indentEnd = start;
+		while (text[indentEnd] === " " || text[indentEnd] === "	") indentEnd++;
+		const next = text[indentEnd];
+		if (next === void 0 || next === "\n" || next === "\r") return;
+		if (removed.has(indentEnd)) return;
+		lines.push({
+			start,
+			indentEnd
+		});
+	};
+	const first = parts[0];
+	const start = contentStart(text);
+	if (first && (first.kind !== "text" || first.from === start)) add(start);
+	for (const part of parts) {
+		if (part.kind !== "text") continue;
+		for (let newline = newlineIn(text, part.start, part.end); newline !== -1; newline = newlineIn(text, newline + 1, part.end)) {
+			const start = newline + 1;
+			if (start < part.from || start > part.to) continue;
+			add(start);
+		}
+	}
+	return lines;
+};
+//#endregion
+//#region src/parser/indent.ts
+/** The bodies a statement holds. Branches share their tag's body. A component's fills are bodies of their own, inside the component's. */
+const bodiesOf = (node) => {
+	const own = (lists, full = false) => ({
+		open: node.span.start,
+		end: node.span.end,
+		lists,
+		full
+	});
+	switch (node.type) {
+		case "If": return [own([...node.branches.map((branch) => branch.body), node.alternate ?? []])];
+		case "For": return [own([node.body, node.alternate ?? []])];
+		case "Component": return [...node.fills.map((fill) => ({
+			open: fill.span.start,
+			end: fill.span.end,
+			lists: [fill.body],
+			full: true
+		})), own([node.body, ...node.fills.map((fill) => fill.body)], true)];
+		case "Island": return [{
+			...own([node.body]),
+			keep: true
+		}];
+		case "Block":
+		case "Slot":
+		case "Add": return [own([node.body], true)];
+		case "SetBlock":
+		case "Macro":
+		case "Cache":
+		case "With":
+		case "Apply":
+		case "Autoescape": return [own([node.body])];
+		default: return NO_BODIES;
+	}
+};
+const NO_BODIES = [];
+/** The statement lists inside a statement, each once. Only a component's fills appear in more than one body. */
+const childLists = (bodies) => bodies.length === 1 ? bodies[0].lists : new Set(bodies.flatMap((body) => body.lists));
+/** The index of the first item whose key is at least `value`, in a list sorted by that key. */
+const firstAtLeast = (items, value, key) => {
+	let low = 0;
+	let high = items.length;
+	while (low < high) {
+		const middle = low + high >>> 1;
+		if (key(items[middle]) < value) low = middle + 1;
+		else high = middle;
+	}
+	return low;
+};
+/**
+* Finds `<pre>` and `<textarea>` tags, and the HTML comments, scripts and styles to skip, whose `<pre` is not a tag.
+* Each region runs to its end, or to the end of the source when it is not closed.
+*/
+const MARKUP = /<!--[\s\S]*?(?:-->|$)|<(script|style)(?=[\s/>])[\s\S]*?(?:<\/\1\s*>|$)|<(\/?)(pre|textarea)(?=[\s/>])/gi;
+const MAY_PREFORMAT = /<(?:pre|textarea)/i;
+/** Where `<pre>` and `<textarea>` elements start and end in the template's text, whose whitespace is content. */
+const preformatted = (text, textTokens) => {
+	if (!MAY_PREFORMAT.test(text)) return [];
+	let visible = "";
+	for (const token of textTokens) {
+		visible += "\0".repeat(token.start - visible.length);
+		visible += text.slice(token.start, token.end);
+	}
+	const ranges = [];
+	let open = null;
+	MARKUP.lastIndex = 0;
+	for (let match = MARKUP.exec(visible); match; match = MARKUP.exec(visible)) {
+		const tag = match[3];
+		if (tag === void 0) continue;
+		const name = tag.toLowerCase();
+		if (open === null && match[2] === "") open = {
+			name,
+			start: match.index
+		};
+		else if (open?.name === name && match[2] === "/") {
+			ranges.push([open.start, match.index]);
+			open = null;
+		}
+	}
+	if (open) ranges.push([open.start, text.length]);
+	return ranges;
+};
+/**
+* Works out the indentation of a template's text, so content can be inserted elsewhere and still line up.
+*
+* - Removes the extra indentation inside tags that stand on their own line: the spaces and tabs that every content line inside shares, beyond the tag's own. Blocks, slots and a component's content can be inserted where another tag stands, so they lose all of it and take the indentation of where they land.
+* - Sets `indent` on the tags in `placedNodes`, which insert content, when they stand on their own line: the line's indentation once that removal is done.
+* - Sets `lines` on text nodes: where each line of text starts, to take the indentation of where the text is inserted.
+*
+* Lines inside `<pre>` and `<textarea>` keep their whitespace. Amounts come from the source alone, so nested tags each remove their own step whatever order they are visited in.
+*/
+const arrangeIndentation = (ast, text, { tokens, standalone, lines }, placedNodes) => {
+	const textTokens = tokens.filter((token) => token.type === "text");
+	const pre = preformatted(text, textTokens);
+	const inPre = (offset) => {
+		const range = pre[firstAtLeast(pre, offset, (range) => range[1])];
+		return range !== void 0 && range[0] < offset;
+	};
+	const textLines = pre.length > 0 ? lines.filter((line) => !inPre(line.start)) : lines;
+	const lineStart = (offset) => text.lastIndexOf("\n", offset - 1) + 1 || contentStart(text);
+	const lineOf = (offset) => {
+		const start = lineStart(offset);
+		let indentEnd = start;
+		while (text[indentEnd] === " " || text[indentEnd] === "	") indentEnd++;
+		return {
+			start,
+			indentEnd
+		};
+	};
+	const placed = [];
+	const islandEnds = [];
+	for (const node of placedNodes) {
+		if (inPre(node.span.start)) continue;
+		if (node.type === "Island") {
+			const end = text.lastIndexOf("{%", node.span.end - 1);
+			if (standalone.has(end)) islandEnds.push({
+				node,
+				line: lineOf(end)
+			});
+		}
+		if (!standalone.has(node.span.start)) continue;
+		placed.push({
+			node,
+			line: lineOf(node.span.start)
+		});
+	}
+	const contentLines = placed.length > 0 || islandEnds.length > 0 ? [
+		...textLines,
+		...placed.map((item) => item.line),
+		...islandEnds.map((item) => item.line)
+	].sort((a, b) => a.start - b.start) : textLines;
+	const cuts = [];
+	const indentOf = (offset) => {
+		const line = lineOf(offset);
+		return text.slice(line.start, line.indentEnd);
+	};
+	const trim = (body) => {
+		if (body.keep) return;
+		const openEnd = standalone.get(body.open);
+		if (openEnd === void 0) return;
+		const newline = text.indexOf("\n", openEnd);
+		if (newline === -1) return;
+		const to = text.lastIndexOf("{%", body.end - 1);
+		const first = firstAtLeast(contentLines, newline + 1, (line) => line.start);
+		const last = firstAtLeast(contentLines, to, (line) => line.start);
+		if (first >= last) return;
+		let shared = Infinity;
+		const firstLine = contentLines[first];
+		for (let i = first; i < last; i++) {
+			const line = contentLines[i];
+			let length = 0;
+			while (length < line.indentEnd - line.start && text[line.start + length] === text[firstLine.start + length]) length++;
+			shared = Math.min(shared, length);
+		}
+		let keep = 0;
+		if (!body.full) {
+			const own = indentOf(body.open);
+			if (shared <= own.length) return;
+			if (text.slice(firstLine.start, firstLine.start + own.length) !== own) return;
+			keep = own.length;
+		} else if (shared === 0) return;
+		for (let i = first; i < last; i++) {
+			const line = contentLines[i];
+			cuts.push([line.start + keep, line.start + shared]);
+		}
+	};
+	const visit = (list) => {
+		for (const node of list) {
+			const bodies = bodiesOf(node);
+			if (bodies.length === 0) continue;
+			for (const child of childLists(bodies)) visit(child);
+			for (const body of bodies) trim(body);
+		}
+	};
+	visit(ast.body);
+	cuts.sort((a, b) => a[0] - b[0]);
+	const merged = [];
+	for (const range of cuts) {
+		const previous = merged[merged.length - 1];
+		if (previous && range[0] <= previous[1]) previous[1] = Math.max(previous[1], range[1]);
+		else merged.push(range);
+	}
+	/** The source from `start` to `end`, without the cut ranges. */
+	const uncut = (start, end) => {
+		let out = "";
+		let at = start;
+		for (let i = firstAtLeast(merged, start, (range) => range[1] - 1); i < merged.length; i++) {
+			const [from, to] = merged[i];
+			if (from >= end) break;
+			out += text.slice(at, Math.max(at, from));
+			at = Math.max(at, to);
+		}
+		return out + text.slice(Math.min(at, end), end);
+	};
+	for (const { node, line } of placed) node.indent = uncut(line.start, line.indentEnd);
+	for (const { node, line } of islandEnds) node.closing = {
+		indent: line.start === lineOf(node.span.start).start ? null : uncut(line.start, line.indentEnd),
+		newline: text.includes("\n", node.span.end)
+	};
+	const hasCut = (start, end) => {
+		const range = merged[firstAtLeast(merged, start, (range) => range[1] - 1)];
+		return range !== void 0 && range[0] < end;
+	};
+	const rewrite = (list) => {
+		for (const node of list) {
+			if (node.type === "Text") {
+				let line = firstAtLeast(textLines, node.span.start, (l) => l.start);
+				const hasLines = (textLines[line]?.start ?? Infinity) <= node.span.end;
+				const cut = hasCut(node.span.start, node.span.end);
+				if (!hasLines && !cut) continue;
+				let value = "";
+				let size = 0;
+				const starts = [];
+				for (let i = firstAtLeast(textTokens, node.span.start, (t) => t.start); i < textTokens.length; i++) {
+					const token = textTokens[i];
+					if (token.end > node.span.end) break;
+					for (let next = textLines[line]; next !== void 0 && next.start <= token.end; next = textLines[++line]) starts.push(size + (cut ? uncut(token.start, next.start).length : next.start - token.start));
+					if (cut) {
+						const piece = uncut(token.start, token.end);
+						value += piece;
+						size += piece.length;
+					} else size += token.end - token.start;
+				}
+				if (cut) node.value = value;
+				if (starts.length > 0) node.lines = starts;
+			}
+			const bodies = bodiesOf(node);
+			if (bodies.length > 0) for (const child of childLists(bodies)) rewrite(child);
+		}
+	};
+	rewrite(ast.body);
+};
+//#endregion
+//#region src/parser/parser.ts
+const isTypeName = (name) => TYPE_NAMES.includes(name);
+/** Names that cannot be declared as variables, because Kiln uses them itself. */
+const RESERVED_NAMES = /* @__PURE__ */ new Set([
+	"true",
+	"false",
+	"null",
+	"and",
+	"or",
+	"not",
+	"in",
+	"is",
+	"loop",
+	"slots"
+]);
+/** Parses template source into a syntax tree, collecting every problem instead of stopping at the first. */
+const parse = (text, options) => {
+	const lexed = lex(text);
+	const parser = new Parser(lexed.tokens, options);
+	const ast = parser.parseTemplate(text.length);
+	arrangeIndentation(ast, text, lexed, parser.placed);
+	return {
+		ast,
+		problems: [...lexed.problems, ...parser.problems]
+	};
+};
+var ParseFailure = class {
+	code;
+	message;
+	span;
+	constructor(code, message, span) {
+		this.code = code;
+		this.message = message;
+		this.span = span;
+	}
+};
+/** Words that can follow a one-word test, so they never form part of a two-word test name. */
+const NOT_TEST_WORDS = /* @__PURE__ */ new Set([
+	"and",
+	"or",
+	"not",
+	"in",
+	"is",
+	"starts",
+	"ends",
+	"with",
+	"ignore",
+	"as"
+]);
+const COMPARISON_PUNCTUATORS = /* @__PURE__ */ new Set([
+	"==",
+	"!=",
+	"<",
+	">",
+	"<=",
+	">="
+]);
+const describeToken = (token) => {
+	switch (token.type) {
+		case "eof": return "the end of the template";
+		case "tagClose": return "\"%}\"";
+		case "outputClose": return "\"}}\"";
+		case "text": return "text";
+		case "string": return "a string";
+		case "stringStart": return "an interpolated string";
+		case "number": return `number ${token.value}`;
+		default: return `"${token.value}"`;
+	}
+};
+var Parser = class {
+	problems = [];
+	/** Every tag that inserts content, for `arrangeIndentation`. */
+	placed = [];
+	#tokens;
+	#options;
+	#index = 0;
+	#lastEnd = 0;
+	#nesting = 0;
+	/** End tag names of every open block tag, innermost last. */
+	#endStack = [];
+	constructor(tokens, options) {
+		this.#tokens = tokens;
+		this.#options = options;
+	}
+	parseTemplate(length) {
+		const { body } = this.#parseBody([]);
+		return {
+			type: "Template",
+			body,
+			span: {
+				start: 0,
+				end: length
+			}
+		};
+	}
+	#peek(offset = 0) {
+		return this.#tokens[this.#index + offset] ?? this.#tokens[this.#tokens.length - 1];
+	}
+	#next() {
+		const token = this.#peek();
+		if (token.type !== "eof") this.#index++;
+		this.#lastEnd = token.end;
+		return token;
+	}
+	#isPunct(value, offset = 0) {
+		const token = this.#peek(offset);
+		return token.type === "punct" && token.value === value;
+	}
+	#isName(value, offset = 0) {
+		const token = this.#peek(offset);
+		return token.type === "name" && token.value === value;
+	}
+	#fail(message, token = this.#peek(), code = "unexpected-token") {
+		throw new ParseFailure(code, message, {
+			start: token.start,
+			end: Math.max(token.end, token.start + 1)
+		});
+	}
+	#expectPunct(value) {
+		if (!this.#isPunct(value)) this.#fail(`Expected "${value}" but found ${describeToken(this.#peek())}`);
+		return this.#next();
+	}
+	#expectName(what = "a name") {
+		const token = this.#peek();
+		if (token.type !== "name") this.#fail(`Expected ${what} but found ${describeToken(token)}`);
+		return this.#next();
+	}
+	#expectKeyword(value) {
+		if (!this.#isName(value)) this.#fail(`Expected "${value}" but found ${describeToken(this.#peek())}`);
+		return this.#next();
+	}
+	#expectTagEnd() {
+		const token = this.#peek();
+		if (token.type !== "tagClose") this.#fail(`Expected "%}" but found ${describeToken(token)}`);
+		return this.#next();
+	}
+	#expectDeclarableName(what) {
+		const token = this.#expectName(what);
+		if (RESERVED_NAMES.has(token.value)) this.#problem("reserved-name", `"${token.value}" is reserved and cannot be used as a name`, token);
+		return token;
+	}
+	#problem(code, message, span) {
+		this.problems.push({
+			code,
+			message,
+			span: {
+				start: span.start,
+				end: span.end
+			}
+		});
+	}
+	/** Skips to just after the end of the current tag or output. */
+	#recover() {
+		for (;;) {
+			const token = this.#peek();
+			if (token.type === "eof") return;
+			if (token.type === "tagClose" || token.type === "outputClose") {
+				this.#next();
+				return;
+			}
+			if (token.type === "text" || token.type === "tagOpen" || token.type === "outputOpen") return;
+			this.#next();
+		}
+	}
+	#record(failure) {
+		if (!(failure instanceof ParseFailure)) throw failure;
+		this.#problem(failure.code, failure.message, failure.span);
+		this.#recover();
+	}
+	/**
+	* Parses a block tag's header and its `%}`. If that fails, records the problem and skips to the end of the tag, so the body still parses.
+	*/
+	#header(parse, fallback) {
+		try {
+			const result = parse();
+			this.#expectTagEnd();
+			return result;
+		} catch (failure) {
+			this.#record(failure);
+			return fallback;
+		}
+	}
+	/** Whether the current tag holds the punctuator `value` before its `%}`. */
+	#tagHasPunct(value) {
+		for (let offset = 0;; offset++) {
+			const token = this.#peek(offset);
+			if (token.type === "punct" && token.value === value) return true;
+			if (token.type === "tagClose" || token.type === "eof" || token.type === "text" || token.type === "tagOpen" || token.type === "outputOpen") return false;
+		}
+	}
+	#invalid() {
+		const token = this.#peek();
+		return {
+			type: "Invalid",
+			span: {
+				start: token.start,
+				end: token.end
+			}
+		};
+	}
+	#parseBody(ends) {
+		this.#enter();
+		const body = [];
+		this.#endStack.push(ends);
+		try {
+			for (;;) {
+				const token = this.#peek();
+				switch (token.type) {
+					case "eof": return {
+						body,
+						end: null
+					};
+					case "text": {
+						this.#next();
+						const previous = body[body.length - 1];
+						if (previous?.type === "Text") {
+							previous.value += token.value;
+							previous.span = {
+								start: previous.span.start,
+								end: token.end
+							};
+						} else body.push({
+							type: "Text",
+							value: token.value,
+							span: {
+								start: token.start,
+								end: token.end
+							}
+						});
+						break;
+					}
+					case "outputOpen":
+						this.#parseOutput(body);
+						break;
+					case "tagOpen": {
+						const name = this.#peek(1);
+						if (name.type === "name") {
+							if (ends.includes(name.value)) {
+								this.#next();
+								this.#next();
+								return {
+									body,
+									end: name
+								};
+							}
+							if (this.#endStack.some((outer) => outer.includes(name.value))) return {
+								body,
+								end: null
+							};
+						}
+						this.#parseTag(body);
+						break;
+					}
+					default: this.#next();
+				}
+			}
+		} finally {
+			this.#endStack.pop();
+			this.#nesting--;
+		}
+	}
+	#parseOutput(body) {
+		const open = this.#next();
+		try {
+			const expression = this.#parseExpression();
+			const close = this.#peek();
+			if (close.type !== "outputClose") this.#fail(`Expected "}}" but found ${describeToken(close)}`);
+			this.#next();
+			body.push({
+				type: "Output",
+				expression,
+				span: {
+					start: open.start,
+					end: close.end
+				}
+			});
+		} catch (failure) {
+			this.#record(failure);
+		}
+	}
+	#parseTag(body) {
+		const open = this.#next();
+		const nameToken = this.#peek();
+		if (nameToken.type !== "name") {
+			this.#problem("unexpected-token", `Expected a tag name but found ${describeToken(nameToken)}`, nameToken);
+			this.#recover();
+			return;
+		}
+		this.#next();
+		const name = nameToken.value;
+		try {
+			const statement = this.#parseNamedTag(name, open, nameToken);
+			if (statement) body.push(statement);
+		} catch (failure) {
+			this.#record(failure);
+		}
+	}
+	#parseNamedTag(name, open, nameToken) {
+		switch (name) {
+			case "if": return this.#parseIf(open);
+			case "for": return this.#parseFor(open);
+			case "set": return this.#parseSet(open);
+			case "props": return this.#parseProps(open);
+			case "extends": {
+				const template = this.#parseExpression();
+				const close = this.#expectTagEnd();
+				return {
+					type: "Extends",
+					template,
+					span: {
+						start: open.start,
+						end: close.end
+					}
+				};
+			}
+			case "block": return this.#parseBlock(open);
+			case "include": return this.#parseInclude(open);
+			case "component": return this.#parseComponent(open);
+			case "slot": return this.#parseSlot(open);
+			case "macro": return this.#parseMacro(open);
+			case "import": return this.#parseImport(open);
+			case "from": return this.#parseFromImport(open);
+			case "with": return this.#parseWith(open);
+			case "cache": return this.#parseCache(open);
+			case "island": return this.#parseIsland(open);
+			case "outlet": {
+				const name = this.#parseStringLiteral("an outlet name");
+				const close = this.#expectTagEnd();
+				return this.#placed({
+					type: "Outlet",
+					name,
+					span: {
+						start: open.start,
+						end: close.end
+					}
+				});
+			}
+			case "flush": {
+				const close = this.#expectTagEnd();
+				return {
+					type: "Flush",
+					span: {
+						start: open.start,
+						end: close.end
+					}
+				};
+			}
+			case "add": return this.#parseAdd(open);
+			case "apply": return this.#parseApply(open);
+			case "autoescape": return this.#parseAutoescape(open);
+			case "verbatim": return this.#parseVerbatim(open);
+			default: {
+				const stray = name.startsWith("end") || name === "else" || name === "elseif" || name === "fill";
+				this.#problem(stray ? "unexpected-tag" : "unknown-tag", stray ? `"${name}" has no matching opening tag here` : `Unknown tag "${name}"`, nameToken);
+				this.#recover();
+				return null;
+			}
+		}
+	}
+	/** Reports a block tag whose end tag never came. */
+	#unclosed(name, open, endName) {
+		this.#problem("unclosed-block", `"${name}" is missing its "${endName}" tag`, {
+			start: open.start,
+			end: open.end
+		});
+	}
+	/** Consumes an end tag's `%}`, plus an optional repeated name such as `endblock content`. */
+	#finishEndTag(expectedName) {
+		try {
+			if (expectedName !== void 0 && this.#peek().type === "name") {
+				const repeated = this.#next();
+				if (repeated.value !== expectedName) this.#problem("mismatched-end", `End tag names "${repeated.value}" but closes "${expectedName}"`, repeated);
+			}
+			this.#expectTagEnd();
+		} catch (failure) {
+			this.#record(failure);
+		}
+	}
+	#parseIf(open) {
+		const branches = [];
+		let test = this.#header(() => this.#parseExpression(), this.#invalid());
+		let alternate = null;
+		for (;;) {
+			const { body, end } = this.#parseBody([
+				"elseif",
+				"else",
+				"endif"
+			]);
+			branches.push({
+				test,
+				body
+			});
+			if (!end) {
+				this.#unclosed("if", open, "endif");
+				break;
+			}
+			if (end.value === "elseif") {
+				test = this.#header(() => this.#parseExpression(), this.#invalid());
+				continue;
+			}
+			if (end.value === "else") {
+				this.#finishEndTag();
+				alternate = this.#parseAlternate("if", open, ["elseif", "else"]);
+				break;
+			}
+			this.#finishEndTag();
+			break;
+		}
+		return {
+			type: "If",
+			branches,
+			alternate,
+			span: {
+				start: open.start,
+				end: this.#lastEnd
+			}
+		};
+	}
+	/**
+	* Parses the `else` branch of `if` or `for` up to its end tag. A branch tag after `else`, such as a second `else`,
+	* is reported where it stands, so it can't close an outer tag instead.
+	*/
+	#parseAlternate(name, open, branches) {
+		const endName = `end${name}`;
+		const alternate = [];
+		for (;;) {
+			const { body, end } = this.#parseBody([endName, ...branches]);
+			alternate.push(...body);
+			if (!end) {
+				this.#unclosed(name, open, endName);
+				return alternate;
+			}
+			if (end.value === endName) {
+				this.#finishEndTag();
+				return alternate;
+			}
+			this.#problem("unexpected-tag", `"${end.value}" cannot follow "else" in "${name}"`, end);
+			this.#recover();
+		}
+	}
+	#parseFor(open) {
+		const header = this.#header(() => {
+			let keyName = null;
+			let valueName = this.#expectDeclarableName("a loop variable").value;
+			if (this.#isPunct(",")) {
+				this.#next();
+				keyName = valueName;
+				valueName = this.#expectDeclarableName("a loop variable").value;
+			}
+			this.#expectKeyword("in");
+			const iterable = this.#parseExpression();
+			return {
+				keyName,
+				valueName,
+				iterable
+			};
+		}, {
+			keyName: null,
+			valueName: "_",
+			iterable: this.#invalid()
+		});
+		const { body, end } = this.#parseBody(["else", "endfor"]);
+		let alternate = null;
+		if (!end) this.#unclosed("for", open, "endfor");
+		else if (end.value === "else") {
+			this.#finishEndTag();
+			alternate = this.#parseAlternate("for", open, ["else"]);
+		} else this.#finishEndTag();
+		return {
+			type: "For",
+			...header,
+			body,
+			alternate,
+			span: {
+				start: open.start,
+				end: this.#lastEnd
+			}
+		};
+	}
+	#parseSet(open) {
+		if (this.#tagHasPunct("=")) {
+			const name = this.#expectDeclarableName("a variable name").value;
+			this.#expectPunct("=");
+			const value = this.#parseExpression();
+			const close = this.#expectTagEnd();
+			return {
+				type: "Set",
+				name,
+				value,
+				span: {
+					start: open.start,
+					end: close.end
+				}
+			};
+		}
+		const name = this.#header(() => this.#expectDeclarableName("a variable name").value, "");
+		const { body, end } = this.#parseBody(["endset"]);
+		if (end) this.#finishEndTag();
+		else this.#unclosed("set", open, "endset");
+		return {
+			type: "SetBlock",
+			name,
+			body,
+			span: {
+				start: open.start,
+				end: this.#lastEnd
+			}
+		};
+	}
+	/** Reads parameters for `macro` and `props`. Only `props` may declare types, so macros' `type` is always null. */
+	#parseParams(closing, typed = false) {
+		const params = [];
+		const done = () => closing === null ? this.#peek().type === "tagClose" || this.#isPunct("...") : this.#isPunct(closing);
+		while (!done()) {
+			const nameToken = this.#expectDeclarableName("a parameter name");
+			if (params.some((param) => param.name === nameToken.value)) this.#problem("duplicate-parameter", `"${nameToken.value}" is declared more than once`, nameToken);
+			let type = null;
+			if (typed && this.#isPunct(":")) {
+				this.#next();
+				type = this.#parsePropType();
+			}
+			let defaultValue = null;
+			if (this.#isPunct("=")) {
+				this.#next();
+				defaultValue = this.#parseExpression();
+			}
+			params.push({
+				name: nameToken.value,
+				type,
+				default: defaultValue,
+				span: {
+					start: nameToken.start,
+					end: this.#lastEnd
+				}
+			});
+			if (!this.#isPunct(",")) break;
+			this.#next();
+		}
+		return params;
+	}
+	/** Reads a prop type such as `string | null`, `"primary" | "secondary"`, `Post[]` or `{ name: string }`. */
+	#parsePropType() {
+		this.#enter();
+		const nesting = this.#nesting;
+		try {
+			const members = [];
+			for (;;) {
+				let type = this.#parsePropTypeTerm();
+				while (this.#isPunct("[") && this.#isPunct("]", 1)) {
+					this.#enter();
+					this.#next();
+					this.#next();
+					type = [{ list: type }];
+				}
+				this.#nesting = nesting;
+				members.push(...type);
+				if (!this.#isPunct("|")) return members;
+				this.#next();
+			}
+		} finally {
+			this.#nesting = nesting - 1;
+		}
+	}
+	/** Reads one part of a union. Brackets return the union inside them, so `(2 | 3)[]` lists either. */
+	#parsePropTypeTerm() {
+		const token = this.#peek();
+		if (token.type === "punct" && token.value === "(") {
+			this.#next();
+			const inner = this.#parsePropType();
+			this.#expectPunct(")");
+			return inner;
+		}
+		if (token.type === "punct" && token.value === "{") return [{ shape: this.#parseShape() }];
+		this.#next();
+		if (token.type === "string") return [{ literal: token.value }];
+		if (token.type === "number") return [{ literal: Number(token.value) }];
+		if (token.type === "name" && isTypeName(token.value)) return [token.value];
+		if (token.type === "name" && /^[A-Z]/.test(token.value)) return [{ named: token.value }];
+		if (token.type === "name") {
+			this.#problem("unknown-type", `Unknown type "${token.value}"`, token);
+			return [];
+		}
+		return this.#fail(`Expected a type but found ${describeToken(token)}`, token);
+	}
+	/** Reads a shape type such as `{ name: string, url?: string }`. */
+	#parseShape() {
+		this.#expectPunct("{");
+		const keys = [];
+		while (!this.#isPunct("}")) {
+			const token = this.#next();
+			if (token.type !== "name" && token.type !== "string") this.#fail(`Expected a key but found ${describeToken(token)}`, token);
+			if (keys.some((key) => key.name === token.value)) this.#problem("duplicate-key", `"${token.value}" is declared more than once`, token);
+			const optional = this.#isPunct("?:") || this.#isPunct("?");
+			if (this.#isPunct("?:")) this.#next();
+			else {
+				if (optional) this.#next();
+				this.#expectPunct(":");
+			}
+			keys.push({
+				name: token.value,
+				optional,
+				type: this.#parsePropType()
+			});
+			if (!this.#isPunct(",")) break;
+			this.#next();
+		}
+		this.#expectPunct("}");
+		return keys;
+	}
+	#parseProps(open) {
+		const props = this.#parseParams(null, true);
+		let rest = null;
+		if (this.#isPunct("...")) {
+			this.#next();
+			const nameToken = this.#expectDeclarableName("a rest prop name");
+			if (props.some((prop) => prop.name === nameToken.value)) this.#problem("duplicate-parameter", `"${nameToken.value}" is declared more than once`, nameToken);
+			rest = nameToken.value;
+			if (this.#isPunct(",")) this.#next();
+			if (this.#peek().type !== "tagClose") this.#fail("The rest prop must come last, with no type or default");
+		}
+		const close = this.#expectTagEnd();
+		return {
+			type: "Props",
+			props,
+			rest,
+			span: {
+				start: open.start,
+				end: close.end
+			}
+		};
+	}
+	#parseBlock(open) {
+		const first = this.#peek();
+		if (first.type !== "name" && (first.type === "tagClose" || this.#peek(1).type === "tagClose")) {
+			this.#header(() => {
+				this.#expectName("a block name");
+			}, void 0);
+			const { end } = this.#parseBody(["endblock"]);
+			if (end) this.#finishEndTag();
+			else this.#unclosed("block", open, "endblock");
+			return null;
+		}
+		const name = this.#expectName("a block name").value;
+		if (this.#peek().type !== "tagClose") {
+			const expression = this.#parseExpression();
+			const close = this.#expectTagEnd();
+			return this.#placed({
+				type: "Block",
+				name,
+				body: [{
+					type: "Output",
+					expression,
+					span: {
+						start: expression.span.start,
+						end: expression.span.end
+					}
+				}],
+				span: {
+					start: open.start,
+					end: close.end
+				}
+			});
+		}
+		this.#expectTagEnd();
+		const { body, end } = this.#parseBody(["endblock"]);
+		if (end) this.#finishEndTag(name);
+		else this.#unclosed("block", open, "endblock");
+		return this.#placed({
+			type: "Block",
+			name,
+			body,
+			span: {
+				start: open.start,
+				end: this.#lastEnd
+			}
+		});
+	}
+	#parseInclude(open) {
+		const template = this.#parseExpression();
+		let withValue = null;
+		let ignoreMissing = false;
+		if (this.#isName("with")) {
+			this.#next();
+			withValue = this.#parseExpression();
+		}
+		if (this.#isName("ignore")) {
+			this.#next();
+			this.#expectKeyword("missing");
+			ignoreMissing = true;
+		}
+		const close = this.#expectTagEnd();
+		return this.#placed({
+			type: "Include",
+			template,
+			with: withValue,
+			ignoreMissing,
+			span: {
+				start: open.start,
+				end: close.end
+			}
+		});
+	}
+	#parseComponent(open) {
+		const header = this.#header(() => {
+			const template = this.#parseExpression();
+			let withValue = null;
+			if (this.#isName("with")) {
+				this.#next();
+				withValue = this.#parseExpression();
+			}
+			return {
+				template,
+				with: withValue
+			};
+		}, {
+			template: this.#invalid(),
+			with: null
+		});
+		const body = [];
+		const fills = [];
+		for (;;) {
+			const part = this.#parseBody(["fill", "endcomponent"]);
+			body.push(...part.body);
+			if (!part.end) {
+				this.#unclosed("component", open, "endcomponent");
+				break;
+			}
+			if (part.end.value === "endcomponent") {
+				this.#finishEndTag();
+				break;
+			}
+			const fillStart = this.#tokens[this.#index - 2] ?? part.end;
+			const name = this.#header(() => this.#parseStringLiteral("a slot name"), "");
+			const fill = this.#parseBody(["endfill"]);
+			if (fill.end) this.#finishEndTag();
+			else this.#unclosed("fill", fillStart, "endfill");
+			if (fills.some((existing) => existing.name === name)) this.#problem("duplicate-fill", `Slot "${name}" is filled more than once`, {
+				start: fillStart.start,
+				end: fillStart.end
+			});
+			fills.push({
+				name,
+				body: fill.body,
+				span: {
+					start: fillStart.start,
+					end: this.#lastEnd
+				}
+			});
+		}
+		return this.#placed({
+			type: "Component",
+			...header,
+			fills,
+			body,
+			span: {
+				start: open.start,
+				end: this.#lastEnd
+			}
+		});
+	}
+	#placed(node) {
+		this.placed.push(node);
+		return node;
+	}
+	#parseStringLiteral(what) {
+		const token = this.#peek();
+		if (token.type !== "string") this.#fail(`Expected ${what} as a string but found ${describeToken(token)}`);
+		this.#next();
+		return token.value;
+	}
+	#parseSlot(open) {
+		const name = this.#header(() => this.#peek().type === "tagClose" ? "default" : this.#parseStringLiteral("a slot name"), "default");
+		const { body, end } = this.#parseBody(["endslot"]);
+		if (end) this.#finishEndTag();
+		else this.#unclosed("slot", open, "endslot");
+		return this.#placed({
+			type: "Slot",
+			name,
+			body,
+			span: {
+				start: open.start,
+				end: this.#lastEnd
+			}
+		});
+	}
+	#parseMacro(open) {
+		const header = this.#header(() => {
+			const name = this.#expectDeclarableName("a macro name").value;
+			this.#expectPunct("(");
+			const params = this.#parseParams(")");
+			this.#expectPunct(")");
+			return {
+				name,
+				params
+			};
+		}, {
+			name: "",
+			params: []
+		});
+		const { body, end } = this.#parseBody(["endmacro"]);
+		if (end) this.#finishEndTag(header.name);
+		else this.#unclosed("macro", open, "endmacro");
+		return {
+			type: "Macro",
+			...header,
+			body,
+			span: {
+				start: open.start,
+				end: this.#lastEnd
+			}
+		};
+	}
+	#parseImport(open) {
+		const template = this.#parseStringLiteral("a template name");
+		this.#expectKeyword("as");
+		const alias = this.#expectDeclarableName("an alias").value;
+		const close = this.#expectTagEnd();
+		return {
+			type: "Import",
+			template,
+			alias,
+			span: {
+				start: open.start,
+				end: close.end
+			}
+		};
+	}
+	#parseFromImport(open) {
+		const template = this.#parseStringLiteral("a template name");
+		this.#expectKeyword("import");
+		const names = [];
+		do {
+			if (names.length > 0) this.#next();
+			const nameToken = this.#expectName("a macro name");
+			let alias = nameToken.value;
+			if (this.#isName("as")) {
+				this.#next();
+				alias = this.#expectDeclarableName("an alias").value;
+			}
+			names.push({
+				name: nameToken.value,
+				alias,
+				span: {
+					start: nameToken.start,
+					end: this.#lastEnd
+				}
+			});
+		} while (this.#isPunct(","));
+		const close = this.#expectTagEnd();
+		return {
+			type: "FromImport",
+			template,
+			names,
+			span: {
+				start: open.start,
+				end: close.end
+			}
+		};
+	}
+	#parseWith(open) {
+		const value = this.#header(() => this.#parseExpression(), this.#invalid());
+		const { body, end } = this.#parseBody(["endwith"]);
+		if (end) this.#finishEndTag();
+		else this.#unclosed("with", open, "endwith");
+		return {
+			type: "With",
+			value,
+			body,
+			span: {
+				start: open.start,
+				end: this.#lastEnd
+			}
+		};
+	}
+	#parseAdd(open) {
+		const { outlet, once } = this.#header(() => {
+			this.#expectKeyword("to");
+			const outlet = this.#parseStringLiteral("an outlet name");
+			const once = this.#isName("once");
+			if (once) this.#next();
+			return {
+				outlet,
+				once
+			};
+		}, {
+			outlet: "",
+			once: false
+		});
+		const { body, end } = this.#parseBody(["endadd"]);
+		if (end) this.#finishEndTag();
+		else this.#unclosed("add", open, "endadd");
+		return {
+			type: "Add",
+			outlet,
+			once,
+			body,
+			span: {
+				start: open.start,
+				end: this.#lastEnd
+			}
+		};
+	}
+	#parseCache(open) {
+		const { key, seconds } = this.#header(() => {
+			const key = this.#parseExpression();
+			let seconds = null;
+			if (this.#isName("for")) {
+				this.#next();
+				seconds = this.#parseExpression();
+			}
+			return {
+				key,
+				seconds
+			};
+		}, {
+			key: this.#invalid(),
+			seconds: null
+		});
+		const { body, end } = this.#parseBody(["endcache"]);
+		if (end) this.#finishEndTag();
+		else this.#unclosed("cache", open, "endcache");
+		return {
+			type: "Cache",
+			key,
+			seconds,
+			body,
+			span: {
+				start: open.start,
+				end: this.#lastEnd
+			}
+		};
+	}
+	#parseIsland(open) {
+		const header = this.#header(() => {
+			const template = this.#parseExpression();
+			let withValue = null;
+			if (this.#isName("with")) {
+				this.#next();
+				withValue = this.#parseExpression();
+			}
+			return {
+				template,
+				with: withValue
+			};
+		}, {
+			template: this.#invalid(),
+			with: null
+		});
+		const { body, end } = this.#parseBody(["endisland"]);
+		if (end) this.#finishEndTag();
+		else this.#unclosed("island", open, "endisland");
+		return this.#placed({
+			type: "Island",
+			...header,
+			body,
+			span: {
+				start: open.start,
+				end: this.#lastEnd
+			}
+		});
+	}
+	#parseApply(open) {
+		const filters = this.#header(() => {
+			const list = [];
+			do {
+				if (list.length > 0) this.#next();
+				const nameToken = this.#expectName("a filter name");
+				const args = this.#isPunct("(") ? this.#parseArguments() : [];
+				list.push({
+					name: nameToken.value,
+					args,
+					span: {
+						start: nameToken.start,
+						end: this.#lastEnd
+					}
+				});
+			} while (this.#isPunct("|"));
+			return list;
+		}, []);
+		const { body, end } = this.#parseBody(["endapply"]);
+		if (end) this.#finishEndTag();
+		else this.#unclosed("apply", open, "endapply");
+		return {
+			type: "Apply",
+			filters,
+			body,
+			span: {
+				start: open.start,
+				end: this.#lastEnd
+			}
+		};
+	}
+	#parseAutoescape(open) {
+		const strategy = this.#header(() => {
+			const token = this.#peek();
+			if (token.type === "tagClose") return "html";
+			if (token.type === "name" && token.value === "false") {
+				this.#next();
+				return false;
+			}
+			const value = this.#parseStringLiteral("an escaping strategy");
+			if (!ESCAPE_STRATEGIES.includes(value)) this.#fail(`Unknown escaping strategy "${value}". Use ${ESCAPE_STRATEGIES.map((s) => `"${s}"`).join(", ")} or false`, token, "unknown-strategy");
+			return value;
+		}, "html");
+		const { body, end } = this.#parseBody(["endautoescape"]);
+		if (end) this.#finishEndTag();
+		else this.#unclosed("autoescape", open, "endautoescape");
+		return {
+			type: "Autoescape",
+			strategy,
+			body,
+			span: {
+				start: open.start,
+				end: this.#lastEnd
+			}
+		};
+	}
+	#parseVerbatim(open) {
+		this.#expectTagEnd();
+		let value = "";
+		let start = this.#lastEnd;
+		let end = start;
+		const token = this.#peek();
+		if (token.type === "text") {
+			this.#next();
+			value = token.value;
+			start = token.start;
+			end = token.end;
+		}
+		if (this.#peek().type === "tagOpen" && this.#isName("endverbatim", 1)) {
+			this.#next();
+			this.#next();
+			this.#finishEndTag();
+		}
+		if (value === "") return null;
+		return {
+			type: "Text",
+			value,
+			span: {
+				start: Math.max(start, open.end),
+				end
+			}
+		};
+	}
+	/** Guards against source nested so deeply that parsing it would overflow the call stack. */
+	#enter() {
+		if (++this.#nesting > 200) {
+			this.#nesting--;
+			this.#fail(`Template is nested more than 200 levels deep`, this.#peek(), "too-deep");
+		}
+	}
+	#parseExpression() {
+		this.#enter();
+		try {
+			return this.#parseConditional();
+		} finally {
+			this.#nesting--;
+		}
+	}
+	#parseConditional() {
+		const test = this.#parseCoalesce();
+		if (this.#isPunct("?")) {
+			this.#next();
+			const consequent = this.#parseExpression();
+			let alternate = null;
+			if (this.#isPunct(":")) {
+				this.#next();
+				alternate = this.#parseExpression();
+			}
+			return {
+				type: "Conditional",
+				test,
+				consequent,
+				alternate,
+				span: {
+					start: test.span.start,
+					end: this.#lastEnd
+				}
+			};
+		}
+		if (this.#isPunct("?:")) {
+			this.#next();
+			const right = this.#parseExpression();
+			return this.#binary("?:", test, right);
+		}
+		return test;
+	}
+	#binary(operator, left, right) {
+		return {
+			type: "Binary",
+			operator,
+			left,
+			right,
+			span: {
+				start: left.span.start,
+				end: right.span.end
+			}
+		};
+	}
+	#parseCoalesce() {
+		const left = this.#parseOr();
+		if (!this.#isPunct("??")) return left;
+		this.#next();
+		this.#enter();
+		try {
+			return this.#binary("??", left, this.#parseCoalesce());
+		} finally {
+			this.#nesting--;
+		}
+	}
+	#parseOr() {
+		let left = this.#parseAnd();
+		while (this.#isName("or")) {
+			this.#next();
+			left = this.#binary("or", left, this.#parseAnd());
+		}
+		return left;
+	}
+	#parseAnd() {
+		let left = this.#parseNot();
+		while (this.#isName("and")) {
+			this.#next();
+			left = this.#binary("and", left, this.#parseNot());
+		}
+		return left;
+	}
+	#parseNot() {
+		this.#enter();
+		try {
+			return this.#parseNotInner();
+		} finally {
+			this.#nesting--;
+		}
+	}
+	#parseNotInner() {
+		if (this.#isName("not")) {
+			const token = this.#next();
+			const operand = this.#parseNot();
+			return {
+				type: "Unary",
+				operator: "not",
+				operand,
+				span: {
+					start: token.start,
+					end: operand.span.end
+				}
+			};
+		}
+		return this.#parseComparison();
+	}
+	/** Reads a comparison operator at the cursor without consuming it, and how many tokens it spans. */
+	#comparisonAhead() {
+		const token = this.#peek();
+		if (token.type === "punct" && COMPARISON_PUNCTUATORS.has(token.value)) return {
+			operator: token.value,
+			length: 1
+		};
+		if (token.type !== "name") return null;
+		switch (token.value) {
+			case "in": return {
+				operator: "in",
+				length: 1
+			};
+			case "is": return {
+				operator: "is",
+				length: 1
+			};
+			case "not": return this.#isName("in", 1) ? {
+				operator: "not in",
+				length: 2
+			} : null;
+			case "starts": return this.#isName("with", 1) ? {
+				operator: "starts with",
+				length: 2
+			} : null;
+			case "ends": return this.#isName("with", 1) ? {
+				operator: "ends with",
+				length: 2
+			} : null;
+			default: return null;
+		}
+	}
+	#parseComparison() {
+		const left = this.#parseRange();
+		const ahead = this.#comparisonAhead();
+		if (!ahead) return left;
+		let result;
+		if (ahead.operator === "is") result = this.#parseTest(left);
+		else {
+			for (let i = 0; i < ahead.length; i++) this.#next();
+			result = this.#binary(ahead.operator, left, this.#parseRange());
+		}
+		if (this.#comparisonAhead()) this.#fail("Comparisons cannot be chained. Join them with \"and\" or \"or\"", this.#peek(), "chained-comparison");
+		return result;
+	}
+	#parseTest(input) {
+		this.#next();
+		let negated = false;
+		if (this.#isName("not")) {
+			this.#next();
+			negated = true;
+		}
+		const first = this.#expectName("a test name");
+		let name = first.value;
+		let nameEnd = first.end;
+		const second = this.#peek();
+		if (second.type === "name" && (this.#options.isTest(`${name} ${second.value}`) || !this.#options.isTest(name) && !NOT_TEST_WORDS.has(second.value))) {
+			this.#next();
+			name = `${name} ${second.value}`;
+			nameEnd = second.end;
+		}
+		const args = this.#isPunct("(") ? this.#parseArguments() : [];
+		return {
+			type: "Test",
+			name,
+			nameSpan: {
+				start: first.start,
+				end: nameEnd
+			},
+			input,
+			args,
+			negated,
+			span: {
+				start: input.span.start,
+				end: this.#lastEnd
+			}
+		};
+	}
+	#parseRange() {
+		const left = this.#parseConcat();
+		if (this.#isPunct("..")) {
+			this.#next();
+			return this.#binary("..", left, this.#parseConcat());
+		}
+		return left;
+	}
+	#parseConcat() {
+		let left = this.#parseAdditive();
+		while (this.#isPunct("~")) {
+			this.#next();
+			left = this.#binary("~", left, this.#parseAdditive());
+		}
+		return left;
+	}
+	#parseAdditive() {
+		let left = this.#parseMultiplicative();
+		while (this.#isPunct("+") || this.#isPunct("-")) {
+			const operator = this.#next().value;
+			left = this.#binary(operator, left, this.#parseMultiplicative());
+		}
+		return left;
+	}
+	#parseMultiplicative() {
+		let left = this.#parseUnary();
+		for (;;) {
+			const token = this.#peek();
+			if (token.type === "punct" && (token.value === "*" || token.value === "/" || token.value === "//" || token.value === "%")) {
+				this.#next();
+				left = this.#binary(token.value, left, this.#parseUnary());
+			} else return left;
+		}
+	}
+	#parseUnary() {
+		this.#enter();
+		try {
+			return this.#parseUnaryInner();
+		} finally {
+			this.#nesting--;
+		}
+	}
+	#parseUnaryInner() {
+		if (this.#isPunct("-") || this.#isPunct("+")) {
+			const token = this.#next();
+			const operand = this.#parseUnary();
+			return {
+				type: "Unary",
+				operator: token.value,
+				operand,
+				span: {
+					start: token.start,
+					end: operand.span.end
+				}
+			};
+		}
+		return this.#parsePower();
+	}
+	#parsePower() {
+		const base = this.#parsePostfix();
+		if (this.#isPunct("**")) {
+			this.#next();
+			return this.#binary("**", base, this.#parseUnary());
+		}
+		return base;
+	}
+	#parsePostfix() {
+		let expression = this.#parsePrimary();
+		let optional = false;
+		const start = expression.span.start;
+		const span = () => ({
+			start,
+			end: this.#lastEnd
+		});
+		const closeChain = () => {
+			if (optional) {
+				expression = {
+					type: "OptionalChain",
+					expression,
+					span: span()
+				};
+				optional = false;
+			}
+		};
+		for (;;) {
+			if (this.#isPunct(".") || this.#isPunct("?.")) {
+				const isOptional = this.#next().value === "?.";
+				if (isOptional) optional = true;
+				if (isOptional && this.#isPunct("[")) {
+					this.#next();
+					const property = this.#parseExpression();
+					this.#expectPunct("]");
+					expression = {
+						type: "Member",
+						object: expression,
+						property,
+						optional: true,
+						span: span()
+					};
+					continue;
+				}
+				const token = this.#peek();
+				if (token.type === "name") {
+					this.#next();
+					expression = {
+						type: "Member",
+						object: expression,
+						property: {
+							type: "Literal",
+							value: token.value,
+							span: {
+								start: token.start,
+								end: token.end
+							}
+						},
+						optional: isOptional,
+						span: span()
+					};
+					continue;
+				}
+				if (token.type === "number" && /^\d+$/.test(token.value)) {
+					this.#next();
+					expression = {
+						type: "Member",
+						object: expression,
+						property: {
+							type: "Literal",
+							value: Number(token.value),
+							span: {
+								start: token.start,
+								end: token.end
+							}
+						},
+						optional: isOptional,
+						span: span()
+					};
+					continue;
+				}
+				this.#fail(`Expected a property name but found ${describeToken(token)}`);
+			}
+			if (this.#isPunct("[")) {
+				this.#next();
+				const property = this.#parseExpression();
+				this.#expectPunct("]");
+				expression = {
+					type: "Member",
+					object: expression,
+					property,
+					optional: false,
+					span: span()
+				};
+				continue;
+			}
+			if (this.#isPunct("(")) {
+				const callee = expression;
+				if (callee.type !== "Name" && callee.type !== "Member") this.#fail("Only named functions, macros and exposed methods can be called", this.#peek(), "invalid-call");
+				expression = {
+					type: "Call",
+					callee,
+					args: this.#parseArguments(),
+					span: span()
+				};
+				continue;
+			}
+			if (this.#isPunct("|")) {
+				closeChain();
+				this.#next();
+				const nameToken = this.#expectName("a filter name");
+				const args = this.#isPunct("(") ? this.#parseArguments() : [];
+				expression = {
+					type: "Filter",
+					name: nameToken.value,
+					nameSpan: {
+						start: nameToken.start,
+						end: nameToken.end
+					},
+					input: expression,
+					args,
+					span: span()
+				};
+				continue;
+			}
+			closeChain();
+			return expression;
+		}
+	}
+	#parsePrimary() {
+		const token = this.#peek();
+		const tokenSpan = {
+			start: token.start,
+			end: token.end
+		};
+		switch (token.type) {
+			case "number":
+				this.#next();
+				return {
+					type: "Literal",
+					value: Number(token.value),
+					span: tokenSpan
+				};
+			case "string":
+				this.#next();
+				return {
+					type: "Literal",
+					value: token.value,
+					span: tokenSpan
+				};
+			case "stringStart": return this.#parseInterpolation();
+			case "name":
+				switch (token.value) {
+					case "true":
+					case "false":
+						this.#next();
+						return {
+							type: "Literal",
+							value: token.value === "true",
+							span: tokenSpan
+						};
+					case "null":
+						this.#next();
+						return {
+							type: "Literal",
+							value: null,
+							span: tokenSpan
+						};
+					case "and":
+					case "or":
+					case "not":
+					case "in":
+					case "is": this.#fail(`Expected a value but found "${token.value}"`);
+				}
+				if (this.#isPunct("=>", 1)) this.#fail("Arrow functions can only be passed as arguments to filters, functions and methods", token, "invalid-arrow");
+				this.#next();
+				return {
+					type: "Name",
+					name: token.value,
+					span: tokenSpan
+				};
+			case "punct": switch (token.value) {
+				case "[": return this.#parseArray();
+				case "{": return this.#parseHash();
+				case "(": {
+					if (this.#arrowAhead()) this.#fail("Arrow functions can only be passed as arguments to filters, functions and methods", token, "invalid-arrow");
+					this.#next();
+					const inner = this.#parseExpression();
+					this.#expectPunct(")");
+					return {
+						...inner,
+						span: {
+							start: token.start,
+							end: this.#lastEnd
+						}
+					};
+				}
+			}
+		}
+		return this.#fail(`Expected a value but found ${describeToken(token)}`);
+	}
+	#parseInterpolation() {
+		const start = this.#next();
+		const parts = [];
+		for (;;) {
+			const token = this.#peek();
+			if (token.type === "stringEnd") {
+				this.#next();
+				break;
+			}
+			if (token.type === "string") {
+				this.#next();
+				parts.push({
+					type: "Literal",
+					value: token.value,
+					span: {
+						start: token.start,
+						end: token.end
+					}
+				});
+				continue;
+			}
+			if (token.type === "interpOpen") {
+				this.#next();
+				parts.push(this.#parseExpression());
+				const close = this.#peek();
+				if (close.type !== "interpClose") this.#fail(`Expected "}" but found ${describeToken(close)}`);
+				this.#next();
+				continue;
+			}
+			this.#fail(`Unexpected ${describeToken(token)} in string`);
+		}
+		return {
+			type: "Interpolation",
+			parts,
+			span: {
+				start: start.start,
+				end: this.#lastEnd
+			}
+		};
+	}
+	#parseSpread() {
+		const token = this.#next();
+		const value = this.#parseExpression();
+		return {
+			type: "Spread",
+			value,
+			span: {
+				start: token.start,
+				end: value.span.end
+			}
+		};
+	}
+	#parseArray() {
+		const open = this.#next();
+		const elements = [];
+		while (!this.#isPunct("]")) {
+			elements.push(this.#isPunct("...") ? this.#parseSpread() : this.#parseExpression());
+			if (!this.#isPunct(",")) break;
+			this.#next();
+		}
+		this.#expectPunct("]");
+		return {
+			type: "Array",
+			elements,
+			span: {
+				start: open.start,
+				end: this.#lastEnd
+			}
+		};
+	}
+	#parseHash() {
+		const open = this.#next();
+		const entries = [];
+		while (!this.#isPunct("}")) {
+			if (this.#isPunct("...")) entries.push(this.#parseSpread());
+			else {
+				const token = this.#peek();
+				let key;
+				if (token.type === "name") {
+					this.#next();
+					key = {
+						type: "Literal",
+						value: token.value,
+						span: {
+							start: token.start,
+							end: token.end
+						}
+					};
+					if (!this.#isPunct(":")) {
+						if (RESERVED_NAMES.has(token.value) && token.value !== "loop" && token.value !== "slots") this.#fail(`Expected ":" after "${token.value}"`);
+						entries.push({
+							type: "Property",
+							key,
+							value: {
+								type: "Name",
+								name: token.value,
+								span: {
+									start: token.start,
+									end: token.end
+								}
+							},
+							span: {
+								start: token.start,
+								end: token.end
+							}
+						});
+						if (!this.#isPunct(",")) break;
+						this.#next();
+						continue;
+					}
+				} else if (token.type === "string" || token.type === "number") {
+					this.#next();
+					key = {
+						type: "Literal",
+						value: token.type === "number" ? String(Number(token.value)) : token.value,
+						span: {
+							start: token.start,
+							end: token.end
+						}
+					};
+				} else if (this.#isPunct("(")) {
+					this.#next();
+					key = this.#parseExpression();
+					this.#expectPunct(")");
+				} else this.#fail(`Expected a hash key but found ${describeToken(token)}`);
+				this.#expectPunct(":");
+				const value = this.#parseExpression();
+				entries.push({
+					type: "Property",
+					key,
+					value,
+					span: {
+						start: token.start,
+						end: value.span.end
+					}
+				});
+			}
+			if (!this.#isPunct(",")) break;
+			this.#next();
+		}
+		this.#expectPunct("}");
+		return {
+			type: "Hash",
+			entries,
+			span: {
+				start: open.start,
+				end: this.#lastEnd
+			}
+		};
+	}
+	/** Checks whether the tokens at the cursor start an arrow function such as `(a, b) =>`. */
+	#arrowAhead() {
+		if (this.#peek().type === "name") return this.#isPunct("=>", 1);
+		if (!this.#isPunct("(")) return false;
+		let offset = 1;
+		if (this.#isPunct(")", offset)) return this.#isPunct("=>", offset + 1);
+		for (;;) {
+			if (this.#peek(offset).type !== "name") return false;
+			offset++;
+			if (this.#isPunct(")", offset)) return this.#isPunct("=>", offset + 1);
+			if (!this.#isPunct(",", offset)) return false;
+			offset++;
+		}
+	}
+	#parseArrow() {
+		const start = this.#peek();
+		const params = [];
+		if (start.type === "name") params.push(this.#expectDeclarableName("a parameter name").value);
+		else {
+			this.#next();
+			while (!this.#isPunct(")")) {
+				params.push(this.#expectDeclarableName("a parameter name").value);
+				if (!this.#isPunct(",")) break;
+				this.#next();
+			}
+			this.#expectPunct(")");
+		}
+		this.#expectPunct("=>");
+		const body = this.#parseExpression();
+		return {
+			type: "Arrow",
+			params,
+			body,
+			span: {
+				start: start.start,
+				end: body.span.end
+			}
+		};
+	}
+	#parseArguments() {
+		this.#expectPunct("(");
+		const args = [];
+		let named = false;
+		while (!this.#isPunct(")")) {
+			const token = this.#peek();
+			if (this.#isPunct("...")) {
+				if (named) this.#fail("Positional arguments cannot follow named arguments", this.#peek(), "positional-after-named");
+				args.push(this.#parseSpread());
+			} else if (token.type === "name" && this.#isPunct(":", 1)) {
+				this.#next();
+				this.#next();
+				named = true;
+				const value = this.#arrowAhead() ? this.#parseArrow() : this.#parseExpression();
+				args.push({
+					type: "Named",
+					name: token.value,
+					value,
+					span: {
+						start: token.start,
+						end: value.span.end
+					}
+				});
+			} else {
+				if (named) this.#fail("Positional arguments cannot follow named arguments", token, "positional-after-named");
+				const value = this.#arrowAhead() ? this.#parseArrow() : this.#parseExpression();
+				args.push({
+					type: "Positional",
+					value,
+					span: value.span
+				});
+			}
+			if (!this.#isPunct(",")) break;
+			this.#next();
+		}
+		this.#expectPunct(")");
+		return args;
+	}
+};
+//#endregion
+export { ESCAPE_STRATEGIES as a, DEFAULT_SLOT as i, contentStart as n, scanParts as r, parse as t };
+
+//# sourceMappingURL=parser-BU5dThuk.js.map