@templatical/import-easy-email-pro 0.36.0

package/dist/index.js

@@ -0,0 +1,1330 @@
+import { DEFAULT_TEMPLATE_DEFAULTS, createButtonBlock, createDefaultTemplateContent, createDividerBlock, createHtmlBlock, createImageBlock, createMenuBlock, createParagraphBlock, createSectionBlock, createSocialIconsBlock, createSpacerBlock, createTableBlock, createTitleBlock, createVideoBlock, findOpenTagEnd, generateId } from "@templatical/types";
+//#region src/normalize.ts
+const VAR_PREFIX = "$var(";
+/** Spec §3.3 category map — unknown types skip the category layer. */
+const CATEGORY_BY_TYPE = {
+	"standard-paragraph": "TEXT",
+	"standard-h1": "TEXT",
+	"standard-h2": "TEXT",
+	"standard-h3": "TEXT",
+	"standard-h4": "TEXT",
+	"standard-button": "BUTTON",
+	"standard-image": "IMAGE",
+	"standard-navbar": "NAVBAR",
+	"standard-navbar-link": "NAVBAR",
+	"standard-social": "SOCIAL",
+	"standard-social-element": "SOCIAL",
+	"standard-spacer": "SPACER",
+	"standard-divider": "DIVIDER",
+	"standard-hero": "HERO",
+	"standard-wrapper": "WRAPPER",
+	"standard-section": "SECTION",
+	"standard-column": "COLUMN",
+	"standard-group": "GROUP"
+};
+/**
+* `null`, `""`, `"url()"`, `"transparent"`, and leftover `$var(` after
+* substitution are unset. Presence-guards that treat these as set write
+* illegal empties.
+*/
+function isUnset(value) {
+	if (value === null || value === void 0) return true;
+	if (typeof value !== "string") return false;
+	const trimmed = value.trim();
+	return trimmed === "" || trimmed === "url()" || trimmed.toLowerCase() === "transparent" || trimmed.includes(VAR_PREFIX);
+}
+/** Index `data.variables[]` by name for `$var` lookup. */
+function buildVariableTable(variables) {
+	const out = {};
+	if (!variables) return out;
+	for (const entry of variables) {
+		if (typeof entry.name !== "string" || entry.name === "") continue;
+		if (typeof entry.value !== "string") continue;
+		out[entry.name] = entry.value;
+	}
+	return out;
+}
+/**
+* Replace `$var(name)` tokens via a linear scan (no regex — CodeQL
+* `js/polynomial-redos`). Unknown names are left in place and flagged.
+*/
+function substituteVars(value, variables) {
+	let out = "";
+	let i = 0;
+	let resolved = 0;
+	let unresolved = 0;
+	while (i < value.length) {
+		const start = value.indexOf(VAR_PREFIX, i);
+		if (start === -1) {
+			out += value.slice(i);
+			break;
+		}
+		out += value.slice(i, start);
+		const nameStart = start + 5;
+		const nameEnd = findMatchingParen(value, nameStart);
+		if (nameEnd === -1) {
+			out += value.slice(start);
+			unresolved += 1;
+			break;
+		}
+		const name = value.slice(nameStart, nameEnd);
+		if (Object.prototype.hasOwnProperty.call(variables, name)) {
+			out += variables[name];
+			resolved += 1;
+		} else {
+			out += value.slice(start, nameEnd + 1);
+			unresolved += 1;
+		}
+		i = nameEnd + 1;
+	}
+	return {
+		value: out,
+		resolved,
+		unresolved
+	};
+}
+/** Walk from `openIdx` (char after `(`) to the matching `)`. */
+function findMatchingParen(value, openIdx) {
+	let depth = 1;
+	for (let i = openIdx; i < value.length; i++) {
+		const ch = value[i];
+		if (ch === "(") depth += 1;
+		else if (ch === ")") {
+			depth -= 1;
+			if (depth === 0) return i;
+		}
+	}
+	return -1;
+}
+function contextFromPage(page) {
+	const data = isPlainObject$1(page.data) ? page.data : {};
+	return {
+		variables: buildVariableTable(Array.isArray(data.variables) ? data.variables : void 0),
+		blockAttributes: asNestedAttrMap(data.blockAttributes),
+		categoryAttributes: asNestedAttrMap(data.categoryAttributes),
+		globalAttributes: asAttrMap(data.globalAttributes),
+		page,
+		stats: {
+			resolved: 0,
+			unresolved: 0
+		},
+		attrCache: /* @__PURE__ */ new WeakMap()
+	};
+}
+/** Widget `data.input` overrides page variables for `$var` resolution. */
+function withWidgetInput(ctx, input) {
+	if (!input) return ctx;
+	const variables = { ...ctx.variables };
+	for (const [key, value] of Object.entries(input)) if (typeof value === "string") variables[key] = value;
+	return {
+		...ctx,
+		variables,
+		attrCache: /* @__PURE__ */ new WeakMap()
+	};
+}
+/**
+* Cascade: element → blockAttributes[type] → categoryAttributes[cat] →
+* globalAttributes. Missing keys fall through. String hits run through
+* `substituteVars`. Keys stay kebab-case MJML.
+*/
+function readAttr(node, key, ctx) {
+	let cached = ctx.attrCache.get(node);
+	if (cached?.has(key)) return cached.get(key);
+	const raw = lookupAttr(node, key, ctx);
+	let value = raw;
+	if (typeof raw === "string") {
+		const result = substituteVars(raw, ctx.variables);
+		ctx.stats.resolved += result.resolved;
+		ctx.stats.unresolved += result.unresolved;
+		value = result.value;
+	}
+	if (!cached) {
+		cached = /* @__PURE__ */ new Map();
+		ctx.attrCache.set(node, cached);
+	}
+	cached.set(key, value);
+	return value;
+}
+function lookupAttr(node, key, ctx) {
+	const fromElement = node.attributes?.[key];
+	if (fromElement !== void 0) return fromElement;
+	if (typeof node.type === "string") {
+		const fromBlock = ctx.blockAttributes[node.type]?.[key];
+		if (fromBlock !== void 0) return fromBlock;
+		const category = CATEGORY_BY_TYPE[node.type];
+		if (category) {
+			const fromCategory = ctx.categoryAttributes[category]?.[key];
+			if (fromCategory !== void 0) return fromCategory;
+		}
+	}
+	return ctx.globalAttributes[key];
+}
+/**
+* Envelope unwrap. Never throws — the converter owns invalid-shape errors.
+* Returns `{ page, subject }` when a page is visible; caller checks
+* `page.type === "page"`.
+*/
+function unwrapDocument(root) {
+	if (!isPlainObject$1(root)) return { page: {} };
+	if (root.type === "page") return { page: root };
+	const doc = root;
+	const page = isPlainObject$1(doc.content) ? doc.content : root;
+	const subject = typeof doc.subject === "string" ? doc.subject : void 0;
+	return subject === void 0 ? { page } : {
+		page,
+		subject
+	};
+}
+function isPlainObject$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asAttrMap(value) {
+	return isPlainObject$1(value) ? value : {};
+}
+function asNestedAttrMap(value) {
+	if (!isPlainObject$1(value)) return {};
+	const out = {};
+	for (const [key, entry] of Object.entries(value)) if (isPlainObject$1(entry)) out[key] = entry;
+	return out;
+}
+//#endregion
+//#region src/attribute-parser.ts
+/** Strip a trailing `px` (case-insensitive) and coerce to number. Unset/NaN → undefined. */
+function parsePx(value) {
+	if (isUnset(value)) return void 0;
+	let raw = String(value).trim();
+	if (raw.toLowerCase().endsWith("px")) raw = raw.slice(0, -2).trimEnd();
+	const n = Number(raw);
+	return Number.isNaN(n) ? void 0 : n;
+}
+/**
+* Strip a trailing `%` and coerce to number. Unset/NaN → `null` so
+* `matchColumnLayout` can tell "missing width" from `0%`.
+*/
+function parsePercent(value) {
+	if (isUnset(value)) return null;
+	let raw = String(value).trim();
+	if (raw.endsWith("%")) raw = raw.slice(0, -1).trimEnd();
+	const n = Number(raw);
+	return Number.isNaN(n) ? null : n;
+}
+/** Return the colour string as-is when set. No named-colour expansion. */
+function parseColor(value) {
+	if (isUnset(value)) return void 0;
+	if (typeof value !== "string") return void 0;
+	return value;
+}
+/** Read the four padding sides via a callback (typically wrapping `readAttr`). Missing → 0. */
+function readPadding(read) {
+	const side = (key) => parsePx(read(key)) ?? 0;
+	return {
+		top: side("padding-top"),
+		right: side("padding-right"),
+		bottom: side("padding-bottom"),
+		left: side("padding-left")
+	};
+}
+//#endregion
+//#region src/rich-text.ts
+/** Escape `& < > "` for text content and attribute values. */
+function escapeHtml(value) {
+	let out = "";
+	for (let i = 0; i < value.length; i++) {
+		const ch = value[i];
+		if (ch === "&") out += "&amp;";
+		else if (ch === "<") out += "&lt;";
+		else if (ch === ">") out += "&gt;";
+		else if (ch === "\"") out += "&quot;";
+		else out += ch;
+	}
+	return out;
+}
+function isTextNode(node) {
+	return typeof node.text === "string";
+}
+/**
+* Nesting (outer → inner): link → color/bgColor span → underline → strike →
+* em → strong. Matches the Task 4 brief / design §8.1 mark order.
+*/
+function serialiseTextNode(node) {
+	let html = escapeHtml(node.text);
+	if (node.bold) html = `<strong>${html}</strong>`;
+	if (node.italic) html = `<em>${html}</em>`;
+	if (node.strikethrough) html = `<s>${html}</s>`;
+	if (node.underline) html = `<u>${html}</u>`;
+	const styles = [];
+	if (typeof node.color === "string" && node.color !== "") styles.push(`color: ${escapeHtml(node.color)}`);
+	if (typeof node.bgColor === "string" && node.bgColor !== "") styles.push(`background-color: ${escapeHtml(node.bgColor)}`);
+	if (styles.length > 0) html = `<span style="${styles.join("; ")}">${html}</span>`;
+	if (node.link) html = `<a href="${escapeHtml(node.link.href ?? "")}"${node.link.blank === true ? " target=\"_blank\"" : ""}>${html}</a>`;
+	return html;
+}
+function serialiseNode(node) {
+	if (node.type === "line-break") return "<br>";
+	if (node.type === "html-block-node") {
+		const element = node;
+		const rawTag = element.data?.["tagName"];
+		const tagName = typeof rawTag === "string" && rawTag !== "" ? rawTag : "div";
+		return `<${tagName}>${serialiseChildren(element.children)}</${tagName}>`;
+	}
+	if (typeof node.type === "string" && node.type !== "") return "";
+	if (isTextNode(node)) return serialiseTextNode(node);
+	return "";
+}
+/** Slate children → HTML for TitleBlock / ParagraphBlock content. */
+function serialiseChildren(children) {
+	if (!children || children.length === 0) return "";
+	let out = "";
+	for (const child of children) out += serialiseNode(child);
+	return out;
+}
+//#endregion
+//#region src/block-mapper.ts
+const LEAF_TYPES = /* @__PURE__ */ new Set([
+	"standard-paragraph",
+	"standard-h1",
+	"standard-h2",
+	"standard-h3",
+	"standard-h4",
+	"standard-button",
+	"standard-image",
+	"standard-divider",
+	"standard-spacer",
+	"standard-navbar",
+	"standard-social",
+	"standard-table2",
+	"marketing-countdown",
+	"placeholder",
+	"common-video"
+]);
+const SOCIAL_PLATFORMS = [
+	"facebook",
+	"instagram",
+	"twitter",
+	"linkedin",
+	"youtube",
+	"tiktok",
+	"pinterest",
+	"whatsapp",
+	"telegram",
+	"github"
+];
+const ENTITIES = {
+	"&amp;": "&",
+	"&lt;": "<",
+	"&gt;": ">",
+	"&quot;": "\"",
+	"&#39;": "'",
+	"&apos;": "'",
+	"&nbsp;": " "
+};
+const COUNTDOWN_NOTE = "marketing-countdown GIF is the timer; Templatical countdown is Cloud-only";
+function isLeafType(type) {
+	if (typeof type !== "string") return false;
+	if (LEAF_TYPES.has(type)) return true;
+	return headingLevelFromType(type) !== null;
+}
+function convertLeaf(node, map) {
+	const type = node.type;
+	if (type === "placeholder") return empty$1();
+	if (type === "standard-paragraph") return convertParagraph(node, map);
+	const heading = typeof type === "string" ? headingLevelFromType(type) : null;
+	if (heading) return convertHeading(node, map, heading);
+	switch (type) {
+		case "standard-button": return convertButton(node, map);
+		case "standard-image": return convertImage(node, map);
+		case "standard-divider": return convertDivider(node, map);
+		case "standard-spacer": return convertSpacer(node, map);
+		case "standard-navbar": return convertNavbar(node, map);
+		case "standard-social": return convertSocial(node, map);
+		case "standard-table2": return convertTable(node, map);
+		case "marketing-countdown": return convertCountdown(node, map);
+		case "common-video": return convertVideo(node, map);
+		default: return convertUnknown(node, map);
+	}
+}
+function convertParagraph(node, map) {
+	return finish(createParagraphBlock({
+		content: paragraphHtml(node, map),
+		...leafStyles(node, map)
+	}), node, report("standard-paragraph", "paragraph", "converted"));
+}
+/**
+* ParagraphBlock has no color / fontSize / textAlign. Bake the cascaded
+* values into a wrapping `<p style>` (single wrapper, Unlayer/BeeFree class).
+*/
+function paragraphHtml(node, map) {
+	const html = serialiseChildren(node.children);
+	const parts = [];
+	const color = parseColor(readAttr(node, "color", map.resolve));
+	if (color) parts.push(`color: ${escapeAttr(color)}`);
+	const fontSize = setString(readAttr(node, "font-size", map.resolve));
+	if (fontSize) parts.push(`font-size: ${escapeAttr(fontSize)}`);
+	const align = parseAlign(readAttr(node, "align", map.resolve));
+	if (align) parts.push(`text-align: ${align}`);
+	if (parts.length === 0) return html;
+	return `<p style="${parts.join("; ")}">${html}</p>`;
+}
+function escapeAttr(value) {
+	let out = "";
+	for (let i = 0; i < value.length; i++) {
+		const ch = value[i];
+		if (ch === "&") out += "&amp;";
+		else if (ch === "<") out += "&lt;";
+		else if (ch === ">") out += "&gt;";
+		else if (ch === "\"") out += "&quot;";
+		else out += ch;
+	}
+	return out;
+}
+function convertHeading(node, map, heading) {
+	const color = parseColor(readAttr(node, "color", map.resolve));
+	const align = parseAlign(readAttr(node, "align", map.resolve));
+	const clamped = heading.source > 4;
+	return finish(createTitleBlock({
+		content: serialiseChildren(node.children),
+		level: heading.level,
+		...color ? { color } : {},
+		...align ? { textAlign: align } : {},
+		...leafStyles(node, map)
+	}), node, clamped ? report(node.type ?? "standard-h4", "title", "approximated", `Heading level h${heading.source} clamped to 4 — Templatical titles support h1-h4.`) : report(node.type ?? "standard-h1", "title", "converted"));
+}
+function convertButton(node, map) {
+	const fill = parseColor(readAttr(node, "background-color", map.resolve));
+	const textColor = parseColor(readAttr(node, "color", map.resolve));
+	const href = readAttr(node, "href", map.resolve);
+	const width = buttonWidth(readAttr(node, "width", map.resolve));
+	const align = parseAlign(readAttr(node, "align", map.resolve));
+	const outlined = isBorderEnabled(readAttr(node, "border-enabled", map.resolve)) && isUnset(readAttr(node, "background-color", map.resolve));
+	const block = createButtonBlock({
+		text: stripTags(serialiseChildren(node.children)),
+		url: setString(href) ?? "",
+		...fill ? { backgroundColor: fill } : {},
+		...textColor ? { textColor } : {},
+		...width !== void 0 ? { width } : {},
+		...align ? { align } : {},
+		...leafStyles(node, map)
+	});
+	if (outlined) block.backgroundColor = "#ffffff";
+	return finish(block, node, outlined ? report("standard-button", "button", "approximated", "outlined button has no Templatical equivalent") : report("standard-button", "button", "converted"));
+}
+function convertImage(node, map) {
+	const src = setString(readAttr(node, "src", map.resolve)) ?? "";
+	const alt = setString(readAttr(node, "alt", map.resolve)) ?? "";
+	const linkUrl = setString(readAttr(node, "href", map.resolve));
+	const radius = parsePx(readAttr(node, "border-radius", map.resolve));
+	const align = parseAlign(readAttr(node, "align", map.resolve));
+	const target = setString(readAttr(node, "target", map.resolve));
+	return finish(createImageBlock({
+		src,
+		alt,
+		...align ? { align } : {},
+		...radius !== void 0 && radius > 0 ? { borderRadius: radius } : {},
+		...linkUrl ? { linkUrl } : {},
+		...linkUrl && target === "_blank" ? { linkOpenInNewTab: true } : {},
+		...leafStyles(node, map)
+	}), node, report("standard-image", "image", "converted"));
+}
+function convertDivider(node, map) {
+	const color = parseColor(readAttr(node, "border-color", map.resolve));
+	const thickness = parsePx(readAttr(node, "border-width", map.resolve));
+	const lineStyle = asLineStyle(readAttr(node, "border-style", map.resolve));
+	return finish(createDividerBlock({
+		...color ? { color } : {},
+		...thickness !== void 0 ? { thickness } : {},
+		...lineStyle ? { lineStyle } : {},
+		...leafStyles(node, map)
+	}), node, report("standard-divider", "divider", "converted"));
+}
+function convertSpacer(node, map) {
+	const height = parsePx(readAttr(node, "height", map.resolve));
+	return finish(createSpacerBlock({
+		...height !== void 0 ? { height } : {},
+		...leafStyles(node, map)
+	}), node, report("standard-spacer", "spacer", "converted"));
+}
+function convertNavbar(node, map) {
+	const items = [];
+	for (const child of node.children ?? []) {
+		if (!isElement$2(child) || child.type !== "standard-navbar-link") continue;
+		const href = readAttr(child, "href", map.resolve);
+		const target = setString(readAttr(child, "target", map.resolve));
+		const color = parseColor(readAttr(child, "color", map.resolve));
+		const weight = setString(readAttr(child, "font-weight", map.resolve));
+		const deco = setString(readAttr(child, "text-decoration", map.resolve));
+		items.push({
+			id: generateId(),
+			text: stripTags(serialiseChildren(child.children)),
+			url: setString(href) ?? "",
+			openInNewTab: target === "_blank",
+			bold: weight === "bold" || weight === "700",
+			underline: deco !== void 0 && deco.includes("underline"),
+			...color ? { color } : {}
+		});
+	}
+	if (items.length === 0) return empty$1();
+	const align = parseAlign(readAttr(node, "align", map.resolve));
+	return finish(createMenuBlock({
+		items,
+		...align ? { textAlign: align } : {},
+		...leafStyles(node, map)
+	}), node, report("standard-navbar", "menu", "converted"));
+}
+function convertSocial(node, map) {
+	const icons = [];
+	let customSrc = false;
+	for (const child of node.children ?? []) {
+		if (!isElement$2(child) || child.type !== "standard-social-element") continue;
+		const href = readAttr(child, "href", map.resolve);
+		const src = readAttr(child, "src", map.resolve);
+		if (typeof src === "string" && !isUnset(src)) customSrc = true;
+		icons.push({
+			id: generateId(),
+			platform: inferPlatform(href, src),
+			url: setString(href) ?? ""
+		});
+	}
+	if (icons.length === 0) return empty$1();
+	const align = parseAlign(readAttr(node, "align", map.resolve));
+	return finish(createSocialIconsBlock({
+		icons,
+		...align ? { align } : {},
+		...leafStyles(node, map)
+	}), node, customSrc ? report("standard-social", "social", "approximated", "custom src was present; SocialIconsBlock has no custom PNG") : report("standard-social", "social", "converted"));
+}
+function convertTable(node, map) {
+	const rows = [];
+	let hasHeaderRow = false;
+	let first = true;
+	for (const row of collectRows(node)) {
+		const cells = [];
+		let rowHasTh = false;
+		for (const cell of row.children ?? []) {
+			if (!isElement$2(cell)) continue;
+			if (cell.type !== "td" && cell.type !== "th") continue;
+			if (cell.type === "th") rowHasTh = true;
+			cells.push({
+				id: generateId(),
+				content: serialiseChildren(cell.children)
+			});
+		}
+		if (cells.length === 0) continue;
+		if (first) {
+			hasHeaderRow = rowHasTh;
+			first = false;
+		}
+		rows.push({
+			id: generateId(),
+			cells
+		});
+	}
+	if (rows.length === 0) return empty$1();
+	const align = parseAlign(readAttr(node, "align", map.resolve));
+	const color = parseColor(readAttr(node, "color", map.resolve));
+	return finish(createTableBlock({
+		rows,
+		hasHeaderRow,
+		...align ? { textAlign: align } : {},
+		...color ? { color } : {},
+		...leafStyles(node, map)
+	}), node, report("standard-table2", "table", "converted"));
+}
+function convertCountdown(node, map) {
+	const blocks = [];
+	const entries = [];
+	for (const child of node.children ?? []) {
+		if (!isElement$2(child)) continue;
+		const remapped = remapOverlay(child);
+		if (!remapped) continue;
+		const inner = convertLeaf(remapped, map);
+		for (const block of inner.blocks) blocks.push(block);
+		for (const entry of inner.entries) entries.push({
+			sourceTag: "marketing-countdown",
+			templaticalBlockType: entry.templaticalBlockType,
+			status: "approximated",
+			note: entry.note ? `${entry.note} marketing-countdown` : COUNTDOWN_NOTE
+		});
+	}
+	const src = readAttr(node, "src", map.resolve);
+	if (typeof src === "string" && !isUnset(src)) {
+		const image = createImageBlock({
+			src,
+			...leafStyles(node, map)
+		});
+		const visibility = readVisibility$1(node);
+		if (visibility) image.visibility = visibility;
+		blocks.push(image);
+		entries.push({
+			sourceTag: "marketing-countdown",
+			templaticalBlockType: "image",
+			status: "approximated",
+			note: COUNTDOWN_NOTE
+		});
+	}
+	return {
+		blocks,
+		entries
+	};
+}
+function convertVideo(node, map) {
+	const url = firstUrl(node, map);
+	if (!url) return convertUnknown(node, map);
+	return finish(createVideoBlock({
+		url,
+		...leafStyles(node, map)
+	}), node, report("common-video", "video", "converted"));
+}
+function convertUnknown(node, map) {
+	const sourceTag = node.type ?? "unknown";
+	return finish(createHtmlBlock({
+		content: JSON.stringify(node),
+		...leafStyles(node, map)
+	}), node, report(sourceTag, "html", "html-fallback", `Unknown Easy Email Pro type "${sourceTag}"; preserved as HTML.`));
+}
+function remapOverlay(child) {
+	if (child.type === "text") return {
+		...child,
+		type: "standard-paragraph"
+	};
+	if (child.type === "standard-paragraph") return child;
+	if (typeof child.type === "string" && headingLevelFromType(child.type)) return child;
+	return null;
+}
+function collectRows(node) {
+	const rows = [];
+	for (const child of node.children ?? []) {
+		if (!isElement$2(child)) continue;
+		if (child.type === "tr") {
+			rows.push(child);
+			continue;
+		}
+		for (const inner of child.children ?? []) if (isElement$2(inner) && inner.type === "tr") rows.push(inner);
+	}
+	return rows;
+}
+function firstUrl(node, map) {
+	for (const key of [
+		"src",
+		"href",
+		"url"
+	]) {
+		const value = readAttr(node, key, map.resolve);
+		if (typeof value === "string" && !isUnset(value)) return value;
+	}
+}
+function inferPlatform(href, src) {
+	const host = hostname(typeof href === "string" ? href : "");
+	for (const platform of SOCIAL_PLATFORMS) if (host.includes(platform)) return platform;
+	const path = pathOf(typeof src === "string" ? src : "");
+	for (const platform of SOCIAL_PLATFORMS) if (path.includes(platform)) return platform;
+	return "website";
+}
+function hostname(href) {
+	const lower = href.toLowerCase();
+	const scheme = lower.indexOf("://");
+	const rest = scheme === -1 ? lower : lower.slice(scheme + 3);
+	const slash = rest.indexOf("/");
+	const hostport = slash === -1 ? rest : rest.slice(0, slash);
+	const colon = hostport.indexOf(":");
+	return colon === -1 ? hostport : hostport.slice(0, colon);
+}
+function pathOf(src) {
+	const lower = src.toLowerCase();
+	const scheme = lower.indexOf("://");
+	const rest = scheme === -1 ? lower : lower.slice(scheme + 3);
+	const slash = rest.indexOf("/");
+	return slash === -1 ? rest : rest.slice(slash);
+}
+function headingLevelFromType(type) {
+	if (!type.startsWith("standard-h")) return null;
+	const raw = type.slice(10);
+	if (raw.length === 0) return null;
+	for (let i = 0; i < raw.length; i++) {
+		const code = raw.charCodeAt(i);
+		if (code < 48 || code > 57) return null;
+	}
+	const source = Number(raw);
+	if (!Number.isFinite(source) || source < 1) return null;
+	return {
+		level: source > 4 ? 4 : source,
+		source
+	};
+}
+function leafStyles(node, map) {
+	return { styles: { padding: readPadding((key) => readAttr(node, key, map.resolve)) } };
+}
+function finish(block, node, entry) {
+	const visibility = readVisibility$1(node);
+	if (visibility) block.visibility = visibility;
+	return {
+		blocks: [block],
+		entries: [entry]
+	};
+}
+function readVisibility$1(node) {
+	if (node.visible === "desktop") return {
+		desktop: true,
+		mobile: false
+	};
+	if (node.visible === "mobile") return {
+		desktop: false,
+		mobile: true
+	};
+}
+function report(sourceTag, templaticalBlockType, status, note) {
+	return {
+		sourceTag,
+		templaticalBlockType,
+		status,
+		...note ? { note } : {}
+	};
+}
+function empty$1() {
+	return {
+		blocks: [],
+		entries: []
+	};
+}
+function isElement$2(node) {
+	return typeof node.type === "string" && node.type !== "";
+}
+function isBorderEnabled(value) {
+	return value === true || value === "true";
+}
+function buttonWidth(value) {
+	if (isUnset(value)) return void 0;
+	if (typeof value === "string" && value.trim() === "100%") return "full";
+	return parsePx(value);
+}
+function parseAlign(value) {
+	if (typeof value !== "string") return void 0;
+	const align = value.trim().toLowerCase();
+	if (align === "left" || align === "center" || align === "right") return align;
+}
+function asLineStyle(value) {
+	if (typeof value !== "string") return void 0;
+	const style = value.trim().toLowerCase();
+	if (style === "solid" || style === "dashed" || style === "dotted") return style;
+}
+function setString(value) {
+	if (typeof value !== "string" || isUnset(value)) return void 0;
+	return value;
+}
+/** Button labels are plain text — strip tags the serialiser may have emitted. */
+function stripTags(html) {
+	if (html === "") return "";
+	return decodeEntities(removeTags(html)).trim();
+}
+function removeTags(html) {
+	let out = "";
+	let i = 0;
+	while (i < html.length) {
+		const open = html.indexOf("<", i);
+		if (open === -1) {
+			out += html.slice(i);
+			break;
+		}
+		out += html.slice(i, open);
+		const tagEnd = findOpenTagEnd(html, open + 1);
+		if (tagEnd === -1) {
+			out += html.slice(open);
+			break;
+		}
+		i = tagEnd + 1;
+	}
+	return out;
+}
+function decodeEntities(text) {
+	let out = "";
+	let i = 0;
+	while (i < text.length) {
+		if (text[i] === "&") {
+			const semi = text.indexOf(";", i + 1);
+			if (semi !== -1 && semi - i <= 6) {
+				const mapped = ENTITIES[text.slice(i, semi + 1)];
+				if (mapped !== void 0) {
+					out += mapped;
+					i = semi + 1;
+					continue;
+				}
+			}
+		}
+		out += text[i];
+		i++;
+	}
+	return out;
+}
+//#endregion
+//#region src/column-layout.ts
+const LAYOUT_SHAPES = [
+	{
+		layout: "1",
+		percents: [100]
+	},
+	{
+		layout: "2",
+		percents: [50, 50]
+	},
+	{
+		layout: "1-2",
+		percents: [33.33, 66.67]
+	},
+	{
+		layout: "2-1",
+		percents: [66.67, 33.33]
+	},
+	{
+		layout: "3",
+		percents: [
+			33.33,
+			33.33,
+			33.34
+		]
+	}
+];
+const WIDTH_TOLERANCE = 2;
+const COLUMN_COUNT = {
+	"1": 1,
+	"2": 2,
+	"3": 3,
+	"2-1": 2,
+	"1-2": 2
+};
+/**
+* Resolve column widths to one of the five layouts `ColumnLayout` allows.
+*
+* `exact: false` means the caller reports `approximated` — Chamaileon permits
+* any column count at any width and this union permits five shapes, so this is
+* the importer's main irreducible loss.
+*/
+function matchColumnLayout(percents) {
+	const count = percents.length;
+	if (count === 0) return {
+		layout: "1",
+		exact: true
+	};
+	if (percents.every((p) => p === null)) {
+		if (count === 1) return {
+			layout: "1",
+			exact: true
+		};
+		if (count === 2) return {
+			layout: "2",
+			exact: true
+		};
+		if (count === 3) return {
+			layout: "3",
+			exact: true
+		};
+		return {
+			layout: "3",
+			exact: false
+		};
+	}
+	const known = percents.filter((p) => p !== null);
+	const unsetCount = count - known.length;
+	const remainder = unsetCount === 0 ? 0 : Math.max(0, 100 - known.reduce((a, b) => a + b, 0)) / unsetCount;
+	const resolved = percents.map((p) => p ?? remainder);
+	const sameCount = LAYOUT_SHAPES.filter((s) => s.percents.length === count);
+	for (const shape of sameCount) if (shape.percents.every((want, i) => Math.abs(want - resolved[i]) <= WIDTH_TOLERANCE)) return {
+		layout: shape.layout,
+		exact: true
+	};
+	const candidates = sameCount.length > 0 ? sameCount : LAYOUT_SHAPES.filter((s) => s.layout === "3");
+	let best = candidates[0];
+	let bestError = Infinity;
+	for (const shape of candidates) {
+		const error = shape.percents.reduce((sum, want, i) => sum + Math.abs(want - (resolved[i] ?? 0)), 0);
+		if (error < bestError) {
+			bestError = error;
+			best = shape;
+		}
+	}
+	return {
+		layout: best.layout,
+		exact: false
+	};
+}
+//#endregion
+//#region src/section-builder.ts
+function buildTopLevel(node, map) {
+	switch (node.type) {
+		case "standard-wrapper": return buildWrapper(node, map);
+		case "standard-hero": return buildHero(node, map);
+		case "standard-section": return buildSection(node, map);
+		default: return empty();
+	}
+}
+function buildSection(node, map) {
+	const plan = collectSlots(node);
+	const leftover = convertFlow(plan.leftovers, map);
+	const rawWidths = plan.columns.map((column) => readAttr(column, "width", map.resolve));
+	const { layout, exact } = matchColumnLayout(rawWidths.map((width) => parsePercent(width)));
+	const slots = COLUMN_COUNT[layout];
+	const children = Array.from({ length: slots }, () => []);
+	if (leftover.blocks.length > 0) children[0].push(...leftover.blocks);
+	const entries = leftover.entries;
+	plan.columns.forEach((column, index) => {
+		const slot = Math.min(index, slots - 1);
+		const inner = convertFlow(column.children ?? [], map);
+		children[slot].push(...inner.blocks);
+		for (const entry of inner.entries) entries.push(entry);
+	});
+	const reasons = [];
+	if (plan.mixed) reasons.push("Section mixed columns and groups; flattened into the column flow.");
+	if (!exact) {
+		if (plan.columns.length > slots) reasons.push(`${plan.columns.length}-column layout has no exact Templatical equivalent; folded onto "${layout}".`);
+		else {
+			const shown = rawWidths.map((width) => typeof width === "string" && !isUnset(width) ? width : "auto").join(", ");
+			reasons.push(`Column widths ${shown} have no exact Templatical layout; resolved to "${layout}".`);
+		}
+	}
+	const section = createSectionBlock();
+	section.columns = layout;
+	section.children = children;
+	paintSection(section, node, map, { stackOnMobile: plan.grouped ? false : void 0 });
+	entries.unshift(sectionEntry(node, reasons.length > 0 ? "approximated" : "converted", reasons.length > 0 ? reasons.join(" ") : void 0));
+	return {
+		blocks: [section],
+		entries
+	};
+}
+function buildHero(node, map) {
+	const slot = [];
+	const entries = [];
+	const url = readAttr(node, "background-url", map.resolve);
+	if (typeof url === "string" && !isUnset(url)) {
+		slot.push(createImageBlock({ src: url }));
+		entries.push({
+			sourceTag: "standard-hero",
+			templaticalBlockType: "image",
+			status: "approximated",
+			note: "hero background-url stacked as a leading image (overlay is the loss)"
+		});
+	}
+	const inner = convertFlow(node.children ?? [], map);
+	slot.push(...inner.blocks);
+	for (const entry of inner.entries) entries.push(entry);
+	const section = createSectionBlock();
+	section.columns = "1";
+	section.children = [slot];
+	paintSection(section, node, map);
+	entries.unshift({
+		sourceTag: "standard-hero",
+		templaticalBlockType: "section",
+		status: "approximated",
+		note: "standard-hero overlay is stacked as a 1-column section; background-url becomes a leading image."
+	});
+	return {
+		blocks: [section],
+		entries
+	};
+}
+function buildWrapper(node, map) {
+	const blocks = [];
+	const entries = [];
+	for (const child of elements(node)) {
+		if (child.type === "placeholder") continue;
+		const inner = buildTopLevel(child, map);
+		for (const block of inner.blocks) blocks.push(block);
+		for (const entry of inner.entries) entries.push(entry);
+	}
+	const sections = blocks.filter((block) => block.type === "section");
+	if (sections.length === 0) return {
+		blocks: [],
+		entries: [{
+			sourceTag: "standard-wrapper",
+			templaticalBlockType: null,
+			status: "skipped",
+			note: "An empty standard-wrapper produces nothing."
+		}]
+	};
+	const wrapper = readWrapper(node, map);
+	for (const section of sections) section.wrapper = { ...wrapper };
+	if (sections.length > 1) {
+		const note = `standard-wrapper holding ${sections.length} sections was applied to each of them — Templatical has no multi-section band.`;
+		for (const entry of entries) {
+			if (entry.templaticalBlockType !== "section") continue;
+			if (entry.status !== "converted") continue;
+			entry.status = "approximated";
+			entry.note = note;
+		}
+	}
+	return {
+		blocks,
+		entries
+	};
+}
+/**
+* Direct columns become slots. A sole `standard-group` of columns becomes
+* those slots with `stackOnMobile: false`. Mixed group + columns flatten
+* into the slot list and are approximated.
+*/
+function collectSlots(section) {
+	const kids = structuralChildren(section);
+	if (kids.every((kid) => kid.type === "standard-column")) return {
+		columns: kids,
+		leftovers: [],
+		grouped: false,
+		mixed: false
+	};
+	if (kids.length === 1 && kids[0].type === "standard-group") {
+		const groupKids = structuralChildren(kids[0]);
+		if (groupKids.every((kid) => kid.type === "standard-column")) return {
+			columns: groupKids,
+			leftovers: [],
+			grouped: true,
+			mixed: false
+		};
+	}
+	const columns = [];
+	const leftovers = [];
+	let grouped = false;
+	for (const kid of kids) {
+		if (kid.type === "standard-column") {
+			columns.push(kid);
+			continue;
+		}
+		if (kid.type === "standard-group") {
+			grouped = true;
+			for (const inner of structuralChildren(kid)) if (inner.type === "standard-column") columns.push(inner);
+			else leftovers.push(inner);
+			continue;
+		}
+		leftovers.push(kid);
+	}
+	return {
+		columns,
+		leftovers,
+		grouped,
+		mixed: true
+	};
+}
+function convertFlow(nodes, map) {
+	const blocks = [];
+	const entries = [];
+	for (const child of nodes ?? []) {
+		if (!isElement$1(child)) continue;
+		if (child.type === "placeholder") continue;
+		if (child.type === "standard-group") {
+			const innerColumns = structuralChildren(child).filter((node) => node.type === "standard-column");
+			entries.push({
+				sourceTag: "standard-group",
+				templaticalBlockType: null,
+				status: "approximated",
+				note: `nested group flattened (${innerColumns.length} columns)`
+			});
+			for (const column of innerColumns) {
+				const inner = convertFlow(column.children, map);
+				for (const block of inner.blocks) blocks.push(block);
+				for (const entry of inner.entries) entries.push(entry);
+			}
+			continue;
+		}
+		if (child.type === "standard-column") {
+			const inner = convertFlow(child.children, map);
+			for (const block of inner.blocks) blocks.push(block);
+			for (const entry of inner.entries) entries.push(entry);
+			continue;
+		}
+		const converted = convertLeaf(child, map);
+		for (const block of converted.blocks) blocks.push(block);
+		for (const entry of converted.entries) entries.push(entry);
+	}
+	return {
+		blocks,
+		entries
+	};
+}
+/** `createSectionBlock()` first, then mutate fill — never a partial `styles`. */
+function paintSection(section, node, map, extras) {
+	section.styles.padding = readPadding((key) => readAttr(node, key, map.resolve));
+	const fill = sectionFill(node, map);
+	if (fill) section.styles.backgroundColor = fill;
+	const radius = parsePx(readAttr(node, "border-radius", map.resolve));
+	if (radius !== void 0 && radius > 0) section.borderRadius = radius;
+	if (extras?.stackOnMobile === false) section.stackOnMobile = false;
+	const visibility = readVisibility(node);
+	if (visibility) section.visibility = visibility;
+}
+function sectionFill(node, map) {
+	const own = parseColor(readAttr(node, "background-color", map.resolve));
+	if (own) return own;
+	return parseColor(readAttr(map.resolve.page, "content-background-color", map.resolve));
+}
+function readWrapper(node, map) {
+	const backgroundColor = parseColor(readAttr(node, "background-color", map.resolve));
+	const padding = readPadding((key) => readAttr(node, key, map.resolve));
+	const radius = parsePx(readAttr(node, "border-radius", map.resolve));
+	return {
+		...backgroundColor ? { backgroundColor } : {},
+		padding,
+		...radius !== void 0 && radius > 0 ? { borderRadius: radius } : {}
+	};
+}
+function sectionEntry(node, status, note) {
+	return {
+		sourceTag: node.type ?? "standard-section",
+		templaticalBlockType: "section",
+		status,
+		...note ? { note } : {}
+	};
+}
+function readVisibility(node) {
+	if (node.visible === "desktop") return {
+		desktop: true,
+		mobile: false
+	};
+	if (node.visible === "mobile") return {
+		desktop: false,
+		mobile: true
+	};
+}
+function structuralChildren(node) {
+	return elements(node).filter((child) => child.type !== "placeholder");
+}
+function elements(node) {
+	const out = [];
+	for (const child of node.children ?? []) if (isElement$1(child)) out.push(child);
+	return out;
+}
+function isElement$1(node) {
+	return typeof node.type === "string" && node.type !== "";
+}
+function empty() {
+	return {
+		blocks: [],
+		entries: []
+	};
+}
+//#endregion
+//#region src/converter.ts
+const INVALID_MESSAGE = "Invalid Easy Email Pro template: expected a page JSON object (EmailTemplate { subject, content } or the page element).";
+const OSS_MESSAGE = "Invalid Easy Email Pro template: this looks like open-source Easy Email JSON, not Easy Email Pro (expected standard-* children).";
+const EMPTY_WARNING = "No convertible content was found in the Easy Email Pro page. Check that page.children holds at least one standard-section.";
+const MOBILE_WARNING = "mobileAttributes were dropped; Templatical has no per-viewport padding.";
+function varWarning(resolved, unresolved) {
+	return `Resolved ${resolved} $var() values, ${unresolved} left unresolved.`;
+}
+const OSS_CHILD_TYPES = /* @__PURE__ */ new Set([
+	"section",
+	"column",
+	"text",
+	"button",
+	"image",
+	"wrapper",
+	"hero",
+	"navbar",
+	"social"
+]);
+const STRUCTURE_TYPES = /* @__PURE__ */ new Set([
+	"standard-section",
+	"standard-wrapper",
+	"standard-hero"
+]);
+const WIDGET_TYPES = /* @__PURE__ */ new Set(["section_widget", "wrapper_widget"]);
+/**
+* `DEFAULT_TEMPLATE_DEFAULTS` is typed `Partial<TemplateSettings>` so a
+* consumer can override any subset, but its own literal always sets the six
+* required fields. Narrowing once here is what lets each fallback come out as
+* `number`/`string`/`boolean` rather than `| undefined`.
+*/
+const REQUIRED_DEFAULTS = DEFAULT_TEMPLATE_DEFAULTS;
+/**
+* Convert an Easy Email Pro page (or EmailTemplate envelope) into a
+* Templatical template. Accepts a bare `page` element, an
+* `EmailTemplate { subject, content }` envelope, or a JSON string of either.
+*/
+function convertEasyEmailProTemplate(doc) {
+	const root = typeof doc === "string" ? safeParse(doc) : doc;
+	if (typeof root !== "object" || root === null || Array.isArray(root)) throw new Error(INVALID_MESSAGE);
+	const unwrapped = unwrapDocument(root);
+	if (unwrapped.page.type !== "page") throw new Error(INVALID_MESSAGE);
+	const page = unwrapped.page;
+	const subject = unwrapped.subject;
+	assertNotOss(page);
+	const warnings = [];
+	const entries = [];
+	const blocks = [];
+	const resolve = contextFromPage(page);
+	const map = {
+		resolve,
+		warnings
+	};
+	const data = isPlainObject(page.data) ? page.data : {};
+	if (typeof subject === "string" ? subject.trim() : "") warnings.push(`Document subject "${subject}" has no TemplateSettings field and was dropped.`);
+	if (Array.isArray(data.fonts) && data.fonts.length > 0) warnings.push("Dropped fonts[] — Templatical templates have no document-level font table.");
+	if (isNonEmptyHeadStyles(data.headStyles)) warnings.push("Dropped headStyles — Templatical templates have no document-level head-style table.");
+	if (isPlainObject(data.classAttributes) && Object.keys(data.classAttributes).length > 0) warnings.push("Dropped classAttributes — class-based MJML attribute cascade is not applied.");
+	for (const child of page.children ?? []) {
+		if (!isElement(child)) continue;
+		walkNode(child, map, entries, blocks);
+	}
+	const settings = readSettings(page, data, resolve);
+	if (hasMobileAttributes(page)) warnings.push(MOBILE_WARNING);
+	if (resolve.stats.resolved > 0 || resolve.stats.unresolved > 0) warnings.push(varWarning(resolve.stats.resolved, resolve.stats.unresolved));
+	if (blocks.length === 0) warnings.push(EMPTY_WARNING);
+	const defaults = createDefaultTemplateContent();
+	return {
+		content: {
+			...defaults,
+			blocks,
+			settings: {
+				...defaults.settings,
+				...settings
+			}
+		},
+		report: {
+			entries,
+			warnings,
+			summary: {
+				total: entries.length,
+				converted: entries.filter((e) => e.status === "converted").length,
+				approximated: entries.filter((e) => e.status === "approximated").length,
+				htmlFallback: entries.filter((e) => e.status === "html-fallback").length,
+				skipped: entries.filter((e) => e.status === "skipped").length
+			}
+		}
+	};
+}
+function readSettings(page, data, resolve) {
+	const width = parsePx(readAttr(page, "width", resolve)) ?? REQUIRED_DEFAULTS.width;
+	const backgroundColor = parseColor(readAttr(page, "background-color", resolve)) ?? REQUIRED_DEFAULTS.backgroundColor;
+	const fontFamilyRaw = readAttr(page, "font-family", resolve);
+	const fontFamily = typeof fontFamilyRaw === "string" && !isUnset(fontFamilyRaw) ? fontFamilyRaw : REQUIRED_DEFAULTS.fontFamily;
+	const textColor = parseColor(readAttr(page, "color", resolve)) ?? REQUIRED_DEFAULTS.textColor;
+	const linkColor = parseColor(readAttr(page, "link-color", resolve));
+	const deco = readAttr(page, "link-text-decoration", resolve);
+	const linkUnderline = deco === "underline" ? true : deco === "none" ? false : REQUIRED_DEFAULTS.linkUnderline;
+	const preheaderRaw = typeof data.preheader === "string" ? data.preheader.trim() : "";
+	return {
+		width,
+		backgroundColor,
+		textColor,
+		fontFamily,
+		linkUnderline,
+		locale: REQUIRED_DEFAULTS.locale,
+		...linkColor ? { linkColor } : {},
+		...preheaderRaw ? { preheaderText: preheaderRaw } : {}
+	};
+}
+function walkNode(node, map, entries, blocks) {
+	if (node.type === "placeholder") return;
+	const logic = node.logic;
+	const logicOn = hasLogic(logic);
+	if (logicOn && !hasTypedContent(node)) {
+		entries.push({
+			sourceTag: node.type ?? "logic",
+			templaticalBlockType: null,
+			status: "skipped",
+			note: `Skipped empty logic (${logicExpression(logic)})`
+		});
+		return;
+	}
+	if (typeof node.type === "string" && WIDGET_TYPES.has(node.type)) {
+		const from = entries.length;
+		const data = isPlainObject(node.data) ? node.data : {};
+		const input = isPlainObject(data.input) ? data.input : void 0;
+		const inner = {
+			resolve: withWidgetInput(map.resolve, input),
+			warnings: map.warnings
+		};
+		for (const child of node.children ?? []) {
+			if (!isElement(child)) continue;
+			walkNode(child, inner, entries, blocks);
+		}
+		markApproximated(entries, from, `${node.type} flattened; $var resolved from data.input`, { sourceTag: node.type });
+		if (logicOn) markApproximated(entries, from, `logic ${logicExpression(logic)}`);
+		return;
+	}
+	const from = entries.length;
+	if (typeof node.type === "string" && STRUCTURE_TYPES.has(node.type)) {
+		const converted = buildTopLevel(node, map);
+		for (const block of converted.blocks) blocks.push(block);
+		for (const entry of converted.entries) entries.push(entry);
+	} else {
+		const converted = convertLeaf(node, map);
+		for (const entry of converted.entries) entries.push(entry);
+		if (converted.blocks.length > 0) {
+			if (isLeafType(node.type)) blocks.push(wrapInSection(converted.blocks));
+			else blocks.push(...converted.blocks);
+		}
+	}
+	if (logicOn) markApproximated(entries, from, `logic ${logicExpression(logic)}`);
+}
+function wrapInSection(blocks) {
+	const section = createSectionBlock();
+	section.columns = "1";
+	section.children = [blocks];
+	return section;
+}
+function markApproximated(entries, from, extra, rewrite) {
+	for (let i = from; i < entries.length; i++) {
+		const entry = entries[i];
+		if (rewrite) entry.sourceTag = rewrite.sourceTag;
+		if (entry.status === "converted") entry.status = "approximated";
+		entry.note = entry.note ? `${entry.note} ${extra}` : extra;
+	}
+}
+function hasLogic(logic) {
+	if (logic == null || typeof logic !== "object") return false;
+	return logic.condition != null || logic.iteration != null;
+}
+function logicExpression(logic) {
+	const parts = [];
+	if (logic.condition != null) parts.push(typeof logic.condition === "string" ? logic.condition : JSON.stringify(logic.condition));
+	if (logic.iteration != null) {
+		const iteration = logic.iteration;
+		if (typeof iteration === "string") parts.push(iteration);
+		else if (isPlainObject(iteration) && typeof iteration.dataSource === "string") parts.push(iteration.dataSource);
+		else parts.push(JSON.stringify(iteration));
+	}
+	return parts.join(" ");
+}
+function hasTypedContent(node) {
+	for (const child of node.children ?? []) {
+		if (!isElement(child)) continue;
+		if (child.type === "placeholder") continue;
+		return true;
+	}
+	return false;
+}
+function hasMobileAttributes(node) {
+	if (!isPlainObject(node)) return false;
+	const mobile = node.mobileAttributes;
+	if (isPlainObject(mobile) && Object.keys(mobile).length > 0) return true;
+	if (!Array.isArray(node.children)) return false;
+	for (const child of node.children) if (hasMobileAttributes(child)) return true;
+	return false;
+}
+function assertNotOss(page) {
+	const children = page.children ?? [];
+	for (const child of children) {
+		if (!child || typeof child !== "object") continue;
+		const type = child.type;
+		if (typeof type !== "string") continue;
+		if (OSS_CHILD_TYPES.has(type)) throw new Error(OSS_MESSAGE);
+		break;
+	}
+}
+function isElement(node) {
+	return typeof node.type === "string" && node.type !== "";
+}
+function isNonEmptyHeadStyles(value) {
+	if (Array.isArray(value)) return value.length > 0;
+	return isPlainObject(value) && Object.keys(value).length > 0;
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function safeParse(raw) {
+	try {
+		return JSON.parse(raw);
+	} catch {
+		throw new Error(INVALID_MESSAGE);
+	}
+}
+//#endregion
+export { convertEasyEmailProTemplate };
+
+//# sourceMappingURL=index.js.map