@lucidkiln/core 1.1.0 → 1.2.0

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

@@ -1,4 +1,4 @@
-import { n as contentStart } from "./parser-BU5dThuk.js";
+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") => ({
@@ -373,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. */
@@ -537,15 +535,6 @@ var Run = class Run {
 };
 //#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) {
@@ -607,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 ?? [])) {
@@ -619,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;
 };
@@ -659,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);
@@ -683,8 +665,6 @@ const runAhead = (run, out, pending, indent, rest, span) => {
 	});
 	const ahead = {
 		s: "",
-		indent,
-		inline: false,
 		ahead: out.ahead ?? {
 			base: out,
 			size: 0
@@ -759,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));
@@ -779,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;
@@ -862,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);
@@ -885,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);
@@ -1297,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) {
@@ -1601,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) {
@@ -2401,6 +2329,6 @@ var Source = class {
 	}
 };
 //#endregion
-export { withCaller as $, suggest as $t, consume as A, passesAhead as At, indentText as B, RenderState as Bt, getAttr as C, BLOCKED_NAMES as Ct, after as D, contentSets as Dt, addSlotFlags as E, atFront as Et, endPlace as F, additionsIn as Ft, locating as G, fillScope as Gt, isPromise as H, blockScope as Ht, fail as I, checkLate as It, renderTemplate as J, lookup$1 as Jt, markCaller as K, startCapture as Kt, hold as L, closeOutlets as Lt, embed as M, runAhead as Mt, embedKeyed as N, runSequence as Nt, all as O, isRoot as Ot, embedScope as P, OUTLET_INDENT as Pt, unhold as Q, variableNames as Qt, holdData as R, recordAddition as Rt, toTime as S, valueLabel as St, readableNames as T, lookup as Tt, loadTemplate as U, emptyOut as Ut, indentedText as V, Run as Vt, locate as W, endCapture as Wt, startPlace as X, sectionCopy as Xt, silence as Y, ownerOf as Yt, step as Z, sectionScope as Zt, markupText as _, toStr as _t, operatorFunction as a, escapeWith as an, describeValue as at, toPieces as b, typeName as bt, checkDepth as c, KilnIssue as cn, isEmpty as ct, functionArgument as d, createDiagnostic as dn, literalOptions as dt, Markup as en, write as et, insertedPiece as f, issue as fn, mapKeys as ft, mapContents as g, toNumber as gt, listOf as h, templateFunctions as ht, contains as i, escapeUrl as in, describeType as it, consumeAt as j, passesFrom as jt, checkLength as k, mayRunAhead as kt, entriesOf as l, KilnRenderError as ln, isHashLike as lt, isHtmlStrategy as m, setOwn as mt, builtinFunctions as n, safe as nn, MISSING as nt, rangeOperator as o, TEMPLATE_EXTENSION as on, equals as ot, integerArgument as p, matchesType as pt, passData as q, childScope as qt, builtinTests as r, escapeHtml as rn, compare as rt, Kept as s, resolveTemplateName as sn, hashKeys as st, Source as t, isSafe as tn, FORMATTERS as tt, fromPieces as u, KilnSyntaxError as un, isPlainObject as ut, readProperty as v, toStringArgument as vt, getMethod as w, expose as wt, toPlainData as x, unwrap as xt, scanHtml as y, truthy as yt, importsFor as z, takeOutput as zt };
+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-BHcxowQp.js.map
+//# sourceMappingURL=source-BbikGqIb.js.map