@samva/markup 0.8.0 → 0.9.0

package/dist/sms-segments.d.ts

@@ -1,2 +1,13 @@
-import { i as smsSegmentInfo, n as SmsSegmentInfo, r as hasSmsOptOut, t as SmsEncoding } from "./sms-segments-y4FpPilJ.js";
-export { SmsEncoding, SmsSegmentInfo, hasSmsOptOut, smsSegmentInfo };
+//#region src/sms-segments.d.ts
+/** The encoding a message needs: GSM-7 when every character fits, UCS-2 otherwise. */
+type SmsEncoding = "gsm7" | "ucs2";
+interface SmsSegmentInfo {
+  readonly encoding: SmsEncoding;
+  readonly characterCount: number;
+  readonly segmentCount: number;
+}
+declare const smsSegmentInfo: (text: string) => SmsSegmentInfo;
+declare const hasSmsOptOut: (text: string) => boolean;
+//#endregion
+export { SmsEncoding, SmsSegmentInfo, hasSmsOptOut, smsSegmentInfo };
+//# sourceMappingURL=sms-segments.d.ts.map

package/dist/sms.d.ts

@@ -0,0 +1,16 @@
+import { t as SmsCategory } from "./channel-specs-C2feJwuP.js";
+import { f as EmailChild, m as EmailNode } from "./elements-cqldpaJt.js";
+//#region src/sms.d.ts
+interface SmsProps {
+  readonly category?: SmsCategory | undefined;
+  readonly children?: EmailChild;
+}
+/**
+ * The root of an SMS body: plain text with bindings, conditionals and formatters. The compiler
+ * reads it from source; executed, it is a fragment of its children so a template file that also
+ * declares an email body still evaluates.
+ */
+declare const Sms: (props: SmsProps) => EmailNode;
+//#endregion
+export { Sms, type SmsCategory, SmsProps };
+//# sourceMappingURL=sms.d.ts.map

package/dist/sms.js

@@ -0,0 +1,12 @@
+import { Fragment, jsx } from "./email/jsx-runtime.js";
+//#region src/sms.ts
+/**
+* The root of an SMS body: plain text with bindings, conditionals and formatters. The compiler
+* reads it from source; executed, it is a fragment of its children so a template file that also
+* declares an email body still evaluates.
+*/
+const Sms = (props) => jsx(Fragment, { children: props.children });
+//#endregion
+export { Sms };
+
+//# sourceMappingURL=sms.js.map

package/dist/{email/source-edit.d.ts → source-edit.d.ts}

