@samva/markup 0.1.2 → 0.3.0

package/dist/render-ykQhtMs_.js

@@ -0,0 +1,592 @@
+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 { snapshotStylesheets } 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 = {}) => renderEmailWith(snapshotStylesheets(), template, data, options);
+/**
+* A render bound to the sheets registered so far. A compiled project's wrapper
+* calls this once its own stylesheet imports have run, so a later project
+* loaded into the same process cannot restyle an entry that is rendered again.
+*/
+const bindStylesheets = (stylesheet = snapshotStylesheets()) => (template, data, options = {}) => renderEmailWith(stylesheet, template, data, options);
+const renderEmailWith = (stylesheet, 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 = stylesheet === void 0 ? {
+		tree: base,
+		headCss: "",
+		diagnostics: []
+	} : applyStylesheet(base, stylesheet);
+	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 { applyStylesheet as a, downlevelMediaQuery as c, renderHeadCss as d, resolveVariables as f, renderEmail as i, finalizeValue as l, bindStylesheets as n, classListOf as o, compileEmail as r, matchesSelector as s, EMAIL_DOCTYPE as t, foldCalc as u };
+
+//# sourceMappingURL=render-ykQhtMs_.js.map

package/dist/source-locations-BCJQnIfU.d.ts

@@ -0,0 +1,89 @@
+import { E as SmlNode, m as ElementNode } from "./ast-63I-VLQx.js";
+import { Schema } from "effect";
+//#region src/source-locations.d.ts
+/**
+ * The source payload emitted by the JSX development transform. The transform
+ * may omit any field for synthetic calls; only a complete payload can identify
+ * a source origin safely.
+ */
+interface JsxSource {
+  readonly fileName?: string | undefined;
+  readonly lineNumber?: number | undefined;
+  readonly columnNumber?: number | undefined;
+}
+/** A complete, normalized source origin for a JSX element. */
+interface JsxSourceLocation {
+  readonly fileName: string;
+  readonly lineNumber: number;
+  readonly columnNumber: number;
+}
+/** JSON-safe source location shape shared by preview and editor contracts. */
+declare const JsxSourceLocation: Schema.Struct<{
+  readonly fileName: Schema.String;
+  readonly lineNumber: Schema.Int;
+  readonly columnNumber: Schema.Int;
+}>;
+/** Reasons a preview cannot safely expose an authored source map. */
+declare const SourceLocationUnavailableReason: Schema.Literals<readonly ["no-source-metadata", "structure-mismatch", "duplicate-source-origin", "render-failed", "stale-preview"]>;
+/**
+ * Runtime-only carrier for JSX source metadata. It is global so separately
+ * bundled `jsx-dev-runtime` and `render-template` entries still agree on the
+ * sidecar key, and it is a Symbol so it cannot enter SML, HTML, or JSON.
+ */
+declare const JSX_SOURCE_LOCATION: unique symbol;
+/** Internal JSX prop used only by an editor preview source transform. */
+declare const JSX_SOURCE_LOCATION_PROP: "__samva_source_location";
+/**
+ * A source map is useful only when it is trustworthy. Production `jsx`/`jsxs`
+ * currently provide no source metadata, so that path reports a typed absence
+ * rather than guessing from output order.
+ */
+type SourceLocationUnavailableReason = typeof SourceLocationUnavailableReason.Type;
+type UnboundTemplateSourceLocations = {
+  readonly kind: "available";
+  /** Parsed SML node id → the JSX origin that produced that element. */
+  readonly byNodeId: Readonly<Record<string, JsxSourceLocation>>;
+} | {
+  readonly kind: "unavailable";
+  readonly reason: SourceLocationUnavailableReason;
+};
+/** Revision-fenced source map exposed by a mutable workspace preview. */
+type TemplateSourceLocations = {
+  readonly kind: "available";
+  readonly revision: string;
+  /** Parsed SML node id → the JSX origin that produced that element. */
+  readonly byNodeId: Readonly<Record<string, JsxSourceLocation>>;
+} | {
+  readonly kind: "unavailable";
+  readonly reason: SourceLocationUnavailableReason;
+};
+/** JSON-safe schema for a parsed-node-id → JSX-origin map. */
+declare const TemplateSourceLocationsSchema: Schema.Union<readonly [Schema.Struct<{
+  readonly kind: Schema.Literal<"available">;
+  readonly revision: Schema.String;
+  readonly byNodeId: Schema.$Record<Schema.String, Schema.Struct<{
+    readonly fileName: Schema.String;
+    readonly lineNumber: Schema.Int;
+    readonly columnNumber: Schema.Int;
+  }>>;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"unavailable">;
+  readonly reason: Schema.Literals<readonly ["no-source-metadata", "structure-mismatch", "duplicate-source-origin", "render-failed", "stale-preview"]>;
+}>]>;
+/** Normalize the optional payload accepted by `jsxDEV`. */
+declare const completeJsxSourceLocation: (source: JsxSource | null | undefined) => JsxSourceLocation | undefined;
+/** Attach a source origin without changing the serialized draft shape. */
+declare const attachJsxSourceLocation: (node: ElementNode, source: JsxSourceLocation) => void;
+/** Read the ephemeral origin, if this draft element has one. */
+declare const jsxSourceLocationOf: (node: SmlNode) => JsxSourceLocation | undefined;
+/**
+ * Pair a draft tree with its parsed SML tree by element preorder. Text nodes
+ * are intentionally ignored: the SML parser normalizes inline whitespace, so
+ * only the element structure is stable enough to be a source-map contract.
+ */
+declare const mapJsxSourceLocations: (draft: ElementNode, parsed: ElementNode) => UnboundTemplateSourceLocations;
+/** Compare source-map statuses for the emission determinism guard. */
+declare const sameTemplateSourceLocations: (left: UnboundTemplateSourceLocations, right: UnboundTemplateSourceLocations) => boolean;
+//#endregion
+export { SourceLocationUnavailableReason as a, UnboundTemplateSourceLocations as c, jsxSourceLocationOf as d, mapJsxSourceLocations as f, JsxSourceLocation as i, attachJsxSourceLocation as l, JSX_SOURCE_LOCATION_PROP as n, TemplateSourceLocations as o, sameTemplateSourceLocations as p, JsxSource as r, TemplateSourceLocationsSchema as s, JSX_SOURCE_LOCATION as t, completeJsxSourceLocation as u };
+//# sourceMappingURL=source-locations-BCJQnIfU.d.ts.map

package/dist/source-locations.d.ts

@@ -0,0 +1,2 @@
+import { a as SourceLocationUnavailableReason, c as UnboundTemplateSourceLocations, d as jsxSourceLocationOf, f as mapJsxSourceLocations, i as JsxSourceLocation, l as attachJsxSourceLocation, n as JSX_SOURCE_LOCATION_PROP, o as TemplateSourceLocations, p as sameTemplateSourceLocations, r as JsxSource, s as TemplateSourceLocationsSchema, t as JSX_SOURCE_LOCATION, u as completeJsxSourceLocation } from "./source-locations-BCJQnIfU.js";
+export { JSX_SOURCE_LOCATION, JSX_SOURCE_LOCATION_PROP, JsxSource, JsxSourceLocation, SourceLocationUnavailableReason, TemplateSourceLocations, TemplateSourceLocationsSchema, UnboundTemplateSourceLocations, attachJsxSourceLocation, completeJsxSourceLocation, jsxSourceLocationOf, mapJsxSourceLocations, sameTemplateSourceLocations };