@lucidkiln/core 1.0.0 → 1.1.0

package/dist/{source-BQxJGo5Y.js → source-BHcxowQp.js}

@@ -1,3 +1,4 @@
+import { n as contentStart } from "./parser-BU5dThuk.js";
 //#region src/errors.ts
 /** Creates a diagnostic for a span of a source. */
 const createDiagnostic = (source, code, message, span, severity = "error") => ({
@@ -469,13 +470,16 @@ const startCapture = (run, section) => {
 };
 /**
 * Ends a capture that started inside `run`'s. One that added nothing leaves the log around it when it is last there,
-* as it is unless captures overlap, and a cached section's islands join the section around it.
+* as it is unless captures overlap, and a cached section's islands and tags join the section around it.
 */
 const endCapture = (run, capture) => {
 	const outer = capture.outer;
 	if (capture.additions === null && outer.at(-1) === capture) outer.pop();
 	const section = run.capture?.section;
-	if (section && capture.section && capture.section !== section) for (const id of capture.section.deferred) section.deferred.push(id);
+	if (section && capture.section && capture.section !== section) {
+		for (const id of capture.section.deferred) section.deferred.push(id);
+		for (const tag of capture.section.tags) section.tags.add(tag);
+	}
 };
 const NO_BLOCKS = /* @__PURE__ */ new Map();
 /** The imports of a template that imports nothing, shared. */
@@ -519,7 +523,14 @@ var Run = class Run {
 			locale: this.state.locale,
 			timeZone: this.state.timeZone,
 			template: this.template.name,
-			signal: this.state.signal
+			signal: this.state.signal,
+			tagCache: (...tags) => {
+				const section = this.capture?.section;
+				for (const tag of tags) {
+					if (typeof tag !== "string") throw new TypeError("Cache tags must be strings");
+					section?.tags.add(tag);
+				}
+			}
 		};
 		return this.#info;
 	}
@@ -1953,7 +1964,7 @@ const toPlainData = (value, onCycle, { what, charge = () => {}, maxLength = Infi
 	return convert(value, 0);
 };
 const isAsciiLetter = (code) => code >= 65 && code <= 90 || code >= 97 && code <= 122;
-const isSpace$1 = (char) => char === " " || char === "	" || char === "\n" || char === "\r" || char === "\f";
+const isSpace = (char) => char === " " || char === "	" || char === "\n" || char === "\r" || char === "\f";
 /**
 * Finds the `>` that ends a tag, or -1 when the tag never ends. A quote starts a value only straight after `=`, as in
 * HTML, and only when the same quote appears again later, so an unclosed quote can't hide the rest of the text.
@@ -1970,7 +1981,7 @@ const tagEnd = (html, from, lastDouble, lastSingle) => {
 		else if (afterEquals && (char === "\"" && i < lastDouble || char === "'" && i < lastSingle)) {
 			quote = char;
 			afterEquals = false;
-		} else if (!isSpace$1(char)) afterEquals = false;
+		} else if (!isSpace(char)) afterEquals = false;
 	}
 	return -1;
 };
@@ -2308,2670 +2319,6 @@ const builtinTests = {
 	}, ["divisor"])
 };
 //#endregion
-//#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
 //#region src/source.ts
 /**
 * A template's text and resolved name.
@@ -5054,6 +2401,6 @@ var Source = class {
 	}
 };
 //#endregion
-export { silence as $, ownerOf as $t, addSlotFlags as A, atFront as At, fail as B, checkLate as Bt, scanHtml as C, truthy as Ct, getAttr as D, BLOCKED_NAMES as Dt, toTime as E, valueLabel as Et, consumeAt as F, passesFrom as Ft, indentedText as G, Run as Gt, holdData as H, recordAddition as Ht, embed as I, runAhead as It, locate as J, endCapture as Jt, isPromise as K, blockScope as Kt, embedKeyed as L, runSequence as Lt, all as M, isRoot as Mt, checkLength as N, mayRunAhead as Nt, getMethod as O, expose as Ot, consume as P, passesAhead as Pt, renderTemplate as Q, lookup$1 as Qt, embedScope as R, OUTLET_INDENT as Rt, readProperty as S, toStringArgument as St, toPlainData as T, unwrap as Tt, importsFor as U, takeOutput as Ut, hold as V, closeOutlets as Vt, indentText as W, RenderState as Wt, markCaller as X, startCapture as Xt, locating as Y, fillScope as Yt, passData as Z, childScope as Zt, integerArgument as _, matchesType as _t, ESCAPE_STRATEGIES as a, isSafe as an, FORMATTERS as at, mapContents as b, toNumber as bt, contains as c, escapeUrl as cn, describeType as ct, Kept as d, resolveTemplateName as dn, hashKeys as dt, sectionCopy as en, startPlace as et, checkDepth as f, KilnIssue as fn, isEmpty as ft, insertedPiece as g, issue as gn, mapKeys as gt, functionArgument as h, createDiagnostic as hn, literalOptions as ht, DEFAULT_SLOT as i, Markup as in, write as it, after as j, contentSets as jt, readableNames as k, lookup as kt, operatorFunction as l, escapeWith as ln, describeValue as lt, fromPieces as m, KilnSyntaxError as mn, isPlainObject as mt, parse as n, variableNames as nn, unhold as nt, builtinFunctions as o, safe as on, MISSING as ot, entriesOf as p, KilnRenderError as pn, isHashLike as pt, loadTemplate as q, emptyOut as qt, scanParts as r, suggest as rn, withCaller as rt, builtinTests as s, escapeHtml as sn, compare as st, Source as t, sectionScope as tn, step as tt, rangeOperator as u, TEMPLATE_EXTENSION as un, equals as ut, isHtmlStrategy as v, setOwn as vt, toPieces as w, typeName as wt, markupText as x, toStr as xt, listOf as y, templateFunctions as yt, endPlace as z, additionsIn as zt };
+export { withCaller as $, suggest as $t, consume as A, passesAhead as At, indentText as B, RenderState as Bt, getAttr as C, BLOCKED_NAMES as Ct, after as D, contentSets as Dt, addSlotFlags as E, atFront as Et, endPlace as F, additionsIn as Ft, locating as G, fillScope as Gt, isPromise as H, blockScope as Ht, fail as I, checkLate as It, renderTemplate as J, lookup$1 as Jt, markCaller as K, startCapture as Kt, hold as L, closeOutlets as Lt, embed as M, runAhead as Mt, embedKeyed as N, runSequence as Nt, all as O, isRoot as Ot, embedScope as P, OUTLET_INDENT as Pt, unhold as Q, variableNames as Qt, holdData as R, recordAddition as Rt, toTime as S, valueLabel as St, readableNames as T, lookup as Tt, loadTemplate as U, emptyOut as Ut, indentedText as V, Run as Vt, locate as W, endCapture as Wt, startPlace as X, sectionCopy as Xt, silence as Y, ownerOf as Yt, step as Z, sectionScope as Zt, markupText as _, toStr as _t, operatorFunction as a, escapeWith as an, describeValue as at, toPieces as b, typeName as bt, checkDepth as c, KilnIssue as cn, isEmpty as ct, functionArgument as d, createDiagnostic as dn, literalOptions as dt, Markup as en, write as et, insertedPiece as f, issue as fn, mapKeys as ft, mapContents as g, toNumber as gt, listOf as h, templateFunctions as ht, contains as i, escapeUrl as in, describeType as it, consumeAt as j, passesFrom as jt, checkLength as k, mayRunAhead as kt, entriesOf as l, KilnRenderError as ln, isHashLike as lt, isHtmlStrategy as m, setOwn as mt, builtinFunctions as n, safe as nn, MISSING as nt, rangeOperator as o, TEMPLATE_EXTENSION as on, equals as ot, integerArgument as p, matchesType as pt, passData as q, childScope as qt, builtinTests as r, escapeHtml as rn, compare as rt, Kept as s, resolveTemplateName as sn, hashKeys as st, Source as t, isSafe as tn, FORMATTERS as tt, fromPieces as u, KilnSyntaxError as un, isPlainObject as ut, readProperty as v, toStringArgument as vt, getMethod as w, expose as wt, toPlainData as x, unwrap as xt, scanHtml as y, truthy as yt, importsFor as z, takeOutput as zt };
 
-//# sourceMappingURL=source-BQxJGo5Y.js.map
+//# sourceMappingURL=source-BHcxowQp.js.map