@samva/markup 0.1.1 → 0.2.0

package/dist/presets.d.ts

@@ -1,9 +1,9 @@
-import { d as Channel } from "./ast-DAhnAvQN.js";
+import { d as Channel } from "./ast-63I-VLQx.js";
 import { o as TokenOverrides } from "./theme-6ApjjiBo.js";
 //#region presets/catalog.d.ts
 type PresetCategory = "transactional" | "digest" | "marketing" | "lifecycle";
 interface PresetMeta {
-  /** Stable id and source filename stem (`${id}.samva`). */
+  /** Stable id and source filename stem (`${id}.tsx`). */
   readonly id: string;
   /** The source's root-tag channel; the gallery filters by it. */
   readonly channel: Channel;

package/dist/printer.d.ts

@@ -1,4 +1,4 @@
-import { C as SmlDocument } from "./ast-DAhnAvQN.js";
+import { w as SmlDocument } from "./ast-63I-VLQx.js";
 //#region src/printer.d.ts
 declare const printSml: (document: SmlDocument) => string;
 //#endregion

package/dist/render-Cddsy_XF.js

@@ -0,0 +1,585 @@
+import { EmailNode, drainEmailDiagnostics } from "./email/jsx-runtime.js";
+import { declarationValue, kebab, serializeEmailHtml } from "./email/html.js";
+import { PREHEADER_ATTRIBUTE, preheaderNode } from "./email/components.js";
+import { EmailCompileError, hasBlockingDiagnostic } from "./email/diagnostics.js";
+import { collectStylesheets, hasStylesheets } from "./email/stylesheets.js";
+import { deriveEmailText } from "./email/text.js";
+import { Predicate } from "effect";
+//#region src/email/css-values.ts
+/** Expand `var(--x, fallback)` against the collected custom properties. */
+const resolveVariables = (value, variables, depth = 0) => {
+	if (depth > 8 || !value.includes("var(")) return value;
+	let result = "";
+	let rest = value;
+	while (rest.length > 0) {
+		const start = rest.indexOf("var(");
+		if (start < 0) {
+			result += rest;
+			break;
+		}
+		result += rest.slice(0, start);
+		let level = 0;
+		let end = -1;
+		for (let index = start + 3; index < rest.length; index++) if (rest[index] === "(") level += 1;
+		else if (rest[index] === ")") {
+			level -= 1;
+			if (level === 0) {
+				end = index;
+				break;
+			}
+		}
+		if (end < 0) {
+			result += rest.slice(start);
+			break;
+		}
+		const body = rest.slice(start + 4, end);
+		const comma = body.indexOf(",");
+		const name = (comma < 0 ? body : body.slice(0, comma)).trim();
+		const fallback = comma < 0 ? void 0 : body.slice(comma + 1).trim();
+		const replacement = variables[name] ?? fallback;
+		result += replacement === void 0 ? rest.slice(start, end + 1) : resolveVariables(replacement, variables, depth + 1);
+		rest = rest.slice(end + 1);
+	}
+	return result;
+};
+/**
+* Fold a constant `calc()` to a plain value. Tailwind writes every spacing
+* utility as `calc(var(--spacing) * n)`, and classic Outlook does not implement
+* `calc()` at all, so an unfolded value is a silently missing style. An
+* expression that cannot be reduced to one term is left exactly as authored.
+*/
+const foldCalc = (value) => {
+	if (!value.includes("calc(")) return value;
+	let result = "";
+	let rest = value;
+	while (rest.length > 0) {
+		const start = rest.indexOf("calc(");
+		if (start < 0) {
+			result += rest;
+			break;
+		}
+		result += rest.slice(0, start);
+		let level = 0;
+		let end = -1;
+		for (let index = start + 4; index < rest.length; index++) if (rest[index] === "(") level += 1;
+		else if (rest[index] === ")") {
+			level -= 1;
+			if (level === 0) {
+				end = index;
+				break;
+			}
+		}
+		if (end < 0) {
+			result += rest.slice(start);
+			break;
+		}
+		const folded = evaluate(rest.slice(start + 5, end));
+		result += folded === void 0 ? rest.slice(start, end + 1) : format(folded);
+		rest = rest.slice(end + 1);
+	}
+	return result;
+};
+const format = (value) => `${Math.round(value.n * 1e6) / 1e6}${value.n === 0 && value.unit !== "%" ? "" : value.unit}`;
+const evaluate = (expression) => {
+	const tokens = expression.match(/\(|\)|[+-]\s|[*/]|[^\s()*/]+/g);
+	if (tokens === null) return void 0;
+	let position = 0;
+	const peek = () => tokens[position]?.trim();
+	const sum = () => {
+		let left = product();
+		while (left !== void 0 && (peek() === "+" || peek() === "-")) {
+			const operator = peek();
+			position += 1;
+			const right = product();
+			if (right === void 0 || left.unit !== right.unit) return void 0;
+			left = {
+				n: operator === "+" ? left.n + right.n : left.n - right.n,
+				unit: left.unit
+			};
+		}
+		return left;
+	};
+	const product = () => {
+		let left = term();
+		while (left !== void 0 && (peek() === "*" || peek() === "/")) {
+			const operator = peek();
+			position += 1;
+			const right = term();
+			if (right === void 0) return void 0;
+			if (operator === "*") {
+				if (left.unit !== "" && right.unit !== "") return void 0;
+				left = {
+					n: left.n * right.n,
+					unit: left.unit === "" ? right.unit : left.unit
+				};
+			} else {
+				if (right.unit !== "" || right.n === 0) return void 0;
+				left = {
+					n: left.n / right.n,
+					unit: left.unit
+				};
+			}
+		}
+		return left;
+	};
+	const term = () => {
+		const token = tokens[position];
+		if (token === void 0) return void 0;
+		if (token === "(") {
+			position += 1;
+			const inner = sum();
+			if (peek() !== ")") return void 0;
+			position += 1;
+			return inner;
+		}
+		const match = /^(-?(?:\d+\.?\d*|\.\d+))([a-z%]*)$/i.exec(token.trim());
+		if (match === null) return void 0;
+		position += 1;
+		return {
+			n: Number.parseFloat(match[1]),
+			unit: (match[2] ?? "").toLowerCase()
+		};
+	};
+	const value = sum();
+	return position === tokens.length ? value : void 0;
+};
+/** Resolve custom properties, then fold what the arithmetic allows. */
+const finalizeValue = (value, variables) => foldCalc(resolveVariables(value, variables));
+const RANGE_FEATURE = /\(\s*([a-z-]+)\s*(<=|>=|<|>)\s*([^)]+?)\s*\)/gi;
+/** Media Queries Level 4 range syntax down to the `min-`/`max-` prefixes clients support. */
+const downlevelMediaQuery = (condition) => condition.replace(RANGE_FEATURE, (whole, feature, comparison, bound) => {
+	return `(${comparison.startsWith(">") ? "min-" : "max-"}${feature}:${bound})`;
+});
+/** Render the rules that could not be inlined as one `<style>` body. */
+const renderHeadCss = (rules, headAtRules, variables) => {
+	const blocks = [...headAtRules];
+	const grouped = /* @__PURE__ */ new Map();
+	for (const rule of rules) {
+		const conditions = rule.conditions.map(downlevelMediaQuery);
+		const key = conditions.join("\0");
+		const bucket = grouped.get(key);
+		if (bucket === void 0) grouped.set(key, {
+			conditions,
+			rules: [rule]
+		});
+		else bucket.rules.push(rule);
+	}
+	for (const { conditions, rules: bucket } of grouped.values()) {
+		const body = bucket.map((rule) => {
+			const declarations = rule.declarations.filter((declaration) => !declaration.property.startsWith("--")).map((declaration) => `${declaration.property}:${finalizeValue(declaration.value, variables)}!important`).join(";");
+			return declarations === "" ? "" : `${rule.selector}{${declarations}}`;
+		}).filter((block) => block !== "").join("");
+		if (body === "") continue;
+		blocks.push(conditions.reduceRight((inner, condition) => `${condition}{${inner}}`, body));
+	}
+	return blocks.join("");
+};
+//#endregion
+//#region src/email/selectors.ts
+const classListOf = (element) => {
+	const value = element.props.class ?? element.props.className;
+	return typeof value === "string" ? value.split(/\s+/).filter((name) => name !== "") : [];
+};
+const attributeOf = (element, name) => {
+	const value = element.props[name];
+	if (value === void 0 || value === null || value === false) return void 0;
+	if (value === true) return "";
+	return typeof value === "string" || typeof value === "number" ? String(value) : void 0;
+};
+const matchesAttribute = (element, test) => {
+	const actual = test.name === "class" ? classListOf(element).join(" ") : attributeOf(element, test.name);
+	if (actual === void 0) return false;
+	if (test.operator === void 0 || test.value === void 0) return true;
+	switch (test.operator) {
+		case "=": return actual === test.value;
+		case "~=": return actual.split(/\s+/).includes(test.value);
+		case "^=": return actual.startsWith(test.value);
+		case "$=": return actual.endsWith(test.value);
+		case "*=": return actual.includes(test.value);
+		case "|=": return actual === test.value || actual.startsWith(`${test.value}-`);
+		default: return false;
+	}
+};
+const matchesCompound = (element, compound) => {
+	if (compound.opaque) return false;
+	if (compound.tag !== void 0 && compound.tag !== element.tag) return false;
+	if (compound.id !== void 0 && attributeOf(element, "id") !== compound.id) return false;
+	if (compound.classes.length > 0) {
+		const classes = classListOf(element);
+		if (!compound.classes.every((name) => classes.includes(name))) return false;
+	}
+	return compound.attributes.every((test) => matchesAttribute(element, test));
+};
+const matchesFrom = (selector, index, ancestry) => {
+	if (ancestry === void 0) return false;
+	const part = selector.parts[index];
+	if (part === void 0) return false;
+	if (!matchesCompound(ancestry.element, part.compound)) return false;
+	const left = selector.parts[index - 1];
+	if (left === void 0) return true;
+	switch (left.after ?? "descendant") {
+		case "child": return matchesFrom(selector, index - 1, ancestry.parent);
+		case "descendant":
+			for (let parent = ancestry.parent; parent !== void 0; parent = parent.parent) if (matchesFrom(selector, index - 1, parent)) return true;
+			return false;
+		case "adjacent": {
+			const sibling = ancestry.previous.at(-1);
+			return sibling === void 0 ? false : matchesFrom(selector, index - 1, {
+				element: sibling,
+				parent: ancestry.parent,
+				previous: ancestry.previous.slice(0, -1)
+			});
+		}
+		case "sibling":
+			for (let position = ancestry.previous.length - 1; position >= 0; position--) if (matchesFrom(selector, index - 1, {
+				element: ancestry.previous[position],
+				parent: ancestry.parent,
+				previous: ancestry.previous.slice(0, position)
+			})) return true;
+			return false;
+	}
+};
+/** Match a compiled selector against one element in its tree position. */
+const matchesSelector = (selector, ancestry) => selector === void 0 || selector.parts.length === 0 ? false : matchesFrom(selector, selector.parts.length - 1, ancestry);
+//#endregion
+//#region src/email/cascade.ts
+/**
+* Cascade rank as the tuple CSS actually sorts by: importance first, then
+* whether the declaration is attached to the element itself, then layer, then
+* specificity, then order of appearance down to the declaration. Normal
+* declarations sort by layer ascending (unlayered last, so it wins); important
+* declarations reverse the layer order, which is why the layer term is negated
+* for them. Element-attached declarations are compared before layers and
+* specificity, so an author's important inline value beats an important
+* stylesheet declaration exactly as it does in a browser. Two declarations never
+* tie: rule order is unique across every registered sheet, and the position
+* inside a rule separates the declarations that share it.
+*/
+const rank = (important, attached, layer, specificity, order, position) => [
+	important ? 1 : 0,
+	attached ? 1 : 0,
+	important ? -layer : layer,
+	specificity[0],
+	specificity[1],
+	specificity[2],
+	order,
+	position
+];
+const compareRank = (left, right) => {
+	for (let index = 0; index < Math.max(left.length, right.length); index++) {
+		const a = left[index] ?? 0;
+		const b = right[index] ?? 0;
+		if (a !== b) return a - b;
+	}
+	return 0;
+};
+const outranks = (left, right) => compareRank(left, right) >= 0;
+/** An authored `style` object becomes declarations with the same normalization the serializer uses. */
+const inlineDeclarations = (style) => {
+	if (!Predicate.isObject(style) || Array.isArray(style)) return [];
+	const output = [];
+	for (const [property, value] of Object.entries(style)) {
+		if (value === void 0 || value === null) continue;
+		if (typeof value !== "string" && typeof value !== "number") continue;
+		const text = declarationValue(property, value);
+		const important = /!important\s*$/i.test(text);
+		output.push({
+			property: kebab(property),
+			value: important ? text.replace(/\s*!important\s*$/i, "") : text,
+			important
+		});
+	}
+	return output;
+};
+const horizontalWriting = {
+	direction: "ltr",
+	writingMode: "horizontal-tb"
+};
+const paddingValues = (value) => {
+	const values = [];
+	let depth = 0;
+	let start = 0;
+	for (let index = 0; index < value.length; index++) {
+		const character = value[index];
+		if (character === "(") depth++;
+		else if (character === ")") depth--;
+		else if (/\s/.test(character) && depth === 0) {
+			if (index > start) values.push(value.slice(start, index));
+			start = index + 1;
+		}
+	}
+	if (start < value.length) values.push(value.slice(start));
+	return values;
+};
+const physicalPadding = (property, value, context) => {
+	const original = [[property, value]];
+	const match = /^padding-(inline|block)(?:-(start|end))?$/.exec(property);
+	if (match === null || context.writingMode !== "horizontal-tb" || !["ltr", "rtl"].includes(context.direction) || /^(inherit|revert|revert-layer)$/.test(value) || value.includes("var(")) return original;
+	const values = paddingValues(value.trim());
+	if (values.length < 1 || values.length > (match[2] === void 0 ? 2 : 1)) return original;
+	const sides = match[1] === "block" ? ["top", "bottom"] : context.direction === "rtl" ? ["right", "left"] : ["left", "right"];
+	if (match[2] !== void 0) return [[`padding-${sides[match[2] === "start" ? 0 : 1]}`, values[0]]];
+	return [[`padding-${sides[0]}`, values[0]], [`padding-${sides[1]}`, values[1] ?? values[0]]];
+};
+/**
+* Resolve every stylesheet against the tree: inline what a client will honor on
+* the element, and keep the rest for `<head>`.
+*/
+const applyStylesheet = (root, sheet, options = {}) => {
+	const diagnostics = [...sheet.diagnostics];
+	const inlinable = [];
+	const retained = [];
+	const styledClasses = /* @__PURE__ */ new Set();
+	for (const rule of sheet.rules) {
+		(rule.inlinable ? inlinable : retained).push(rule);
+		for (const name of rule.classes) styledClasses.add(name);
+	}
+	const conditionalWritingRules = retained.filter((rule) => rule.declarations.some((declaration) => declaration.property === "direction" || declaration.property === "writing-mode" || declaration.property === "all"));
+	const unmatched = /* @__PURE__ */ new Map();
+	/**
+	* Children are visited with their own preceding-sibling list so `+`/`~` work.
+	* A fragment is not an element in the serialized document, so its children
+	* join that same list rather than starting a new one.
+	*/
+	const visitChildren = (children, ancestry, variables, writing) => {
+		const previous = [];
+		const visit = (nodes) => nodes.map((child) => {
+			if (child._tag === "Element") {
+				const result = applyTo(child, {
+					element: child,
+					parent: ancestry,
+					previous: [...previous]
+				}, variables, writing);
+				previous.push(child);
+				return result;
+			}
+			if (child._tag === "Fragment") return EmailNode.Fragment({ children: visit(child.children) });
+			return child;
+		});
+		return visit(children);
+	};
+	/**
+	* `inherited` is the custom-property scope this element sees from its
+	* ancestors, rooted in the sheet's unconditional properties. Custom properties
+	* cascade like any other declaration and then inherit, so a `--brand` declared
+	* on `.card` has to reach `var(--brand)` on `.card` and everything under it.
+	*/
+	const applyTo = (element, ancestry, inherited, inheritedWriting) => {
+		const conditionalWriting = conditionalWritingRules.some((rule) => {
+			if (rule.matcher === void 0 || rule.matcher.parts.length === 0 || rule.matcher.parts.some((part) => part.compound.opaque)) return true;
+			for (let context = ancestry; context !== void 0; context = context.parent) if (matchesSelector(rule.matcher, context)) return true;
+			return false;
+		});
+		const winners = /* @__PURE__ */ new Map();
+		const claim = (declaration, key) => {
+			const current = winners.get(declaration.property);
+			if (current === void 0 || outranks(key, current.key)) winners.set(declaration.property, {
+				value: declaration.value,
+				key
+			});
+		};
+		for (const rule of inlinable) {
+			if (!matchesSelector(rule.matcher, ancestry)) continue;
+			for (const [position, declaration] of rule.declarations.entries()) claim(declaration, rank(declaration.important, false, rule.layer, rule.specificity, rule.order, position));
+		}
+		for (const [position, declaration] of inlineDeclarations(element.props.style).entries()) claim(declaration, rank(declaration.important, true, 0, [
+			0,
+			0,
+			0
+		], 0, position));
+		for (const name of classListOf(element)) if (!styledClasses.has(name) && options.knownClasses?.has(name) !== true) unmatched.set(name, [...unmatched.get(name) ?? [], ...element.origins]);
+		const declared = {};
+		for (const [property, entry] of winners) if (property.startsWith("--")) declared[property] = entry.value;
+		const variables = Object.keys(declared).length === 0 ? inherited : {
+			...inherited,
+			...declared
+		};
+		const inheritedValue = (property, parent, initial, fallback = parent) => {
+			const value = winners.get(property)?.value;
+			if (value === void 0) return fallback;
+			const resolved = finalizeValue(value, variables);
+			return resolved === "inherit" || resolved === "unset" ? parent : resolved === "initial" ? initial : resolved;
+		};
+		const writing = {
+			direction: inheritedValue("direction", inheritedWriting.direction, "ltr", typeof element.props.dir === "string" ? element.props.dir : element.tag === "bdi" ? "auto" : inheritedWriting.direction),
+			writingMode: winners.has("all") ? "unknown" : inheritedValue("writing-mode", inheritedWriting.writingMode, "horizontal-tb")
+		};
+		const emitted = [...winners].filter(([property]) => !property.startsWith("--")).sort(([, left], [, right]) => compareRank(left.key, right.key)).map(([property, entry]) => [property, finalizeValue(entry.value, variables)]);
+		const physical = /* @__PURE__ */ new Map();
+		for (const [property, value] of emitted) for (const [name, lowered] of conditionalWriting ? [[property, value]] : physicalPadding(property, value, writing)) {
+			physical.delete(name);
+			physical.set(name, lowered);
+		}
+		return EmailNode.Element({
+			...element,
+			props: emitted.length === 0 ? element.props : {
+				...element.props,
+				style: Object.fromEntries(physical)
+			},
+			children: visitChildren(element.children, ancestry, variables, writing)
+		});
+	};
+	const tree = root._tag === "Element" ? applyTo(root, {
+		element: root,
+		parent: void 0,
+		previous: []
+	}, sheet.variables, horizontalWriting) : root._tag === "Fragment" ? EmailNode.Fragment({ children: visitChildren(root.children, void 0, sheet.variables, horizontalWriting) }) : root;
+	for (const [name, origins] of unmatched) diagnostics.push({
+		code: "unmatched-class",
+		severity: "warning",
+		message: `Class ${JSON.stringify(name)} produced no styles. If it is composed at run time, the compiler cannot discover it; list it in the template's declared classes or write the style inline.`,
+		origins: origins.slice(0, 1)
+	});
+	return {
+		tree,
+		headCss: renderHeadCss(retained, sheet.headAtRules, sheet.variables),
+		diagnostics
+	};
+};
+//#endregion
+//#region src/email/render.ts
+/** Classic Outlook lays a document out correctly only under a transitional doctype. */
+const EMAIL_DOCTYPE = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">";
+const settle = (diagnostics) => {
+	if (hasBlockingDiagnostic(diagnostics)) throw new EmailCompileError({ diagnostics });
+	return diagnostics;
+};
+/** Lower the derived tree to HTML and its plain-text alternative. */
+const compileEmail = (node, options = {}) => {
+	const serialized = serializeEmailHtml(node, options);
+	const diagnostics = settle([...drainEmailDiagnostics(), ...serialized.diagnostics]);
+	return {
+		html: serialized.html,
+		text: deriveEmailText(node),
+		diagnostics,
+		positions: serialized.positions
+	};
+};
+/** The preview text already present in the tree, from `<Email preheader>`. */
+const declaredPreheader = (node) => {
+	switch (node._tag) {
+		case "Text":
+		case "Raw": return;
+		case "Fragment": return node.children.reduce((found, child) => found ?? declaredPreheader(child), void 0);
+		case "Element": {
+			const declared = node.props[PREHEADER_ATTRIBUTE];
+			if (typeof declared === "string") return declared;
+			return node.children.reduce((found, child) => found ?? declaredPreheader(child), void 0);
+		}
+	}
+};
+/** Put the hidden preview block first inside `<body>`, or first overall when there is no shell. */
+const withPreheader = (node, text) => {
+	const insert = (current) => {
+		if (current._tag === "Fragment") {
+			for (const [index, child] of current.children.entries()) {
+				const replaced = insert(child);
+				if (replaced !== void 0) return EmailNode.Fragment({ children: current.children.with(index, replaced) });
+			}
+			return;
+		}
+		if (current._tag !== "Element") return void 0;
+		if (current.tag === "body") return EmailNode.Element({
+			...current,
+			children: [preheaderNode(text), ...current.children]
+		});
+		for (const [index, child] of current.children.entries()) {
+			const replaced = insert(child);
+			if (replaced !== void 0) return EmailNode.Element({
+				...current,
+				children: current.children.with(index, replaced)
+			});
+		}
+	};
+	return insert(node) ?? EmailNode.Fragment({ children: [preheaderNode(text), node] });
+};
+/** Put the retained rules in a `<style>` at the end of `<head>`. */
+const withHeadCss = (node, css) => {
+	const insert = (current) => {
+		if (current._tag === "Fragment") {
+			for (const [index, child] of current.children.entries()) {
+				const replaced = insert(child);
+				if (replaced !== void 0) return EmailNode.Fragment({ children: current.children.with(index, replaced) });
+			}
+			return;
+		}
+		if (current._tag !== "Element") return void 0;
+		if (current.tag === "head") return EmailNode.Element({
+			...current,
+			children: [...current.children, EmailNode.Element({
+				tag: "style",
+				props: {},
+				children: [EmailNode.Text({ value: css })],
+				origins: current.origins,
+				authored: false
+			})]
+		});
+		for (const [index, child] of current.children.entries()) {
+			const replaced = insert(child);
+			if (replaced !== void 0) return EmailNode.Element({
+				...current,
+				children: current.children.with(index, replaced)
+			});
+		}
+	};
+	return insert(node);
+};
+/** Render one validated input through the template's only content function. Host isolation is required for untrusted source. */
+const renderEmail = (template, data, options = {}) => {
+	if (!template.schema.validate(data)) throw new TypeError(`Invalid template input: ${JSON.stringify(template.schema.validate.errors)}`);
+	drainEmailDiagnostics();
+	const content = template.render(data);
+	const invalid = [];
+	const fail = (code, message) => invalid.push({
+		code,
+		severity: "error",
+		message,
+		origins: []
+	});
+	if (typeof content.subject !== "string" || /[\r\n\u0000]/.test(content.subject)) fail("invalid-subject", "Invalid email subject: it must be one line of text.");
+	if (content.preheader !== void 0 && typeof content.preheader !== "string") fail("invalid-preheader", "Invalid email preheader: it must be a string.");
+	if (content.text !== void 0 && typeof content.text !== "string") fail("invalid-text", "Invalid plain text: it must be a string.");
+	const declared = declaredPreheader(content.body);
+	if (content.preheader !== void 0 && declared !== void 0) fail("duplicate-preheader", "Preheader is set on both the template content and <Email preheader>; keep one.");
+	settle(invalid);
+	const base = content.preheader === void 0 ? content.body : withPreheader(content.body, content.preheader);
+	const styled = hasStylesheets() ? applyStylesheet(base, collectStylesheets()) : {
+		tree: base,
+		headCss: "",
+		diagnostics: []
+	};
+	const style = [...styled.diagnostics];
+	let tree = styled.tree;
+	if (styled.headCss !== "") {
+		const placed = withHeadCss(tree, styled.headCss);
+		if (placed === void 0) style.push({
+			code: "missing-head",
+			severity: "error",
+			message: "Styles that cannot be inlined — media queries, dark-scheme rules and pseudo-selectors — need a <head> to live in. Wrap the message in <Email>, or write those declarations as inline styles.",
+			origins: []
+		});
+		else tree = placed;
+	}
+	settle(style);
+	const compiled = compileEmail(tree, options);
+	const prefix = compiled.html.startsWith("<html") ? EMAIL_DOCTYPE : "";
+	const html = `${prefix}${compiled.html}`;
+	const positions = prefix === "" ? compiled.positions : compiled.positions.map((position) => ({
+		...position,
+		start: position.start + prefix.length,
+		end: position.end + prefix.length
+	}));
+	return {
+		subject: content.subject,
+		preheader: content.preheader ?? declared,
+		html,
+		text: content.text ?? compiled.text,
+		tree,
+		diagnostics: [...style, ...compiled.diagnostics],
+		positions
+	};
+};
+//#endregion
+export { classListOf as a, finalizeValue as c, resolveVariables as d, applyStylesheet as i, foldCalc as l, compileEmail as n, matchesSelector as o, renderEmail as r, downlevelMediaQuery as s, EMAIL_DOCTYPE as t, renderHeadCss as u };
+
+//# sourceMappingURL=render-Cddsy_XF.js.map

