@lucidkiln/core 1.0.0 → 1.2.0

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

@@ -1,3 +1,4 @@
+import { n as contentStart } from "./parser-isboTef0.js";
 //#region src/errors.ts
 /** Creates a diagnostic for a span of a source. */
 const createDiagnostic = (source, code, message, span, severity = "error") => ({
@@ -372,8 +373,6 @@ const variableNames = (scope) => {
 /** An empty output buffer. Captures start with one too, since what they capture is printed as a value. */
 const emptyOut = () => ({
 	s: "",
-	indent: "",
-	inline: false,
 	ahead: null
 });
 /** The scope a block's body renders in: its own when it may set variables. */
@@ -469,13 +468,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,22 +521,20 @@ 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;
 	}
 };
 //#endregion
 //#region src/runtime/outlets.ts
-/**
-* Stands for the outlet's indentation in added content, which is rendered before the outlet may be reached. The
-* outlet puts its own indentation in place when it closes, so content lines up the same whichever runs first, and a
-* cached section's additions line up wherever they are replayed. Two Unicode noncharacters, meant for uses like
-* this. Indentation can land mid-line, where a tag's line ending was removed, so the marker is replaced wherever it
-* is. Data holding one of the characters on its own is left alone.
-*/
-const OUTLET_INDENT = "﷐﷑";
-const INDENT_MARKERS = /\uFDD0\uFDD1/g;
 /** The additions in a log, in order, with each capture's in its place. See `Capture`. */
 const additionsIn = (log, into = []) => {
 	for (const entry of log) if (entry instanceof Capture) {
@@ -596,10 +596,10 @@ const closedError = (run, span, outlet) => fail(run, span, "outlet-closed", `Out
 /** Closes every outlet reached so far, fixing its content. */
 const closeOutlets = (state) => {
 	if (state.outlets === null) return;
-	for (const [name, mark] of state.outlets) if (mark.content === null) mark.content = contentFor(state, name, mark);
+	for (const [name, mark] of state.outlets) if (mark.content === null) mark.content = contentFor(state, name);
 };
 /** An outlet's content: what was added to it, in order, without repeats of `once` tags. */
-const contentFor = (state, name, mark) => {
+const contentFor = (state, name) => {
 	const seen = /* @__PURE__ */ new Set();
 	let content = "";
 	for (const addition of additionsIn(state.additions ?? [])) {
@@ -608,8 +608,7 @@ const contentFor = (state, name, mark) => {
 			if (seen.has(addition.once)) continue;
 			seen.add(addition.once);
 		}
-		const html = content === "" && mark.inline && addition.html.startsWith("﷐﷑") ? addition.html.slice(2) : addition.html;
-		content += html.replace(INDENT_MARKERS, mark.indent);
+		content += addition.html;
 	}
 	return content;
 };
@@ -648,20 +647,14 @@ const takeOutput = (state, output) => {
 	return text;
 };
 const NOTHING = () => {};
+/** Whether parts may start early ahead of a part that waits: the render runs fewer parts ahead than it may. */
+const mayRunAhead = (state) => state.ahead < 64;
 /**
-* Whether parts may start early ahead of a part that waits: the render runs fewer parts ahead than it may, and the
-* part didn't start where content was inserted mid-line with nothing written since. `inline` is `out.inline` from
-* before the part started. If it was set, whether the line the part started goes on depends on what the part writes,
-* and so does the indentation of what comes after it. Check before starting anything that waits for the part.
-*/
-const mayRunAhead = (state, inline) => state.ahead < 64 && !inline;
-/**
-* Starts `rest` while `pending`, the promise of the part before it, waits, and returns a promise for both. `indent` is
-* the indentation `out` had before the part started, which `rest` writes at. Rejects with the part's error when it
-* fails, or else with the rest's, after both settle, so a failed render has nothing still running. Only call it when
-* `mayRunAhead` allows.
+* Starts `rest` while `pending`, the promise of the part before it, waits, and returns a promise for both. Rejects with
+* the part's error when it fails, or else with the rest's, after both settle, so a failed render has nothing still
+* running. Only call it when `mayRunAhead` allows.
 */
-const runAhead = (run, out, pending, indent, rest, span) => {
+const runAhead = (run, out, pending, rest, span) => {
 	const state = run.state;
 	state.ahead++;
 	const log = additionLog(run);
@@ -672,8 +665,6 @@ const runAhead = (run, out, pending, indent, rest, span) => {
 	});
 	const ahead = {
 		s: "",
-		indent,
-		inline: false,
 		ahead: out.ahead ?? {
 			base: out,
 			size: 0
@@ -748,17 +739,15 @@ const runGated = (sequence, index, gate, run, scope, out) => {
 */
 const runSequence = (sequence, index, last, run, scope, out, gate) => {
 	const statements = sequence.statements;
-	const indent = out.indent;
 	for (let i = index; i <= last; i++) {
-		const inline = out.inline;
 		const result = gate === null ? statements[i](run, scope, out) : runGated(sequence, i, gate, run, scope, out);
 		if (result === void 0) continue;
 		const plan = sequence.plan(run, gate !== null);
 		const after = Math.min(plan.after[i], last);
 		const end = Math.min(plan.reach[i], last);
-		if (end > after && mayRunAhead(run.state, inline)) {
+		if (end > after && mayRunAhead(run.state)) {
 			const pending = after > i ? result.then(() => runSequence(sequence, i + 1, after, run, scope, out, gate)) : result;
-			const joined = runAhead(run, out, pending, indent, (ahead, aheadOut) => runSequence(sequence, after + 1, end, ahead, scope, aheadOut, gate), plan.spans[i]);
+			const joined = runAhead(run, out, pending, (ahead, aheadOut) => runSequence(sequence, after + 1, end, ahead, scope, aheadOut, gate), plan.spans[i]);
 			return end === last ? joined : joined.then(() => runSequence(sequence, end + 1, last, run, scope, out, gate));
 		}
 		return result.then(() => runSequence(sequence, i + 1, last, run, scope, out, gate));
@@ -768,24 +757,22 @@ const runSequence = (sequence, index, last, run, scope, out, gate) => {
 * Runs passes `from` to `to` of a loop in order, waiting only when one returns a promise. Then the passes after it
 * continue as `passesFrom` runs them. `ahead` is whether the loop's passes may run ahead of each other.
 */
-const runPasses = (run, out, from, to, indent, pass, span, ahead) => {
+const runPasses = (run, out, from, to, pass, span, ahead) => {
 	for (let index = from; index < to; index++) {
-		const inline = out.inline;
 		const result = pass(run, out, index);
 		if (result === void 0) continue;
-		return index + 1 < to ? passesFrom(run, out, result, inline, index + 1, to, indent, pass, span, ahead) : result;
+		return index + 1 < to ? passesFrom(run, out, result, index + 1, to, pass, span, ahead) : result;
 	}
 };
 /**
-* Runs passes `from` to `to` of a loop, which come after `pending`, a pass that waits, and started with `out.inline`
-* as `inline`. When `ahead`, they start at once: each pass that waits lets the passes after it start in a buffer and
-* capture of their own, and every buffer joins `out` in order once all the passes are done. Otherwise, or when
-* `mayRunAhead` refuses, they run once the pass is done. Rejects with the first error in the loop's order, once every
-* pass started is done.
+* Runs passes `from` to `to` of a loop, which come after `pending`, a pass that waits. When `ahead`, they start at
+* once: each pass that waits lets the passes after it start in a buffer and capture of their own, and every buffer
+* joins `out` in order once all the passes are done. Otherwise, or when `mayRunAhead` refuses, they run once the pass
+* is done. Rejects with the first error in the loop's order, once every pass started is done.
 */
-const passesFrom = (run, out, pending, inline, from, to, indent, pass, span, ahead) => {
+const passesFrom = (run, out, pending, from, to, pass, span, ahead) => {
 	const state = run.state;
-	if (!ahead || !mayRunAhead(state, inline)) return pending.then(() => runPasses(run, out, from, to, indent, pass, span, ahead));
+	if (!ahead || !mayRunAhead(state)) return pending.then(() => runPasses(run, out, from, to, pass, span, ahead));
 	const log = additionLog(run);
 	const outer = run.capture;
 	const section = outer?.section ?? null;
@@ -851,8 +838,6 @@ const passesFrom = (run, out, pending, inline, from, to, indent, pass, span, ahe
 		const capture = new Capture(log, section, behind);
 		const segment = {
 			s: "",
-			indent,
-			inline: false,
 			ahead: group
 		};
 		const segmentRun = run.within(capture);
@@ -874,7 +859,7 @@ const passesFrom = (run, out, pending, inline, from, to, indent, pass, span, ahe
 		if (waiting === void 0) break;
 		if (index < to && state.ahead >= 64) {
 			const next = index;
-			waiting = waiting.then(() => runPasses(segmentRun, segment, next, to, indent, pass, span, true));
+			waiting = waiting.then(() => runPasses(segmentRun, segment, next, to, pass, span, true));
 			index = to;
 		}
 		watch(waiting, at);
@@ -1286,55 +1271,10 @@ const checkLength = (run, text) => {
 */
 const write = (run, out, text, span) => {
 	out.s += text;
-	if (out.inline && text !== "") out.inline = false;
 	const state = run.state;
 	const ahead = out.ahead;
 	if (out.s.length > state.maxSize || ahead !== null && (ahead.size += text.length) + ahead.base.s.length > state.maxSize) throw fail(run, span, "limit-output", `Render stopped after ${state.maxSize} characters of output`);
 };
-/**
-* Starts inserting content for an include, component, slot or block. `at` is the tag's `indent` when it stands on a
-* line of its own, which the content's lines get on top of the current indentation. Without it, the tag shares its
-* line, so the content's first line carries on from it. Tags at the start of a line, with `indent` empty, need
-* nothing.
-*
-* Callers keep `out.indent` and `out.inline` from before, and pass them to `endPlace` with the render's result. A
-* render that throws stops, so nothing needs restoring then.
-*/
-const startPlace = (out, at) => {
-	if (at === void 0) out.inline = true;
-	else out.indent += at;
-};
-/** Ends `startPlace` once `result` settles. */
-const endPlace = (out, indent, inline, result) => {
-	if (result instanceof Promise) return result.then(() => endPlace(out, indent, inline, void 0));
-	out.indent = indent;
-	if (out.inline) out.inline = inline;
-};
-const indentedText = (text, lines) => ({
-	text,
-	lines,
-	indent: "",
-	indented: text
-});
-/**
-* The text with `indent` at the start of each line. `inline` is set when it is the first thing written since content
-* was inserted mid-line, so a line starting straight away gets no indentation. Remembers the last result, since text
-* is usually inserted at the same indentation each time.
-*/
-const indentText = (entry, indent, inline) => {
-	if (entry.indent !== indent) {
-		const { text, lines } = entry;
-		let result = "";
-		let at = 0;
-		for (const start of lines) {
-			result += text.slice(at, start) + indent;
-			at = start;
-		}
-		entry.indented = result + text.slice(at);
-		entry.indent = indent;
-	}
-	return inline && entry.lines[0] === 0 ? entry.indented.slice(indent.length) : entry.indented;
-};
 /** Records the caller's location on a render error that passes through an include, component or `extends`. */
 const markCaller = (run, span, error) => {
 	if (error instanceof KilnRenderError) {
@@ -1590,16 +1530,15 @@ const renderBody = (run, scope, out, imports, block, gate) => {
 	const { template, state } = run;
 	const parent = template.parent;
 	if (!parent && block !== void 0) return renderOnlyBlock(run, scope, out, block);
-	const { indent, inline } = out;
 	const top = template.top;
 	const result = gate === null || top === null ? template.body(run, scope, out) : runSequence(top, 0, top.statements.length - 1, run, scope, out, gate);
 	if (!parent) return result;
 	const span = template.parentSpan;
-	if (result !== void 0 && !parent.async && block === void 0 && mayRunAhead(state, inline)) {
+	if (result !== void 0 && !parent.async && block === void 0 && mayRunAhead(state)) {
 		const effects = template.early?.() ?? null;
 		if (effects !== null) {
 			const next = gateFor(result, effects, gate);
-			return runAhead(run, out, result, indent, (ahead, aheadOut) => after(loadTemplate(ahead, parent.ev(ahead, scope), span), (layout) => withCaller(ahead, span, () => renderTemplate(state, layout, scope, aheadOut, run.depth + 1, run.slots, null, run.blocks, ahead, span, void 0, next))), span);
+			return runAhead(run, out, result, (ahead, aheadOut) => after(loadTemplate(ahead, parent.ev(ahead, scope), span), (layout) => withCaller(ahead, span, () => renderTemplate(state, layout, scope, aheadOut, run.depth + 1, run.slots, null, run.blocks, ahead, span, void 0, next))), span);
 		}
 	}
 	if (result === void 0 && !parent.async) {
@@ -1953,7 +1892,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 +1909,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 +2247,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 +2329,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 { compare as $, escapeUrl as $t, consume as A, additionsIn as At, loadTemplate as B, fillScope as Bt, getAttr as C, contentSets as Ct, after as D, passesFrom as Dt, addSlotFlags as E, passesAhead as Et, fail as F, RenderState as Ft, renderTemplate as G, sectionCopy as Gt, locating as H, childScope as Ht, hold as I, Run as It, unhold as J, suggest as Jt, silence as K, sectionScope as Kt, holdData as L, blockScope as Lt, embed as M, closeOutlets as Mt, embedKeyed as N, recordAddition as Nt, all as O, runAhead as Ot, embedScope as P, takeOutput as Pt, MISSING as Q, escapeHtml as Qt, importsFor as R, emptyOut as Rt, toTime as S, atFront as St, readableNames as T, mayRunAhead as Tt, markCaller as U, lookup$1 as Ut, locate as V, startCapture as Vt, passData as W, ownerOf as Wt, write as X, isSafe as Xt, withCaller as Y, Markup as Yt, FORMATTERS as Z, safe as Zt, markupText as _, unwrap as _t, operatorFunction as a, KilnSyntaxError as an, isHashLike as at, toPieces as b, expose as bt, checkDepth as c, mapKeys as ct, functionArgument as d, templateFunctions as dt, escapeWith as en, describeType as et, insertedPiece as f, toNumber as ft, mapContents as g, typeName as gt, listOf as h, truthy as ht, contains as i, KilnRenderError as in, isEmpty as it, consumeAt as j, checkLate as jt, checkLength as k, runSequence as kt, entriesOf as l, matchesType as lt, isHtmlStrategy as m, toStringArgument as mt, builtinFunctions as n, resolveTemplateName as nn, equals as nt, rangeOperator as o, createDiagnostic as on, isPlainObject as ot, integerArgument as p, toStr as pt, step as q, variableNames as qt, builtinTests as r, KilnIssue as rn, hashKeys as rt, Kept as s, issue as sn, literalOptions as st, Source as t, TEMPLATE_EXTENSION as tn, describeValue as tt, fromPieces as u, setOwn as ut, readProperty as v, valueLabel as vt, getMethod as w, isRoot as wt, toPlainData as x, lookup as xt, scanHtml as y, BLOCKED_NAMES as yt, isPromise as z, endCapture as zt };
 
-//# sourceMappingURL=source-BQxJGo5Y.js.map
+//# sourceMappingURL=source-BbikGqIb.js.map