@lucidkiln/core 1.0.0 → 1.2.0

package/dist/index.js

@@ -1,4 +1,5 @@
-import { $ as silence, $t as ownerOf, A as addSlotFlags, At as atFront, B as fail, Bt as checkLate, C as scanHtml, Ct as truthy, D as getAttr, Dt as BLOCKED_NAMES, E as toTime, Et as valueLabel, F as consumeAt, Ft as passesFrom, G as indentedText, Gt as Run, H as holdData, Ht as recordAddition, I as embed, It as runAhead, J as locate, Jt as endCapture, K as isPromise, Kt as blockScope, L as embedKeyed, Lt as runSequence, M as all, Mt as isRoot, N as checkLength, Nt as mayRunAhead, O as getMethod, Ot as expose, P as consume, Pt as passesAhead, Q as renderTemplate, Qt as lookup$1, R as embedScope, Rt as OUTLET_INDENT, S as readProperty, St as toStringArgument, T as toPlainData, Tt as unwrap, U as importsFor, Ut as takeOutput, V as hold, Vt as closeOutlets, W as indentText, Wt as RenderState, X as markCaller, Xt as startCapture, Y as locating, Yt as fillScope, Z as passData, Zt as childScope, _ as integerArgument, _t as matchesType, a as ESCAPE_STRATEGIES, an as isSafe, at as FORMATTERS, b as mapContents, bt as toNumber, c as contains, cn as escapeUrl, ct as describeType, d as Kept, dn as resolveTemplateName, dt as hashKeys, en as sectionCopy, et as startPlace, f as checkDepth, fn as KilnIssue, ft as isEmpty, g as insertedPiece, gn as issue, gt as mapKeys, h as functionArgument, hn as createDiagnostic, ht as literalOptions, i as DEFAULT_SLOT, in as Markup, it as write, j as after, jt as contentSets, k as readableNames, kt as lookup, l as operatorFunction, ln as escapeWith, lt as describeValue, m as fromPieces, mn as KilnSyntaxError, mt as isPlainObject, n as parse, nn as variableNames, nt as unhold, o as builtinFunctions, on as safe, ot as MISSING, p as entriesOf, pn as KilnRenderError, pt as isHashLike, q as loadTemplate, qt as emptyOut, r as scanParts, rn as suggest, rt as withCaller, s as builtinTests, sn as escapeHtml, st as compare, t as Source, tn as sectionScope, tt as step, u as rangeOperator, un as TEMPLATE_EXTENSION, ut as equals, v as isHtmlStrategy, vt as setOwn, w as toPieces, wt as typeName, x as markupText, xt as toStr, y as listOf$1, yt as templateFunctions, z as endPlace, zt as additionsIn } from "./source-BQxJGo5Y.js";
+import { $ as compare, $t as escapeUrl, A as consume, At as additionsIn, B as loadTemplate, Bt as fillScope, C as getAttr, Ct as contentSets, D as after, Dt as passesFrom, E as addSlotFlags, Et as passesAhead, F as fail, Ft as RenderState, G as renderTemplate, Gt as sectionCopy, H as locating, Ht as childScope, I as hold, It as Run, J as unhold, Jt as suggest, K as silence, Kt as sectionScope, L as holdData, Lt as blockScope, M as embed, Mt as closeOutlets, N as embedKeyed, Nt as recordAddition, O as all, Ot as runAhead, P as embedScope, Pt as takeOutput, Q as MISSING, Qt as escapeHtml, R as importsFor, Rt as emptyOut, S as toTime, St as atFront, T as readableNames, Tt as mayRunAhead, U as markCaller, Ut as lookup$1, V as locate, Vt as startCapture, W as passData, Wt as ownerOf, X as write, Xt as isSafe, Y as withCaller, Yt as Markup, Z as FORMATTERS, Zt as safe, _ as markupText, _t as unwrap, a as operatorFunction, an as KilnSyntaxError, at as isHashLike, b as toPieces, bt as expose, c as checkDepth, ct as mapKeys, d as functionArgument, dt as templateFunctions, en as escapeWith, et as describeType, f as insertedPiece, ft as toNumber, g as mapContents, gt as typeName, h as listOf$1, ht as truthy, i as contains, in as KilnRenderError, it as isEmpty, j as consumeAt, jt as checkLate, k as checkLength, kt as runSequence, l as entriesOf, lt as matchesType, m as isHtmlStrategy, mt as toStringArgument, n as builtinFunctions, nn as resolveTemplateName, nt as equals, o as rangeOperator, on as createDiagnostic, ot as isPlainObject, p as integerArgument, pt as toStr, q as step, qt as variableNames, r as builtinTests, rn as KilnIssue, rt as hashKeys, s as Kept, sn as issue, st as literalOptions, t as Source, tn as TEMPLATE_EXTENSION, tt as describeValue, u as fromPieces, ut as setOwn, v as readProperty, vt as valueLabel, w as getMethod, wt as isRoot, x as toPlainData, xt as lookup, y as scanHtml, yt as BLOCKED_NAMES, z as isPromise, zt as endCapture } from "./source-BbikGqIb.js";
+import { a as ESCAPE_STRATEGIES, i as DEFAULT_SLOT, r as scanParts, t as parse } from "./parser-isboTef0.js";
 //#region src/analyzer.ts
 const MAX_DEPTH$1 = 1e3;
 /** The statement lists nested inside a statement. */