package/dist/render-template.d.ts

@@ -1,7 +1,8 @@
 import { o as SmlParseError } from "./diagnostics-oveE-laV.js";
-import { C as SmlDocument } from "./ast-DAhnAvQN.js";
-import { a as VariableKind, l as Variables } from "./variables-3NGLpNTB.js";
-import { a as JsxResult } from "./jsx-runtime-fSxcvlx4.js";
+import { w as SmlDocument } from "./ast-63I-VLQx.js";
+import { c as UnboundTemplateSourceLocations } from "./source-locations-BCJQnIfU.js";
+import { a as VariableKind, l as Variables } from "./variables-if1VrV34.js";
+import { a as JsxResult } from "./jsx-runtime-C5k_Zq0A.js";
 import { Result } from "effect";
 //#region src/render-template.d.ts
 /**
@@ -27,6 +28,8 @@ interface RenderedTemplate {
   readonly document: SmlDocument;
   readonly source: string;
   readonly variables: ReadonlyArray<TemplateVariable>;
+  /** Ephemeral parsed-node-id → authored JSX source origins, when available. */
+  readonly sourceLocations: UnboundTemplateSourceLocations;
 }
 /**
  * Runs a template function and returns its canonical document, source, and

package/dist/render-template.js

@@ -1,4 +1,5 @@
-import { collectPredicateVariables, parsePredicate } from "./predicate.js";
+import { mapJsxSourceLocations } from "./source-locations.js";
+import { i as parsePredicate, n as collectPredicateVariables } from "./predicate-CvkzT-a2.js";
 import { isRootTag } from "./ast.js";
 import { createVariablesProxy } from "./variables.js";
 import { parseSml } from "./parser.js";
@@ -27,7 +28,8 @@ const renderTemplate = (template) => {
 	return Result.succeed({
 		document,
 		source,
-		variables: collectVariableSchema(document, recorder)
+		variables: collectVariableSchema(document, recorder),
+		sourceLocations: mapJsxSourceLocations(root, document.root)
 	});
 };
 /**