@@ -1,5 +1,5 @@
-import { i as JsxSourceLocation } from "../source-locations-DrCM82Ym.js";
-//#region src/email/source-edit.d.ts
+import { r as JsxSourceLocation } from "./source-locations-C8wCsiAy.js";
+//#region src/source-edit.d.ts
 /** One exact source replacement; before text guards against concurrent changes. */
 interface SourceReplacement {
   readonly start: number;
@@ -33,6 +33,13 @@ interface SourceElement {
   readonly hasSpread: boolean;
   readonly properties: readonly SourceProperty[];
   readonly structural: boolean;
+  /** The JSX element sibling directly before / after this one, when both share a JSX parent. */
+  readonly previous: SourceRange | null;
+  readonly next: SourceRange | null;
+}
+interface SourceRange {
+  readonly start: number;
+  readonly end: number;
 }
 /** Resolve a renderer origin against the unchanged authored entry, never against HTML offsets. */
 declare const inspectSourceElement: (source: string, file: string, origin: JsxSourceLocation) => SourceElement | null;
@@ -40,11 +47,39 @@ declare const inspectSourceElement: (source: string, file: string, origin: JsxSo
 declare const literalReplacement: (source: string, field: SourceProperty, value: string) => SourceReplacement | null;
 /** Explicit expression changes are proposals: callers show before/after and require Apply. */
 declare const expressionReplacement: (source: string, field: SourceProperty, expression: string) => SourceReplacement;
+/**
+ * Where an edited file sits in its template project. Every edit of a template is checked against
+ * the static profile: one that would leave it is refused, so a visual edit can never produce a
+ * template the compiler rejects.
+ */
+interface ProfileGuard {
+  /** The template entry the profile check reads. */
+  readonly entry: string;
+  /** The file the edit changes; the entry when omitted. A partial names itself here. */
+  readonly file?: string | undefined;
+  /** The project's other files, when the edited file is not the entry. */
+  readonly files?: Readonly<Record<string, string>> | undefined;
+}
+interface ApplyOptions {
+  readonly profile?: ProfileGuard | undefined;
+}
 /** Apply exact, nonoverlapping edits and refuse syntax damage without changing the original. */
-declare const applySourceReplacements: (source: string, edits: readonly SourceReplacement[]) => SourceEditResult;
+declare const applySourceReplacements: (source: string, edits: readonly SourceReplacement[], options?: ApplyOptions) => SourceEditResult;
+type SourceProposal = {
+  readonly ok: true;
+  readonly edits: readonly SourceReplacement[];
+} | {
+  readonly ok: false;
+  readonly reason: string;
+};
 /** Structural edits name a whole authored block; loop iterations are never source nodes. */
 declare const structuralReplacements: (source: string, element: SourceElement, operation: {
   readonly kind: "delete";
+} | {
+  readonly kind: "duplicate";
+} | {
+  readonly kind: "reorder";
+  readonly direction: "before" | "after";
 } | {
   readonly kind: "insert";
   readonly tsx: string;
@@ -60,8 +95,22 @@ interface SourceFixture {
 }
 /** Declared fixture values are separate source targets from body bindings and literals. */
 declare const inspectSourceFixtures: (source: string) => readonly SourceFixture[];
-/** Adding a style literal is unambiguous only when no spread can supply that property. */
-declare const addStyleClasses: (element: SourceElement, value: string) => SourceReplacement | null;
+type ClassNameOperation = {
+  readonly kind: "set";
+  readonly value: string;
+} | {
+  readonly kind: "add";
+  readonly tokens: string;
+} | {
+  readonly kind: "remove";
+  readonly tokens: string;
+};
+/**
+ * Edit an element's class list where it is written. A literal `className` is replaced, extended or
+ * trimmed in place; a missing one is added; one that is a condition or any other expression is
+ * refused, because rewriting it would discard the choice the author encoded.
+ */
+declare const classNameEdit: (source: string, element: SourceElement, operation: ClassNameOperation) => SourceProposal;
 //#endregion
-export { SourceEditResult, SourceElement, SourceFixture, SourceProperty, SourceReplacement, addStyleClasses, applySourceReplacements, expressionReplacement, inspectSourceElement, inspectSourceFixtures, literalReplacement, structuralReplacements };
+export { ApplyOptions, ClassNameOperation, ProfileGuard, SourceEditResult, SourceElement, SourceFixture, SourceProperty, SourceProposal, SourceRange, SourceReplacement, applySourceReplacements, classNameEdit, expressionReplacement, inspectSourceElement, inspectSourceFixtures, literalReplacement, structuralReplacements };
 //# sourceMappingURL=source-edit.d.ts.map

package/dist/source-edit.js

@@ -0,0 +1,343 @@
+import { n as isObject } from "./guards-eV1qLbf2.js";
+import { buildLineMap } from "./diagnostics.js";
+import { n as introducedProfileErrors, t as checkStaticProfile } from "./profile-BH-OtdDA.js";
+import { parse } from "@babel/parser";
+//#region src/source-edit.ts
+const node = (value) => isObject(value) && "type" in value && typeof value.type === "string" && "start" in value && typeof value.start === "number" && "end" in value && typeof value.end === "number";
+const children = (value) => Array.isArray(value) ? value.filter(node) : [];
+const walk = (value, visit, parent = null) => {
+	if (Array.isArray(value)) {
+		for (const item of value) walk(item, visit, parent);
+		return;
+	}
+	if (!node(value)) return;
+	visit(value, parent);
+	for (const [key, child] of Object.entries(value)) if (key !== "loc" && key !== "extra" && key !== "comments") walk(child, visit, value);
+};
+const parsed = (source) => {
+	try {
+		const result = parse(source, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"]
+		});
+		return node(result) ? result : null;
+	} catch {
+		return null;
+	}
+};
+const binding = (value) => value.type === "Identifier" || value.type === "MemberExpression" && value.computed === false && node(value.object) && binding(value.object);
+/** JSX trims each line of text and joins the non-empty lines with one space. */
+const collapseJsxText = (value) => value.split(/\r\n|\n|\r|\u2028|\u2029/).map((line) => line.trim()).filter((line) => line !== "").join(" ");
+const property = (name, value, source, syntax) => {
+	const expression = value.type === "JSXExpressionContainer" && node(value.expression) ? value.expression : value;
+	const literal = expression.type === "StringLiteral" || expression.type === "NumericLiteral" || expression.type === "BooleanLiteral" || expression.type === "JSXText";
+	const raw = source.slice(expression.start, expression.end);
+	const inset = expression.type === "JSXText" ? {
+		start: expression.start + (raw.length - raw.trimStart().length),
+		end: expression.end - (raw.length - raw.trimEnd().length)
+	} : {
+		start: value.start,
+		end: value.end
+	};
+	return {
+		name,
+		literalType: expression.type === "NumericLiteral" ? "number" : expression.type === "BooleanLiteral" ? "boolean" : "string",
+		kind: literal ? "literal" : binding(expression) ? "binding" : "computed",
+		value: literal && expression.type === "JSXText" && typeof expression.value === "string" ? collapseJsxText(expression.value) : literal && (typeof expression.value === "string" || typeof expression.value === "number" || typeof expression.value === "boolean") ? String(expression.value) : source.slice(expression.start, expression.end),
+		start: inset.start,
+		end: inset.end,
+		syntax
+	};
+};
+/** The JSX elements directly before and after `element` in its parent's child list. */
+const siblingsOf = (element, parent, source) => {
+	if (parent?.type !== "JSXElement" && parent?.type !== "JSXFragment") return {
+		previous: null,
+		next: null
+	};
+	const list = children(parent.children).filter((child) => child.type !== "JSXText" || source.slice(child.start, child.end).trim() !== "");
+	const index = list.findIndex((child) => child.start === element.start);
+	const range = (child) => child?.type === "JSXElement" ? {
+		start: child.start,
+		end: child.end
+	} : null;
+	return {
+		previous: range(list[index - 1]),
+		next: range(list[index + 1])
+	};
+};
+/** Resolve a renderer origin against the unchanged authored entry, never against HTML offsets. */
+const inspectSourceElement = (source, file, origin) => {
+	if (file !== origin.fileName) return null;
+	const tree = parsed(source);
+	if (tree === null) return null;
+	const lines = buildLineMap(source);
+	const lineStart = lines[origin.lineNumber - 1];
+	if (lineStart === void 0 || !Number.isInteger(origin.columnNumber) || origin.columnNumber < 1) return null;
+	const offset = lineStart + origin.columnNumber - 1;
+	if (offset >= (lines[origin.lineNumber] ?? source.length)) return null;
+	let found = null;
+	walk(tree, (element, parent) => {
+		if (element.type !== "JSXElement" || element.start !== offset || !node(element.openingElement)) return;
+		const opening = element.openingElement;
+		const properties = [];
+		for (const attribute of children(opening.attributes)) if (attribute.type === "JSXAttribute" && node(attribute.name) && typeof attribute.name.name === "string" && node(attribute.value)) {
+			const value = attribute.value;
+			const expression = value.type === "JSXExpressionContainer" && node(value.expression) ? value.expression : null;
+			if (attribute.name.name === "style" && expression?.type === "ObjectExpression" && !children(expression.properties).some((member) => member.type === "SpreadElement")) for (const member of children(expression.properties)) {
+				if (member.type !== "ObjectProperty" || member.computed === true || !node(member.key) || !node(member.value)) continue;
+				const key = member.key.type === "Identifier" ? member.key.name : member.key.value;
+				if (typeof key === "string") properties.push(property(`style.${key}`, member.value, source, "value"));
+			}
+			else properties.push(property(attribute.name.name, value, source, "attribute"));
+		}
+		const meaningful = children(element.children).filter((child) => child.type !== "JSXText" || source.slice(child.start, child.end).trim() !== "");
+		if (meaningful.length === 1 && meaningful[0] !== void 0 && meaningful[0].type !== "JSXElement" && meaningful[0].type !== "JSXFragment") properties.unshift(property("children", meaningful[0], source, "child"));
+		else if (meaningful.length > 1) {
+			const texts = meaningful.flatMap((child, index) => child.type === "JSXText" ? [property(`text.${index}`, child, source, "child")] : []);
+			properties.unshift(...texts);
+		}
+		found = {
+			start: element.start,
+			end: element.end,
+			contentStart: opening.selfClosing === true ? null : opening.end,
+			contentEnd: node(element.closingElement) ? element.closingElement.start : null,
+			tag: node(opening.name) ? source.slice(opening.name.start, opening.name.end) : "element",
+			properties,
+			attributeInsertion: (() => {
+				const last = children(opening.attributes).at(-1);
+				if (last !== void 0) return last.end;
+				return node(opening.name) ? opening.name.end : opening.end - 1;
+			})(),
+			hasSpread: children(opening.attributes).some((attribute) => attribute.type === "JSXSpreadAttribute"),
+			structural: parent?.type === "JSXElement" || parent?.type === "JSXFragment",
+			...siblingsOf(element, parent, source)
+		};
+	});
+	return found;
+};
+const PLAIN_JSX_TEXT = /^[^\s{}<>&](?:[^{}<>&\r\n\u2028\u2029]*[^\s{}<>&])?$/;
+/** Literal controls cannot overwrite a binding or computed expression. */
+const literalReplacement = (source, field, value) => {
+	if (field.kind !== "literal") return null;
+	if (field.literalType === "number" && (value.trim() === "" || !Number.isFinite(Number(value)))) return null;
+	if (field.literalType === "boolean" && value !== "true" && value !== "false") return null;
+	const literal = field.literalType === "string" ? JSON.stringify(value) : field.literalType === "number" ? String(Number(value)) : value;
+	const before = source.slice(field.start, field.end);
+	const plainText = field.syntax === "child" && !before.startsWith("{") && PLAIN_JSX_TEXT.test(value);
+	return {
+		start: field.start,
+		end: field.end,
+		before,
+		after: plainText ? value : field.syntax === "child" || field.syntax === "attribute" && field.literalType !== "string" ? `{${literal}}` : literal
+	};
+};
+/** Explicit expression changes are proposals: callers show before/after and require Apply. */
+const expressionReplacement = (source, field, expression) => ({
+	start: field.start,
+	end: field.end,
+	before: source.slice(field.start, field.end),
+	after: field.syntax === "value" ? expression : `{${expression}}`
+});
+const profileRefusal = (source, result, guard) => {
+	const file = guard.file ?? guard.entry;
+	const project = (content) => ({
+		...guard.files,
+		[file]: content
+	});
+	const introduced = introducedProfileErrors(checkStaticProfile(project(source), guard.entry), checkStaticProfile(project(result), guard.entry));
+	const first = introduced[0];
+	if (first === void 0) return null;
+	const more = introduced.length > 1 ? ` (and ${introduced.length - 1} more)` : "";
+	return `This change leaves the static profile: ${first.message}${first.fix === void 0 ? "" : ` ${first.fix}`}${more}`;
+};
+/** Apply exact, nonoverlapping edits and refuse syntax damage without changing the original. */
+const applySourceReplacements = (source, edits, options = {}) => {
+	const sorted = [...edits].sort((a, b) => b.start - a.start);
+	let boundary = source.length;
+	let result = source;
+	for (const edit of sorted) {
+		if (edit.start < 0 || edit.end < edit.start || edit.end > boundary || source.slice(edit.start, edit.end) !== edit.before) return {
+			ok: false,
+			reason: "Source changed at this target. Select it again before applying the edit."
+		};
+		result = result.slice(0, edit.start) + edit.after + result.slice(edit.end);
+		boundary = edit.start;
+	}
+	if (parsed(result) === null) return {
+		ok: false,
+		reason: "This change is not valid TSX. Review it in Source."
+	};
+	if (options.profile !== void 0 && result !== source) {
+		const refusal = profileRefusal(source, result, options.profile);
+		if (refusal !== null) return {
+			ok: false,
+			reason: refusal
+		};
+	}
+	return {
+		ok: true,
+		source: result
+	};
+};
+const indentation = (source, offset) => {
+	const lineStart = Math.max(source.lastIndexOf("\n", offset - 1), source.lastIndexOf("\r", offset - 1));
+	const lead = source.slice(lineStart + 1, offset);
+	return /^[ \t]*$/.test(lead) ? lead : null;
+};
+/** The whole lines an element alone occupies, so removing it leaves no blank line behind. */
+const ownLines = (source, element) => {
+	if (indentation(source, element.start) === null) return element;
+	const trailing = /^[ \t]*(\r\n|\n|\r)/.exec(source.slice(element.end));
+	if (trailing === null) return element;
+	return {
+		start: element.start - (indentation(source, element.start) ?? "").length,
+		end: element.end + trailing[0].length
+	};
+};
+/** Structural edits name a whole authored block; loop iterations are never source nodes. */
+const structuralReplacements = (source, element, operation) => {
+	if (operation.kind === "insert") {
+		if (element.contentEnd === null) return null;
+		return [{
+			start: element.contentEnd,
+			end: element.contentEnd,
+			before: "",
+			after: operation.tsx
+		}];
+	}
+	if (!element.structural) return null;
+	const text = source.slice(element.start, element.end);
+	if (operation.kind === "duplicate") {
+		const indent = indentation(source, element.start);
+		return [{
+			start: element.end,
+			end: element.end,
+			before: "",
+			after: indent === null ? text : `\n${indent}${text}`
+		}];
+	}
+	if (operation.kind === "reorder") {
+		const neighbour = operation.direction === "before" ? element.previous : element.next;
+		if (neighbour === null) return null;
+		return [{
+			start: neighbour.start,
+			end: neighbour.end,
+			before: source.slice(neighbour.start, neighbour.end),
+			after: text
+		}, {
+			start: element.start,
+			end: element.end,
+			before: text,
+			after: source.slice(neighbour.start, neighbour.end)
+		}];
+	}
+	const removal = ownLines(source, element);
+	const removed = {
+		start: removal.start,
+		end: removal.end,
+		before: source.slice(removal.start, removal.end),
+		after: ""
+	};
+	if (operation.kind === "delete") return [removed];
+	const destination = operation.destination.contentEnd;
+	if (destination === null || destination >= element.start && destination <= element.end) return null;
+	return [removed, {
+		start: destination,
+		end: destination,
+		before: "",
+		after: text
+	}];
+};
+/** The object literal a top-level `const name = { ... }` holds. */
+const topLevelObject = (tree, name) => {
+	const program = tree.program;
+	if (!node(program)) return null;
+	for (const item of children(program.body)) {
+		const declaration = item.type === "ExportNamedDeclaration" && node(item.declaration) ? item.declaration : item;
+		if (declaration.type !== "VariableDeclaration") continue;
+		for (const declarator of children(declaration.declarations)) if (node(declarator.id) && declarator.id.name === name && node(declarator.init) && declarator.init.type === "ObjectExpression") return declarator.init;
+	}
+	return null;
+};
+/** Declared fixture values are separate source targets from body bindings and literals. */
+const inspectSourceFixtures = (source) => {
+	const tree = parsed(source);
+	if (tree === null) return [];
+	const found = [];
+	walk(tree, (call) => {
+		if (call.type !== "CallExpression" || !node(call.callee) || call.callee.type !== "Identifier" || call.callee.name !== "defineTemplate") return;
+		const definition = children(call.arguments)[0];
+		if (definition?.type !== "ObjectExpression") return;
+		const fixtures = children(definition.properties).find((field) => field.type === "ObjectProperty" && node(field.key) && field.key.name === "fixtures" && field.computed !== true);
+		if (fixtures === void 0 || !node(fixtures.value) || fixtures.value.type !== "ObjectExpression") return;
+		for (const field of children(fixtures.value.properties)) {
+			if (field.type !== "ObjectProperty" || field.computed === true || !node(field.key) || !node(field.value)) continue;
+			const name = field.key.type === "Identifier" ? field.key.name : field.key.value;
+			const value = field.value.type === "Identifier" && typeof field.value.name === "string" ? topLevelObject(tree, field.value.name) ?? field.value : field.value;
+			if (typeof name === "string") found.push({
+				name,
+				start: value.start,
+				end: value.end,
+				source: source.slice(value.start, value.end)
+			});
+		}
+	});
+	return found;
+};
+const tokens = (value) => value.split(/\s+/).filter((item) => item !== "");
+/**
+* Edit an element's class list where it is written. A literal `className` is replaced, extended or
+* trimmed in place; a missing one is added; one that is a condition or any other expression is
+* refused, because rewriting it would discard the choice the author encoded.
+*/
+const classNameEdit = (source, element, operation) => {
+	const field = element.properties.find((item) => item.name === "className");
+	const next = (current) => {
+		if (operation.kind === "set") return tokens(operation.value).join(" ");
+		const wanted = tokens(operation.tokens);
+		return operation.kind === "add" ? [...current, ...wanted.filter((item) => !current.includes(item))].join(" ") : current.filter((item) => !wanted.includes(item)).join(" ");
+	};
+	if (field === void 0) {
+		if (element.hasSpread) return {
+			ok: false,
+			reason: "A spread attribute can supply className here, so a class list cannot be added safely. Edit it in Source."
+		};
+		if (operation.kind === "remove") return {
+			ok: true,
+			edits: []
+		};
+		const value = next([]);
+		if (value === "") return {
+			ok: true,
+			edits: []
+		};
+		return {
+			ok: true,
+			edits: [{
+				start: element.attributeInsertion,
+				end: element.attributeInsertion,
+				before: "",
+				after: ` className=${JSON.stringify(value)}`
+			}]
+		};
+	}
+	if (field.kind !== "literal" || field.literalType !== "string") return {
+		ok: false,
+		reason: `className is ${field.kind === "binding" ? "bound to" : "computed from"} \`${field.value}\`, so editing it would discard that choice. Change the literal classes inside it in Source.`
+	};
+	const value = next(tokens(field.value));
+	return {
+		ok: true,
+		edits: [{
+			start: field.start,
+			end: field.end,
+			before: source.slice(field.start, field.end),
+			after: JSON.stringify(value)
+		}]
+	};
+};
+//#endregion
+export { applySourceReplacements, classNameEdit, expressionReplacement, inspectSourceElement, inspectSourceFixtures, literalReplacement, structuralReplacements };
+
+//# sourceMappingURL=source-edit.js.map

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

@@ -0,0 +1,23 @@
+//#region src/source-locations.d.ts
+/**
+ * The source payload a JSX transform may attach to an element. 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;
+}
+/** The JSX prop that carries a {@link JsxSource} to the email JSX runtime. */
+declare const JSX_SOURCE_LOCATION_PROP: "__samva_source_location";
+/** Normalize the optional payload a JSX transform attaches. */
+declare const completeJsxSourceLocation: (source: JsxSource | null | undefined) => JsxSourceLocation | undefined;
+//#endregion
+export { completeJsxSourceLocation as i, JsxSource as n, JsxSourceLocation as r, JSX_SOURCE_LOCATION_PROP as t };
+//# sourceMappingURL=source-locations-C8wCsiAy.d.ts.map

package/dist/source-locations.d.ts

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

package/dist/source-locations.js

@@ -1,14 +1,7 @@
-import { t as hasProperty } from "./guards-eV1qLbf2.js";
 //#region src/source-locations.ts
-/**
-* 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.
-*/
-const JSX_SOURCE_LOCATION = Symbol.for("@samva/markup/jsx-source-location");
-/** Internal JSX prop used only by an editor preview source transform. */
+/** The JSX prop that carries a {@link JsxSource} to the email JSX runtime. */
 const JSX_SOURCE_LOCATION_PROP = "__samva_source_location";
-/** Normalize the optional payload accepted by `jsxDEV`. */
+/** Normalize the optional payload a JSX transform attaches. */
 const completeJsxSourceLocation = (source) => {
 	if (source?.fileName === void 0 || source.lineNumber === void 0 || source.columnNumber === void 0) return;
 	return Object.freeze({
@@ -17,86 +10,7 @@ const completeJsxSourceLocation = (source) => {
 		columnNumber: source.columnNumber
 	});
 };
-/** Attach a source origin without changing the serialized draft shape. */
-const attachJsxSourceLocation = (node, source) => {
-	if (Object.hasOwn(node, JSX_SOURCE_LOCATION)) return;
-	Object.defineProperty(node, JSX_SOURCE_LOCATION, {
-		configurable: false,
-		enumerable: false,
-		value: source,
-		writable: false
-	});
-};
-const isJsxSourceLocation = (value) => hasProperty(value, "fileName") && typeof value.fileName === "string" && hasProperty(value, "lineNumber") && typeof value.lineNumber === "number" && Number.isInteger(value.lineNumber) && hasProperty(value, "columnNumber") && typeof value.columnNumber === "number" && Number.isInteger(value.columnNumber);
-/** Read the ephemeral origin, if this draft element has one. */
-const jsxSourceLocationOf = (node) => {
-	if (node.kind !== "element") return void 0;
-	const value = Object.getOwnPropertyDescriptor(node, JSX_SOURCE_LOCATION)?.value;
-	return isJsxSourceLocation(value) ? value : void 0;
-};
-const elementChildren = (node) => node.children.filter((child) => child.kind === "element");
-const sourceOriginKey = (source) => JSON.stringify([
-	source.fileName,
-	source.lineNumber,
-	source.columnNumber
-]);
-/**
-* 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.
-*/
-const mapJsxSourceLocations = (draft, parsed) => {
-	const byNodeId = {};
-	const origins = /* @__PURE__ */ new Set();
-	let duplicateOrigin = false;
-	const visit = (draftNode, parsedNode) => {
-		if (draftNode.tag !== parsedNode.tag) return false;
-		const source = jsxSourceLocationOf(draftNode);
-		if (source !== void 0) {
-			const origin = sourceOriginKey(source);
-			if (origins.has(origin)) duplicateOrigin = true;
-			origins.add(origin);
-			if (Object.hasOwn(byNodeId, parsedNode.id)) return false;
-			byNodeId[parsedNode.id] = source;
-		}
-		const draftChildren = elementChildren(draftNode);
-		const parsedChildren = elementChildren(parsedNode);
-		if (draftChildren.length !== parsedChildren.length) return false;
-		for (let index = 0; index < draftChildren.length; index++) if (!visit(draftChildren[index], parsedChildren[index])) return false;
-		return true;
-	};
-	if (!visit(draft, parsed)) return {
-		kind: "unavailable",
-		reason: "structure-mismatch"
-	};
-	if (duplicateOrigin) return {
-		kind: "unavailable",
-		reason: "duplicate-source-origin"
-	};
-	if (Object.keys(byNodeId).length === 0) return {
-		kind: "unavailable",
-		reason: "no-source-metadata"
-	};
-	return {
-		kind: "available",
-		byNodeId: Object.freeze(byNodeId)
-	};
-};
-/** Compare source-map statuses for the emission determinism guard. */
-const sameTemplateSourceLocations = (left, right) => {
-	if (left.kind !== right.kind) return false;
-	if (left.kind === "unavailable") return right.kind === "unavailable" && left.reason === right.reason;
-	if (right.kind === "unavailable") return false;
-	const leftEntries = Object.entries(left.byNodeId);
-	const rightEntries = Object.entries(right.byNodeId);
-	if (leftEntries.length !== rightEntries.length) return false;
-	for (const [nodeId, source] of leftEntries) {
-		const other = right.byNodeId[nodeId];
-		if (other === void 0 || other.fileName !== source.fileName || other.lineNumber !== source.lineNumber || other.columnNumber !== source.columnNumber) return false;
-	}
-	return true;
-};
 //#endregion
-export { JSX_SOURCE_LOCATION, JSX_SOURCE_LOCATION_PROP, attachJsxSourceLocation, completeJsxSourceLocation, jsxSourceLocationOf, mapJsxSourceLocations, sameTemplateSourceLocations };
+export { JSX_SOURCE_LOCATION_PROP, completeJsxSourceLocation };
 
 //# sourceMappingURL=source-locations.js.map