@@ -1565,9 +1566,9 @@ const checkReferences = async (env, template) => {
 };
 //#endregion
 //#region src/runtime/cache.ts
-const VERSION = 2;
+const VERSION = 3;
 /** Makes the value a store saves. */
-const packSaved = ({ html, additions, islands, islandScript }) => JSON.stringify({
+const packSaved = ({ html, additions, islands, islandScript, tags }) => JSON.stringify({
 	v: VERSION,
 	html,
 	add: additions.map((addition) => [
@@ -1576,7 +1577,8 @@ const packSaved = ({ html, additions, islands, islandScript }) => JSON.stringify
 		addition.once
 	]),
 	isl: islands.map((island) => [island.template, island.props]),
-	scr: islandScript
+	scr: islandScript,
+	tag: tags
 });
 /** Reads a value a store returned, or returns null when it isn't one `packSaved` made. */
 const unpackSaved = (value) => {
@@ -1587,8 +1589,8 @@ const unpackSaved = (value) => {
 		return null;
 	}
 	if (typeof parsed !== "object" || parsed === null) return null;
-	const { v, html, add, isl, scr } = parsed;
-	if (v !== VERSION || typeof html !== "string" || !Array.isArray(add) || !Array.isArray(isl) || typeof scr !== "boolean") return null;
+	const { v, html, add, isl, scr, tag } = parsed;
+	if (v !== VERSION || typeof html !== "string" || !Array.isArray(add) || !Array.isArray(isl) || typeof scr !== "boolean" || !Array.isArray(tag) || tag.some((item) => typeof item !== "string")) return null;
 	const additions = [];
 	for (const item of add) {
 		if (!Array.isArray(item)) return null;
@@ -1614,7 +1616,8 @@ const unpackSaved = (value) => {
 		html,
 		additions,
 		islands,
-		islandScript: scr
+		islandScript: scr,
+		tags: tag
 	};
 };
 //#endregion
@@ -2094,18 +2097,14 @@ const printParts = (list) => {
 	const parts = [];
 	for (const part of list) {
 		const last = parts.at(-1);
-		if (part.text !== null && last && last.text !== null) {
-			const offset = last.text.length;
-			const lines = part.lines ? [...last.lines ?? [], ...part.lines.map((start) => start + offset)] : last.lines;
-			parts[parts.length - 1] = {
-				text: last.text + part.text,
-				lines,
-				span: {
-					start: last.span.start,
-					end: part.span.end
-				}
-			};
-		} else parts.push(part);
+		if (part.text !== null && last && last.text !== null) parts[parts.length - 1] = {
+			text: last.text + part.text,
+			span: {
+				start: last.span.start,
+				end: part.span.end
+			}
+		};
+		else parts.push(part);
 	}
 	const first = parts[0];
 	const span = {
@@ -2114,18 +2113,12 @@ const printParts = (list) => {
 	};
 	if (parts.length === 1 && first.text !== null) {
 		const text = first.text;
-		if (!first.lines) return (run, _scope, out) => {
-			write(run, out, text, span);
-		};
-		const entry = indentedText(text, first.lines);
 		return (run, _scope, out) => {
-			const indent = out.indent;
-			write(run, out, indent === "" ? text : indentText(entry, indent, out.inline), span);
+			write(run, out, text, span);
 		};
 	}
 	const count = parts.length;
 	const texts = [];
-	const indented = [];
 	const reads = [];
 	const evs = [];
 	const emits = [];
@@ -2143,7 +2136,6 @@ const printParts = (list) => {
 		const root = compiled?.variable ?? path?.root.variable ?? null;
 		const choice = compiled?.choice ? emitChoice(compiled.choice, emit) : null;
 		texts.push(part.text);
-		indented.push(part.text !== null && part.lines ? indentedText(part.text, part.lines) : null);
 		reads.push(root !== null ? "path" : choice ? "choice" : "other");
 		evs.push(compiled?.ev ?? null);
 		emits.push(emit);
@@ -2155,13 +2147,11 @@ const printParts = (list) => {
 		spans.push(part.span);
 	}
 	return (run, scope, out) => {
-		const indent = out.indent;
 		let text = "";
 		for (let i = 0; i < count; i++) {
 			const part = texts[i];
 			if (part !== null) {
-				const entry = indented[i];
-				text += indent === "" || !entry ? part : entry.indent === indent && !out.inline ? entry.indented : indentText(entry, indent, text === "" && out.inline);
+				text += part;
 				continue;
 			}
 			const at = spans[i];
@@ -2645,7 +2635,6 @@ var Compiler = class {
 				if (parts.length === 0) partsStart = i;
 				parts.push({
 					text: statement.value,
-					lines: statement.lines,
 					span: statement.span
 				});
 				continue;
@@ -2777,15 +2766,13 @@ var Compiler = class {
 		const env = this.#env;
 		/**
 		* Runs passes `index` to `end`. When a pass waits, the passes after it run as `passesFrom` runs them: ahead of
-		* it when they may. `ahead` is whether they may, found the first time a pass waits, and `indent` is the
-		* output's indentation when the loop started.
+		* it when they may. `ahead` is whether they may, found the first time a pass waits.
 		*/
-		const iterate = (run, scope, out, values, keys, index, end, reused, indent, ahead) => {
+		const iterate = (run, scope, out, values, keys, index, end, reused, ahead) => {
 			const length = values.length;
 			for (let i = index; i < end; i++) {
 				step(run, span);
 				const inner = reused ?? childScope(scope);
-				const inline = out.inline;
 				inner[valueName] = values[i] ?? null;
 				if (keyName !== null) inner[keyName] = keys ? keys[i] ?? null : i;
 				if (usesLoop) inner.loop = {
@@ -2808,14 +2795,14 @@ var Compiler = class {
 					};
 				}
 				const may = ahead ??= passesAhead(run, scope, effects.sets, effects.elsewhere);
-				return passesFrom(run, out, result, inline, i + 1, end, indent, (aheadRun, aheadOut, at) => iterate(aheadRun, scope, aheadOut, values, keys, at, at + 1, shared ? childScope(scope) : null, indent, may), span, may);
+				return passesFrom(run, out, result, i + 1, end, (aheadRun, aheadOut, at) => iterate(aheadRun, scope, aheadOut, values, keys, at, at + 1, shared ? childScope(scope) : null, may), span, may);
 			}
 		};
 		const start = (run, scope, out, value) => {
 			const { values, keys } = loopItems(run, span, value, keyName !== null);
 			if (values.length === 0) return alternate?.(run, scope, out);
 			const reused = shared ? childScope(scope) : null;
-			return iterate(run, scope, out, values, keys, 0, values.length, reused, out.indent, null);
+			return iterate(run, scope, out, values, keys, 0, values.length, reused, null);
 		};
 		const ev = iterable.ev;
 		if (!iterable.async) return (run, scope, out) => {
@@ -2942,31 +2929,20 @@ var Compiler = class {
 	}
 	#blockStatement(node) {
 		this.#defineBlock(node);
-		const { name, span, indent } = node;
+		const { name, span } = node;
 		return (run, scope, out) => {
 			const entry = run.blocks.get(name)?.[0];
 			if (!entry) return;
 			const render = () => entry.def.body(entry.run.within(run.capture, run.blockDepth), blockScope(entry.def, scope), out);
-			const own = entry.run.template === run.template;
-			if (indent === "") return own ? render() : withCaller(run, span, render);
-			const saved = out.indent;
-			const inline = out.inline;
-			startPlace(out, indent);
-			return endPlace(out, saved, inline, own ? render() : withCaller(run, span, render));
+			return entry.run.template === run.template ? render() : withCaller(run, span, render);
 		};
 	}
 	#include(node) {
-		const { ignoreMissing, span, indent } = node;
-		return this.#embedding(node.template, node.with, span, (run, out, name, variables) => {
-			if (indent === "") return embed(run, out, span, name, variables, null, ignoreMissing);
-			const saved = out.indent;
-			const inline = out.inline;
-			startPlace(out, indent);
-			return endPlace(out, saved, inline, embed(run, out, span, name, variables, null, ignoreMissing));
-		});
+		const { ignoreMissing, span } = node;
+		return this.#embedding(node.template, node.with, span, (run, out, name, variables) => embed(run, out, span, name, variables, null, ignoreMissing));
 	}
 	#component(node) {
-		const { span, indent } = node;
+		const { span } = node;
 		const fills = node.fills.map((fill) => ({
 			name: fill.name,
 			body: this.#body(fill.body),
@@ -2988,11 +2964,7 @@ var Compiler = class {
 				scope: callerScope,
 				sets: fill.sets
 			});
-			if (indent === "") return embed(run, out, span, name, variables, slots, false);
-			const saved = out.indent;
-			const inline = out.inline;
-			startPlace(out, indent);
-			return endPlace(out, saved, inline, embed(run, out, span, name, variables, slots, false));
+			return embed(run, out, span, name, variables, slots, false);
 		});
 	}
 	/**
@@ -3010,11 +2982,10 @@ var Compiler = class {
 				opening = ISLAND_SCRIPT + opening;
 				if (isRoot(state, out)) state.islandScript = true;
 			}
-			const lead = (at) => (out.inline ? "" : out.indent) + at;
-			write(run, out, indent === void 0 ? opening : `${lead(indent)}${opening}${closing?.indent === null ? "" : "\n"}`, span);
+			write(run, out, indent === void 0 ? opening : `${indent}${opening}${closing?.indent === null ? "" : "\n"}`, span);
 			return after(fallback(run, childScope(scope), out), () => {
 				if (!closing) return write(run, out, ISLAND_CLOSING, span);
-				const start = closing.indent === null ? "" : lead(closing.indent);
+				const start = closing.indent ?? "";
 				const end = closing.newline ? "\n" : "";
 				return write(run, out, `${start}${ISLAND_CLOSING}${end}`, span);
 			});
@@ -3037,11 +3008,7 @@ var Compiler = class {
 			const state = run.state;
 			const islands = state.islands;
 			if (islands !== null && (islands.mode === "defer" || state.stream !== null && isRoot(state, out) && !run.capture?.section)) return after(loadTemplate(run, name, span), (template) => template ? render(run, out, scope, islands, template, props) : void 0);
-			if (indent === "") return embed(run, out, span, name, props, null, false);
-			const saved = out.indent;
-			const inline = out.inline;
-			startPlace(out, indent);
-			return endPlace(out, saved, inline, embed(run, out, span, name, props, null, false));
+			return embed(run, out, span, name, props, null, false);
 		};
 		return this.#embedding(node.template, node.with, span, (run, out, name, variables, scope) => run.state.islands === null ? place(run, out, name, variables, scope) : atFront(run, () => place(run, out, name, variables, scope)));
 	}
@@ -3068,8 +3035,8 @@ var Compiler = class {
 	}
 	#slot(node) {
 		const fallback = this.#body(node.body);
-		const { name, span, indent } = node;
-		const render = (run, scope, out) => {
+		const { name, span } = node;
+		return (run, scope, out) => {
 			const fill = run.slots?.get(name);
 			if (!fill) return fallback(run, childScope(scope), out);
 			try {
@@ -3082,13 +3049,6 @@ var Compiler = class {
 				throw markCaller(run, span, error);
 			}
 		};
-		if (indent === "") return render;
-		return (run, scope, out) => {
-			const saved = out.indent;
-			const inline = out.inline;
-			startPlace(out, indent);
-			return endPlace(out, saved, inline, render(run, scope, out));
-		};
 	}
 	#with(node) {
 		const value = this.#expr(node.value);
@@ -3131,11 +3091,10 @@ var Compiler = class {
 			if (value instanceof Markup) return value.value;
 			throw fail(run, span, "type-error", `"cache" keys are made of strings, numbers, booleans, dates and null, but got a ${typeName(value)}`);
 		};
-		const fullKey = (run, out, value) => {
+		const fullKey = (run, value) => {
 			const parts = Array.isArray(value) ? value.map((item) => part(run, item)) : [part(run, value)];
 			const { locale, timeZone, islands } = run.state;
-			let key = `${JSON.stringify(run.state.env.cacheNamespace)}|${templateName}|${locale}|${timeZone}|${JSON.stringify(parts)}`;
-			if (out.indent !== "") key += `|indent|${JSON.stringify([out.indent, out.inline])}`;
+			const key = `${JSON.stringify(run.state.env.cacheNamespace)}|${templateName}|${locale}|${timeZone}|${JSON.stringify(parts)}`;
 			return islands?.mode === "defer" ? `${key}|islands|${JSON.stringify([islands.url, islands.script])}` : key;
 		};
 		const lifetime = (run, value) => {
@@ -3144,7 +3103,7 @@ var Compiler = class {
 			return value;
 		};
 		const save = (run, scope, out, keyValue, secondsValue) => {
-			const name = fullKey(run, out, keyValue);
+			const name = fullKey(run, keyValue);
 			const time = lifetime(run, secondsValue);
 			const state = run.state;
 			const store = state.env.cache;
@@ -3152,7 +3111,8 @@ var Compiler = class {
 				const inner = sectionScope(scope);
 				const capture = startCapture(run, {
 					scope: inner,
-					deferred: []
+					deferred: [],
+					tags: /* @__PURE__ */ new Set()
 				});
 				return after(body(run.within(capture), inner, out), () => {
 					endCapture(run, capture);
@@ -3164,6 +3124,8 @@ var Compiler = class {
 			return after(found, (value) => {
 				const saved = typeof value === "string" ? unpackSaved(value) : null;
 				if (saved) {
+					const around = run.capture?.section;
+					if (around) for (const tag of saved.tags) around.tags.add(tag);
 					const replay = (front) => {
 						const islands = state.islands;
 						if (islands?.mode === "defer" && saved.islands.length > 0) {
@@ -3185,17 +3147,20 @@ var Compiler = class {
 				const start = out.s.length;
 				const hadScript = state.islandScript;
 				return after(fresh(), (capture) => {
+					const tags = [...capture.section?.tags ?? []].sort();
 					const manifest = state.islands?.mode === "defer" ? state.islands.manifest : null;
 					const value = packSaved({
 						html: out.s.slice(start),
 						additions: additionsIn(capture.additions ?? []),
 						islands: manifest ? (capture.section?.deferred ?? []).flatMap((id) => manifest[id] ?? []) : [],
-						islandScript: !hadScript && state.islandScript
+						islandScript: !hadScript && state.islandScript,
+						tags
 					});
 					return locating(run, span, () => store.set({
 						key: name,
 						value,
-						seconds: time
+						seconds: time,
+						tags
 					}), "The cache store");
 				});
 			});
@@ -3220,7 +3185,7 @@ var Compiler = class {
 	* so the outlet must write to that output, not to a capture or a cached section.
 	*/
 	#outlet(node) {
-		const { name, span, indent } = node;
+		const { name, span } = node;
 		const mark = (run, out) => {
 			const state = run.state;
 			if (!isRoot(state, out) || run.capture?.section) throw fail(run, span, "misplaced-outlet", `Outlet "${name}" can't be inside "cache", "set", "apply" or a macro`);
@@ -3229,8 +3194,6 @@ var Compiler = class {
 			state.outlets.set(name, {
 				out,
 				offset: out.s.length,
-				indent: indent === void 0 ? out.indent : out.indent + indent,
-				inline: indent === void 0,
 				content: null
 			});
 		};
@@ -3258,9 +3221,8 @@ var Compiler = class {
 		};
 	}
 	/**
-	* `add to`: renders its content and records it for the outlet. The content takes the outlet's indentation when the
-	* outlet has been reached. A `once` tag that already added doesn't render again, but is still recorded, so a cached
-	* section saves it.
+	* `add to`: renders its content and records it for the outlet. A `once` tag that already added doesn't render again,
+	* but is still recorded, so a cached section saves it.
 	*/
 	#add(node) {
 		const body = this.#body(node.body);
@@ -3276,12 +3238,7 @@ var Compiler = class {
 				}, front);
 				return;
 			}
-			const capture = {
-				s: "",
-				indent: OUTLET_INDENT,
-				inline: false,
-				ahead: null
-			};
+			const capture = emptyOut();
 			return after(body(run, childScope(scope), capture), () => recordAddition(run, span, {
 				outlet,
 				html: capture.s,
@@ -4199,7 +4156,7 @@ const isPrecompiled = (value) => typeof value === "object" && value !== null &&
 const mismatch = (name, detail) => new KilnRenderError("precompiled-mismatch", `Precompiled template "${name}" ${detail}. Precompile it again`, name);
 /** Compiles a precompiled template: its source, with the generated statements in place of the ones they cover. */
 const compilePrecompiled = (env, name, template) => {
-	if (template.kiln !== 4) throw mismatch(name, "was made by another version of Kiln");
+	if (template.kiln !== 5) throw mismatch(name, "was made by another version of Kiln");
 	if (template.autoescape !== env.autoescape) throw mismatch(name, "was compiled with another \"autoescape\" option");
 	const runs = /* @__PURE__ */ new Map();
 	const create = template.create;
@@ -4279,30 +4236,29 @@ const runtime = {
 	unhold,
 	/**
 	* Continues a generated run after a statement that returned a promise, `pending`: the rest of the run starts at
-	* once, ahead of it, when it may, or else once the statement is done. `inline` is `out.inline` from where the
-	* function started. See `runAhead`.
+	* once, ahead of it, when it may, or else once the statement is done. See `runAhead`.
 	*/
-	restAhead: (run, out, pending, inline, indent, rest, span) => mayRunAhead(run.state, inline) ? runAhead(run, out, pending, indent, rest, span) : pending.then(() => rest(run, out)),
+	restAhead: (run, out, pending, rest, span) => mayRunAhead(run.state) ? runAhead(run, out, pending, rest, span) : pending.then(() => rest(run, out)),
 	contentSets,
 	/**
 	* Continues a generated loop after a pass that returned a promise, `pending`: passes `from` to `to` run one at a
 	* time with `pass`, ahead of it when they may, see `passesAhead`. `sets` are the variables the loop's body sets,
 	* and `elsewhere` whether it places content from elsewhere.
 	*/
-	passAhead: (run, scope, out, pending, inline, indent, sets, elsewhere, from, to, pass, span) => passesFrom(run, out, pending, inline, from, to, indent, pass, span, passesAhead(run, scope, sets, elsewhere)),
+	passAhead: (run, scope, out, pending, sets, elsewhere, from, to, pass, span) => passesFrom(run, out, pending, from, to, pass, span, passesAhead(run, scope, sets, elsewhere)),
 	/**
 	* For a generated loop that pauses inside a pass: starts passes `from` to `to` ahead of it when they may, and returns
 	* what the loop calls once the pass is done. Returns null when they may not, and the loop carries on as usual.
 	*/
-	startAhead: (run, scope, out, inline, indent, sets, elsewhere, from, to, pass, span) => {
-		if (!mayRunAhead(run.state, inline) || !passesAhead(run, scope, sets, elsewhere)) return null;
+	startAhead: (run, scope, out, sets, elsewhere, from, to, pass, span) => {
+		if (!mayRunAhead(run.state) || !passesAhead(run, scope, sets, elsewhere)) return null;
 		let done = NOTHING;
 		let failed = NOTHING;
 		const pending = new Promise((resolve, reject) => {
 			done = resolve;
 			failed = reject;
 		});
-		const joined = passesFrom(run, out, pending, false, from, to, indent, pass, span, true);
+		const joined = passesFrom(run, out, pending, from, to, pass, span, true);
 		return {
 			join: () => {
 				done();
@@ -4314,10 +4270,6 @@ const runtime = {
 			}
 		};
 	},
-	startPlace,
-	endPlace,
-	indentText,
-	indentedText,
 	embed,
 	embedScope,
 	embedKeyed,
@@ -4662,10 +4614,6 @@ const HELPERS = [
 	"contentSets",
 	"passAhead",
 	"startAhead",
-	"startPlace",
-	"endPlace",
-	"indentText",
-	"indentedText",
 	"truthy",
 	"isEmpty",
 	"equals",
@@ -4852,7 +4800,7 @@ var Generator = class {
 		return [
 			"// Precompiled by Kiln. Don't edit this file: precompile the template again.",
 			"export default {",
-			`\tkiln: 4,`,
+			`\tkiln: 5,`,
 			`\tautoescape: ${JSON.stringify(this.#env.autoescape)},`,
 			`\tsource: ${JSON.stringify(source)},`,
 			"	create(rt) {",
@@ -4979,7 +4927,7 @@ var Generator = class {
 				const next = `${base}_${index + 1}(run, scope, out)`;
 				const body = lines.map((line) => line.replace(WAIT_LINE, (_, tabs, result, ahead) => {
 					const then = `${result}.then(() => ${next})`;
-					const rest = `restAhead(run, out, ${result}, inl, ind, (run, out) => ${next}, ${span})`;
+					const rest = `restAhead(run, out, ${result}, (run, out) => ${next}, ${span})`;
 					return `${tabs}if (${result} !== undefined) return ${ahead === AHEAD ? rest : ahead === GUARDED ? `contentSets(run) ? ${then} : ${rest}` : then};`;
 				}));
 				const last = index === segments.length - 1;
@@ -5030,8 +4978,6 @@ var Generator = class {
 			"let steps = state.steps;",
 			"const signal = state.signal;",
 			`signal !== undefined && signal.aborted && aborted(run, ${span});`,
-			"const ind = out.indent;",
-			"const inl = out.inline;",
 			"let s = \"\";",
 			`let ${[
 				"q",
@@ -5179,7 +5125,7 @@ var Generator = class {
 	}
 	#statement(statement, context) {
 		switch (statement.type) {
-			case "Text": return [this.#text(statement)];
+			case "Text": return [`s += ${JSON.stringify(statement.value)};`];
 			case "Output": return this.#output(statement.expression, statement.span, context);
 			case "If": return this.#if(statement, context);
 			case "For": return this.#for(statement, context);
@@ -5196,26 +5142,6 @@ var Generator = class {
 			default: return unsupported();
 		}
 	}
-	/** Text, with its lines indented to where it is inserted. See `indentText`. */
-	#text(statement) {
-		const text = JSON.stringify(statement.value);
-		if (!statement.lines) return `s += ${text};`;
-		const lines = JSON.stringify(statement.lines);
-		const entry = this.#constant(`text:${statement.span.start}:${statement.span.end}`, "T", `indentedText(${text}, ${lines})`);
-		return `s += ind === "" ? ${text} : ${entry}.indent === ind && !out.inline ? ${entry}.indented : indentText(${entry}, ind, s === "" && out.inline);`;
-	}
-	/**
-	* Inserts content at the indentation of the tag that inserts it, with `startPlace` and `endPlace`. Tags at the start
-	* of a line need nothing. Saved values go in temporaries rather than a closure, so the function's locals stay fast.
-	*/
-	#place(at, call) {
-		if (at === "") return call;
-		const [saved, inline] = [this.#temp(), this.#temp()];
-		return `(${saved} = out.indent, ${inline} = out.inline, startPlace(out, ${this.#at(at)}), endPlace(out, ${saved}, ${inline}, ${call}))`;
-	}
-	#at(at) {
-		return at === void 0 ? "undefined" : JSON.stringify(at);
-	}
 	/** Statements inside another, such as a loop's body. */
 	#body(list, context) {
 		const inner = {
@@ -5504,7 +5430,7 @@ var Generator = class {
 			const call = (part, value) => `${name}_${part}(${partParams}${value === void 0 ? "" : `, ${value}`})`;
 			const one = `(run, out, j) => ${name}(run, scope, out, ${loop.values}, ${loop.length}, j, j + 1${keys})`;
 			const { sets, elsewhere } = this.#setsOf(statement);
-			const handOff = (from, tabs, rest) => from === 0 ? `${tabs}return ${loop.index} + 1 < stop ? passAhead(run, scope, out, ${rest}, inl, ind, ${sets}, ${elsewhere}, ${loop.index} + 1, stop, ${one}, ${loop.span}) : ${rest};` : `${tabs}return ${rest};`;
+			const handOff = (from, tabs, rest) => from === 0 ? `${tabs}return ${loop.index} + 1 < stop ? passAhead(run, scope, out, ${rest}, ${sets}, ${elsewhere}, ${loop.index} + 1, stop, ${one}, ${loop.span}) : ${rest};` : `${tabs}return ${rest};`;
 			const continued = (from) => segments.slice(from).flatMap((lines, offset) => this.#forgetLines(lines).flatMap((line) => {
 				const next = from + offset + 1;
 				const value = VALUE_LINE.exec(line);
@@ -5593,7 +5519,7 @@ var Generator = class {
 			const ahead = `a${loop.id}`;
 			const { index, span } = loop;
 			const { sets, elsewhere } = this.#setsOf(statement);
-			const fork = `if (${ahead} === null && ${index} + 1 < stop) ${ahead} = startAhead(run, ${loop.outer}, out, inl, ind, ${sets}, ${elsewhere}, ${index} + 1, stop, (run, out, j) => drive(${name}(run, out, j, j + 1)), ${span});`;
+			const fork = `if (${ahead} === null && ${index} + 1 < stop) ${ahead} = startAhead(run, ${loop.outer}, out, ${sets}, ${elsewhere}, ${index} + 1, stop, (run, out, j) => drive(${name}(run, out, j, j + 1)), ${span});`;
 			const body = this.#forgetLines(this.#setFlags(lines)).flatMap((line) => {
 				if (line.trim() === FORK) return [line.replace(FORK, fork)];
 				const wait = WAIT_LINE.exec(line);
@@ -5758,7 +5684,7 @@ var Generator = class {
 			...target.lines,
 			...variables.lines,
 			...variables.charge(span),
-			...this.#wait(span, this.#place(statement.indent, variables.embed(span, target.name, "null", statement.ignoreMissing)), context.top)
+			...this.#wait(span, variables.embed(span, target.name, "null", statement.ignoreMissing), context.top)
 		];
 	}
 	/**
@@ -5846,7 +5772,7 @@ var Generator = class {
 			`${slots} = new Map();`,
 			...fills.map((fill) => `${slots}.set(${JSON.stringify(fill.name)}, { body: ${this.#nested(fill.body, statement.span, context)}, run, scope: ${context.scope}, sets: ${mayWrite(fill.body)} });`),
 			...variables.charge(span),
-			...this.#wait(span, this.#place(statement.indent, variables.embed(span, target.name, slots, false)), context.top),
+			...this.#wait(span, variables.embed(span, target.name, slots, false), context.top),
 			...fills.some((fill) => setsVariables(fill.body)) ? this.#forgetAll() : fills.some((fill) => containsNode(fill.body, (record) => record.type === "Block")) ? this.#afterBlocks() : []
 		];
 	}
@@ -5854,7 +5780,6 @@ var Generator = class {
 	#slot(statement, context) {
 		const span = this.#span(statement.span);
 		const fill = this.#temp();
-		const at = statement.indent;
 		const sets = [...setsIn(statement.body)];
 		const scope = sets.length > 0 ? this.#temp() : context.scope;
 		let fallback = this.#body(statement.body, {
@@ -5866,23 +5791,10 @@ var Generator = class {
 			...fallback,
 			...sets.flatMap((name) => this.#forget(name))
 		];
-		if (at !== "" && !statement.body.every(isBlank)) {
-			const [saved, inline] = [this.#temp(), this.#temp()];
-			fallback = [
-				`${saved} = out.indent;`,
-				`${inline} = out.inline;`,
-				`startPlace(out, ${this.#at(at)});`,
-				"{",
-				...indent(["const ind = out.indent;", ...fallback]),
-				"}",
-				`out.indent = ${saved};`,
-				`if (out.inline) out.inline = ${inline};`
-			];
-		}
 		return [
 			`${fill} = run.slots === null ? undefined : run.slots.get(${JSON.stringify(statement.name)});`,
 			`if (${fill} !== undefined) {`,
-			...indent(this.#wait(span, this.#place(at, `fillSlot(run, ${span}, ${fill}, out)`), context.top)),
+			...indent(this.#wait(span, `fillSlot(run, ${span}, ${fill}, out)`, context.top)),
 			"} else {",
 			...indent(fallback),
 			"}"
@@ -5896,7 +5808,7 @@ var Generator = class {
 		if (context.inLoop) return unsupported();
 		this.#pending.push([statement.body, context.strategy]);
 		const span = this.#span(statement.span);
-		return [...this.#wait(span, this.#place(statement.indent, `placeBlock(run, ${span}, ${JSON.stringify(statement.name)}, ${context.scope}, out)`), context.top), ...this.#afterBlocks()];
+		return [...this.#wait(span, `placeBlock(run, ${span}, ${JSON.stringify(statement.name)}, ${context.scope}, out)`, context.top), ...this.#afterBlocks()];
 	}
 	/** Forgets every variable lookup after a block is placed when the block, perhaps a child template's version, may set any variable. */
 	#afterBlocks() {
@@ -8565,7 +8477,7 @@ const memoryLoader = (templates) => {
 };
 /**
 * A store for the `cache` tag that keeps output in memory, for a long-running server. Holds up to `max` copies, 1,000
-* by default, and drops the oldest first.
+* by default, and drops the oldest first. `clear` removes every copy, or those with any of the tags passed.
 *
 * ```ts
 * const kiln = createKiln({ loader, cache: memoryCache() });
@@ -8581,14 +8493,20 @@ const memoryCache = ({ max = 1e3 } = {}) => {
 			entries.delete(key);
 			return null;
 		},
-		set: ({ key, value, seconds }) => {
+		set: ({ key, value, seconds, tags }) => {
 			entries.delete(key);
 			entries.set(key, {
 				value,
-				expires: seconds === null ? Infinity : Date.now() + seconds * 1e3
+				expires: seconds === null ? Infinity : Date.now() + seconds * 1e3,
+				tags
 			});
 			const oldest = entries.keys().next();
 			if (entries.size > max && !oldest.done) entries.delete(oldest.value);
+		},
+		/** Removes every copy, or with `tags`, the copies that have any of them. */
+		clear: ({ tags } = {}) => {
+			if (!tags) return entries.clear();
+			for (const [key, entry] of entries) if (entry.tags.some((tag) => tags.includes(tag))) entries.delete(key);
 		}
 	};
 };