@templatical/import-chamaileon 0.36.0

package/dist/index.js

@@ -0,0 +1,1072 @@
+import { DEFAULT_TEMPLATE_DEFAULTS, createButtonBlock, createDefaultTemplateContent, createDividerBlock, createHtmlBlock, createImageBlock, createParagraphBlock, createSectionBlock, createSocialIconsBlock, createTitleBlock, createVideoBlock, findOpenTagEnd, generateId } from "@templatical/types";
+//#region src/normalize.ts
+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";
+}
+function camelKey(key) {
+	return key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function isVariableObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && ("reference" in value || "default" in value);
+}
+function unwrapValue(value, variables, stats) {
+	if (!isVariableObject(value)) return value;
+	const resolved = !isUnset(value.default) ? value.default : (() => {
+		const ref = typeof value.reference === "string" ? value.reference : void 0;
+		if (!ref) return void 0;
+		const found = variables.find((v) => v.name === ref);
+		return found && !isUnset(found.value) ? found.value : void 0;
+	})();
+	if (stats && !isUnset(resolved)) stats.resolvedVariables += 1;
+	return resolved;
+}
+function readMap(raw, variables, stats) {
+	const out = {};
+	if (!raw) return out;
+	for (const [key, value] of Object.entries(raw)) {
+		const unwrapped = unwrapValue(value, variables, stats);
+		if (isUnset(unwrapped)) continue;
+		out[camelKey(key)] = unwrapped;
+	}
+	return out;
+}
+function readStyle(node, variables, stats) {
+	return readMap(node.style, variables, stats);
+}
+function readAttrs(node, variables, stats) {
+	return readMap(node.attrs, variables, stats);
+}
+function styleValue(style, key) {
+	return style[camelKey(key)];
+}
+//#endregion
+//#region src/attribute-parser.ts
+/**
+* Parse a px-like value into a rounded integer. Returns `undefined` when unset
+* or for units the block model cannot express (em, rem, %).
+*
+* Trims first, then matches with no surrounding `\s*` so a failing match cannot
+* backtrack across trailing spaces.
+*/
+function parsePx(value) {
+	if (isUnset(value)) return void 0;
+	if (typeof value === "number") return Number.isFinite(value) ? Math.round(value) : void 0;
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	const match = /^(-?\d+(?:\.\d+)?)(?:px)?$/.exec(trimmed);
+	return match ? Math.round(parseFloat(match[1])) : void 0;
+}
+const NAMED_COLORS = {
+	black: "#000000",
+	white: "#ffffff",
+	red: "#ff0000",
+	green: "#008000",
+	blue: "#0000ff",
+	yellow: "#ffff00",
+	cyan: "#00ffff",
+	magenta: "#ff00ff",
+	gray: "#808080",
+	grey: "#808080",
+	silver: "#c0c0c0",
+	maroon: "#800000",
+	olive: "#808000",
+	lime: "#00ff00",
+	aqua: "#00ffff",
+	teal: "#008080",
+	navy: "#000080",
+	fuchsia: "#ff00ff",
+	purple: "#800080",
+	orange: "#ffa500",
+	pink: "#ffc0cb"
+};
+function rgbToHex(r, g, b) {
+	const clamp = (n) => Math.max(0, Math.min(255, Math.round(n)));
+	const hex = (n) => clamp(n).toString(16).padStart(2, "0");
+	return `#${hex(r)}${hex(g)}${hex(b)}`;
+}
+/**
+* Normalize a colour to 6-digit lowercase hex.
+*
+* Returns `undefined` for unset inputs (including transparent) and for anything
+* unrecognised — optional colour fields stay omitted rather than empty string.
+*/
+function parseColor(value) {
+	if (isUnset(value)) return void 0;
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim().toLowerCase();
+	if (trimmed === "transparent" || trimmed === "inherit" || trimmed === "none") return void 0;
+	if (/^#[0-9a-f]{6}$/.test(trimmed)) return trimmed;
+	if (/^#[0-9a-f]{3}$/.test(trimmed)) {
+		const [, r, g, b] = trimmed;
+		return `#${r}${r}${g}${g}${b}${b}`;
+	}
+	const rgb = trimmed.match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*[\d.]+\s*)?\)$/);
+	if (rgb) return rgbToHex(+rgb[1], +rgb[2], +rgb[3]);
+	return NAMED_COLORS[trimmed];
+}
+/** Read split padding sides from a normalized style map; missing sides are 0. */
+function parsePadding(style) {
+	const side = (key) => parsePx(styleValue(style, key)) ?? 0;
+	return {
+		top: side("paddingTop"),
+		right: side("paddingRight"),
+		bottom: side("paddingBottom"),
+		left: side("paddingLeft")
+	};
+}
+/** Narrow an alignment to the three the block model accepts. */
+function parseAlignment(value, fallback) {
+	if (typeof value !== "string") return fallback;
+	const v = value.trim().toLowerCase();
+	return v === "left" || v === "center" || v === "right" ? v : fallback;
+}
+function isSpace(ch) {
+	return ch === " " || ch === "	" || ch === "\n" || ch === "\r";
+}
+function skipSpaces(s, i) {
+	while (i < s.length && isSpace(s[i])) i++;
+	return i;
+}
+/**
+* `"2px solid #00a591"` — width, style, colour.
+*
+* Linear: a regex whose last two tokens are "spaces, then the rest of the
+* string" is polynomial on a long run of spaces after the style word
+* (`js/polynomial-redos`). Every character here is visited at most once.
+*/
+function parseCssBorder(value) {
+	if (isUnset(value) || typeof value !== "string") return void 0;
+	const s = value.trim();
+	let i = 0;
+	const numStart = i;
+	while (i < s.length && s[i] >= "0" && s[i] <= "9") i++;
+	if (i < s.length && s[i] === ".") {
+		i++;
+		while (i < s.length && s[i] >= "0" && s[i] <= "9") i++;
+	}
+	if (i === numStart) return void 0;
+	const width = Math.round(parseFloat(s.slice(numStart, i)));
+	if (s.slice(i, i + 2).toLowerCase() !== "px") return void 0;
+	i += 2;
+	i = skipSpaces(s, i);
+	const styleStart = i;
+	while (i < s.length && !isSpace(s[i])) i++;
+	const styleWord = s.slice(styleStart, i).toLowerCase();
+	if (styleWord !== "solid" && styleWord !== "dashed" && styleWord !== "dotted") return;
+	i = skipSpaces(s, i);
+	if (i >= s.length) return void 0;
+	const color = parseColor(s.slice(i));
+	if (color === void 0 || width === 0) return void 0;
+	return {
+		width,
+		style: styleWord,
+		color
+	};
+}
+/** Parse a 2.0 divider `attrs.lineStyle` string into thickness/lineStyle/color. */
+function parseLineStyle(value) {
+	const border = parseCssBorder(value);
+	if (!border) return void 0;
+	return {
+		thickness: border.width,
+		lineStyle: border.style,
+		color: border.color
+	};
+}
+/** Strip quotes and return the first family in a stack. */
+function firstFamily(value) {
+	if (isUnset(value) || typeof value !== "string") return void 0;
+	const family = value.split(",")[0].trim().replace(/^['"]|['"]$/g, "");
+	return family === "" ? void 0 : family;
+}
+//#endregion
+//#region src/content-inference.ts
+/**
+* A single heading element wrapping the whole content, captured with its level
+* and inner markup. Anchored at both ends so a heading with a sibling does not
+* match — that case is a paragraph.
+*/
+const SOLE_HEADING = /^<h([1-6])(?:\s[^>]*)?>([\s\S]*)<\/h\1>$/i;
+const BLOCK_ROOT = /^<(p|h[1-6]|ul|ol|blockquote|div|table)\b/i;
+/**
+* Resolve a Chamaileon `attrs.text` string to a Title or a Paragraph.
+*
+* Chamaileon has no menu or table construct for this arm, so this is a two-way
+* choice — the MJML importer needs four arms because `mj-text` is the output
+* of four different block renderers there. Paragraph is the terminal arm and
+* always reachable, so this function is total.
+*/
+function inferTextBlock(content) {
+	const trimmed = (content ?? "").trim();
+	if (trimmed === "") return {
+		kind: "paragraph",
+		html: "<p></p>"
+	};
+	const heading = trimmed.match(SOLE_HEADING);
+	if (heading) {
+		const source = Number(heading[1]);
+		return {
+			kind: "title",
+			level: Math.min(source, 4),
+			inner: heading[2].trim(),
+			...source > 4 ? { clampedFrom: source } : {}
+		};
+	}
+	return {
+		kind: "paragraph",
+		html: BLOCK_ROOT.test(trimmed) ? trimmed : `<p>${trimmed}</p>`
+	};
+}
+const ENTITIES = {
+	"&amp;": "&",
+	"&lt;": "<",
+	"&gt;": ">",
+	"&quot;": "\"",
+	"&#39;": "'",
+	"&apos;": "'",
+	"&nbsp;": " "
+};
+/**
+* Remove every `<tag>` from `html`, keeping the text between them.
+*
+* A single-pass linear scan rather than `/<[^>]*>/g`: that regex is
+* polynomial over input with many `<` starts and no closing `>`, since
+* `[^>]*` backtracks at every one of them — `"<".repeat(n)` is quadratic in
+* `n`. `findOpenTagEnd` (from `@templatical/types`) resolves each `<` with a
+* bounded, quote-aware forward scan instead, so the walk stays O(n): every
+* character is visited at most once by `indexOf` and once by
+* `findOpenTagEnd`, because the cursor only moves forward and an
+* unterminated tag ends the walk rather than retrying from inside it. On
+* that unterminated case the remainder of the string — the dangling `<`
+* included — is emitted as-is, matching what `/<[^>]*>/g` does with
+* malformed markup: it can never complete a match without a `>`, so the
+* text is left untouched from that point on.
+*/
+function removeTags(html) {
+	let out = "";
+	let i = 0;
+	while (i < html.length) {
+		const open = html.indexOf("<", i);
+		if (open === -1) {
+			out += html.substring(i);
+			break;
+		}
+		out += html.substring(i, open);
+		const tagEnd = findOpenTagEnd(html, open + 1);
+		if (tagEnd === -1) {
+			out += html.substring(open);
+			break;
+		}
+		i = tagEnd + 1;
+	}
+	return out;
+}
+/**
+* The visible text of a markup fragment, for a button label — `ButtonBlock.text`
+* is a plain string, so the markup Chamaileon stores in `attrs.text` cannot
+* travel.
+*/
+function stripTags(html) {
+	if (!html) return "";
+	return removeTags(html).replace(/&(?:amp|lt|gt|quot|#39|apos|nbsp);/g, (m) => ENTITIES[m] ?? m).replace(/\s+/g, " ").trim();
+}
+//#endregion
+//#region src/social-mapper.ts
+/**
+* Exhaustive over `SocialPlatform` on purpose: adding a member to that union
+* without adding it here is a compile error, so this cannot silently fall back
+* to "website" for a platform the block model gained.
+*/
+const KNOWN_PLATFORMS = {
+	facebook: true,
+	twitter: true,
+	instagram: true,
+	linkedin: true,
+	youtube: true,
+	tiktok: true,
+	pinterest: true,
+	email: true,
+	whatsapp: true,
+	telegram: true,
+	discord: true,
+	snapchat: true,
+	reddit: true,
+	github: true,
+	dribbble: true,
+	behance: true,
+	website: true
+};
+const ICON_SIZES = [
+	[24, "small"],
+	[32, "medium"],
+	[48, "large"]
+];
+const KNOWN_STYLES = /* @__PURE__ */ new Set([
+	"solid",
+	"outlined",
+	"rounded",
+	"square",
+	"circle"
+]);
+function normalizePlatform(raw) {
+	const cleaned = raw.trim().toLowerCase();
+	if (!cleaned) return null;
+	return cleaned in KNOWN_PLATFORMS ? cleaned : null;
+}
+function nearestSize(px) {
+	let best = ICON_SIZES[1];
+	let gap = Infinity;
+	for (const candidate of ICON_SIZES) {
+		const d = Math.abs(candidate[0] - px);
+		if (d < gap) {
+			gap = d;
+			best = candidate;
+		}
+	}
+	return {
+		size: best[1],
+		exact: gap === 0
+	};
+}
+function asString$2(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function asIconStyle(value) {
+	if (typeof value !== "string") return void 0;
+	const v = value.trim().toLowerCase();
+	return KNOWN_STYLES.has(v) ? v : void 0;
+}
+/**
+* Convert a Chamaileon `social` leaf into a `SocialIconsBlock`.
+*
+* `attrs.elements` is the source of truth for which icons render and in what
+* order. A row of images is not sniffed as social — only `type === "social"`.
+*/
+function convertSocial(node, ctx) {
+	const style = readStyle(node, ctx.variables, ctx.stats);
+	const attrs = readAttrs(node, ctx.variables, ctx.stats);
+	const rawElements = attrs.elements;
+	const elements = Array.isArray(rawElements) ? rawElements : [];
+	if (elements.length === 0) return {
+		block: null,
+		entry: report$1("social", null, "skipped", "social has no elements")
+	};
+	const notes = [];
+	const icons = [];
+	for (const item of elements) {
+		if (typeof item !== "object" || item === null || Array.isArray(item)) continue;
+		const el = item;
+		const rawType = asString$2(el.type) ?? "";
+		const platform = normalizePlatform(rawType);
+		if (!platform) notes.push(`Unrecognised social platform "${rawType}" mapped to "website".`);
+		icons.push({
+			id: generateId(),
+			platform: platform ?? "website",
+			url: asString$2(el.link) ?? ""
+		});
+	}
+	if (icons.length === 0) return {
+		block: null,
+		entry: report$1("social", null, "skipped", "social has no elements")
+	};
+	let iconSize;
+	const sizePx = parsePx(attrs.size);
+	if (sizePx !== void 0) {
+		const resolved = nearestSize(sizePx);
+		iconSize = resolved.size;
+		if (!resolved.exact) notes.push(`Icon size ${attrs.size} is not one of 24/32/48px; resolved to "${resolved.size}".`);
+	}
+	const iconStyle = asIconStyle(attrs.color) ?? asIconStyle(attrs.iconSet);
+	const spacing = parsePx(attrs.spacing);
+	const block = createSocialIconsBlock({
+		icons,
+		align: parseAlignment(attrs.align ?? style.align, "center"),
+		...iconSize ? { iconSize } : {},
+		...iconStyle ? { iconStyle } : {},
+		...spacing !== void 0 ? { spacing } : {},
+		styles: { padding: parsePadding(style) }
+	});
+	const visibility = readVisibility$2(attrs);
+	if (visibility) block.visibility = visibility;
+	return {
+		block,
+		entry: report$1("social", "social", notes.length > 0 ? "approximated" : "converted", notes.length > 0 ? notes.join(" ") : void 0)
+	};
+}
+function readVisibility$2(attrs) {
+	const hideOnMobile = attrs.hideOnMobile === true;
+	const hideOnDesktop = attrs.hideOnDesktop === true;
+	if (!hideOnMobile && !hideOnDesktop) return void 0;
+	return {
+		desktop: !hideOnDesktop,
+		mobile: !hideOnMobile
+	};
+}
+function report$1(sourceTag, templaticalBlockType, status, note) {
+	return {
+		sourceTag,
+		templaticalBlockType,
+		status,
+		...note ? { note } : {}
+	};
+}
+//#endregion
+//#region src/block-mapper.ts
+const LOOP_TYPES = /* @__PURE__ */ new Set([
+	"block-level-loop",
+	"block-level-conditional",
+	"loop",
+	"conditional",
+	"branch"
+]);
+function isLoopType(type) {
+	return typeof type === "string" && LOOP_TYPES.has(type);
+}
+function readLoopExpression(node, ctx) {
+	const value = readAttrs(node, ctx.variables, ctx.stats).expression;
+	return typeof value === "string" ? value : void 0;
+}
+function skippedLoopEntry(type, expression) {
+	return {
+		sourceTag: type,
+		templaticalBlockType: null,
+		status: "skipped",
+		note: expression ? `${type} ${expression}` : type
+	};
+}
+function markLoopApproximated(entries, from, type, expression) {
+	const extra = expression ? `${type} ${expression}` : type;
+	for (let i = from; i < entries.length; i++) {
+		const entry = entries[i];
+		if (entry.status === "converted") entry.status = "approximated";
+		entry.note = entry.note ? `${entry.note} ${extra}` : extra;
+	}
+}
+/**
+* Convert one Chamaileon leaf into a Templatical block.
+*
+* Structure nodes (`fullwidth` / `box` / `multicolumn` / `column`)
+* html-fallback if they reach this function.
+*/
+function convertLeaf(node, ctx) {
+	switch (node.type) {
+		case "text": return convertText(node, ctx);
+		case "typed-text": return convertTypedText(node, ctx);
+		case "button": return convertButton(node, ctx);
+		case "image": return convertImage(node, ctx, "converted");
+		case "dynamic-image": return convertImage(node, ctx, "approximated", "dynamic-image imported as an image block");
+		case "divider": return convertDivider(node, ctx);
+		case "video": return convertVideo(node, ctx);
+		case "code": return convertCode(node, ctx);
+		case "social": return convertSocial(node, ctx);
+		default: return convertUnknown(node, ctx);
+	}
+}
+function convertText(node, ctx) {
+	const { style, attrs } = readNode(node, ctx);
+	const raw = asString$1(attrs.text);
+	const inferred = inferTextBlock(raw);
+	if (inferred.kind === "paragraph") return finish(createParagraphBlock({
+		content: inferred.html,
+		...paddingStyles(style)
+	}), attrs, report("text", "paragraph", "converted"));
+	const heading = headingLooks(style, inferred.level, ctx);
+	return finish(createTitleBlock({
+		content: inferred.inner,
+		level: inferred.level,
+		textAlign: parseAlignment(alignFromMarkup(raw) ?? attrs.align ?? style.align, "left"),
+		...heading,
+		...paddingStyles(style)
+	}), attrs, inferred.clampedFrom ? report("text", "title", "approximated", `Heading level h${inferred.clampedFrom} clamped to 4 — Templatical titles support h1-h4.`) : report("text", "title", "converted"));
+}
+function convertTypedText(node, ctx) {
+	const { style, attrs } = readNode(node, ctx);
+	const raw = asString$1(attrs.text);
+	const inferred = inferTextBlock(raw);
+	const subType = asString$1(style.subType)?.trim().toLowerCase() ?? "paragraph";
+	const titleLevel = typedTitleLevel(subType);
+	if (titleLevel !== void 0) {
+		const level = inferred.kind === "title" ? inferred.level : titleLevel;
+		const color = parseColor(styleValue(style, "color"));
+		const fontFamily = firstFamily(styleValue(style, "fontFamily"));
+		return finish(createTitleBlock({
+			content: inferred.kind === "title" ? inferred.inner : stripTags(raw),
+			level,
+			textAlign: parseAlignment(style.align ?? attrs.align ?? alignFromMarkup(raw), "left"),
+			...color ? { color } : {},
+			...fontFamily ? { fontFamily } : {},
+			...paddingStyles(style)
+		}), attrs, report("typed-text", "title", "converted"));
+	}
+	const list = subType === "list";
+	return finish(createParagraphBlock({
+		content: inferred.kind === "paragraph" ? inferred.html : raw?.trim() || "<p></p>",
+		...paddingStyles(style)
+	}), attrs, list ? report("typed-text", "paragraph", "approximated", "typed-text list imported as a paragraph") : report("typed-text", "paragraph", "converted"));
+}
+function convertButton(node, ctx) {
+	const { style, attrs } = readNode(node, ctx);
+	const fill = parseColor(styleValue(style, "backgroundColor"));
+	const textColor = parseColor(styleValue(style, "color"));
+	const borderRadius = parsePx(styleValue(style, "borderRadius"));
+	const fontSize = parsePx(styleValue(style, "fontSize"));
+	const fontFamily = firstFamily(styleValue(style, "fontFamily"));
+	const block = createButtonBlock({
+		text: stripTags(asString$1(attrs.text)),
+		url: asString$1(attrs.href) ?? "",
+		...fill ? { backgroundColor: fill } : {},
+		...textColor ? { textColor } : {},
+		...borderRadius !== void 0 ? { borderRadius } : {},
+		...fontSize !== void 0 ? { fontSize } : {},
+		...fontFamily ? { fontFamily } : {},
+		align: parseAlignment(attrs.align ?? style.align, "center"),
+		...paddingStyles(style)
+	});
+	if (!fill) block.backgroundColor = "#ffffff";
+	return finish(block, attrs, fill ? report("button", "button", "converted") : report("button", "button", "approximated", "outlined button has no Templatical equivalent"));
+}
+function convertImage(node, ctx, status, note) {
+	const { style, attrs } = readNode(node, ctx);
+	const sourceTag = node.type ?? "image";
+	const src = asString$1(attrs.src) ?? asString$1(styleValue(style, "src")) ?? "";
+	const width = resolvedWidth(style, ctx.columnWidth);
+	const linkUrl = asString$1(attrs.link);
+	const borderRadius = parsePx(styleValue(style, "borderRadius"));
+	return finish(createImageBlock({
+		src,
+		alt: asString$1(attrs.altText) ?? "",
+		...width !== void 0 ? { width } : {},
+		align: parseAlignment(attrs.align ?? style.align, "center"),
+		...linkUrl ? { linkUrl } : {},
+		...borderRadius && borderRadius > 0 ? { borderRadius } : {},
+		...paddingStyles(style)
+	}), attrs, report(sourceTag, "image", status, note));
+}
+function convertDivider(node, ctx) {
+	const { style, attrs } = readNode(node, ctx);
+	const fromLine = parseLineStyle(attrs.lineStyle);
+	const thickness = fromLine?.thickness ?? parsePx(styleValue(style, "width"));
+	const lineStyle = fromLine?.lineStyle ?? asLineStyle(style.type);
+	const color = fromLine?.color ?? parseColor(styleValue(style, "color"));
+	return finish(createDividerBlock({
+		...thickness !== void 0 ? { thickness } : {},
+		...lineStyle ? { lineStyle } : {},
+		...color ? { color } : {},
+		width: "full",
+		...paddingStyles(style)
+	}), attrs, report("divider", "divider", "converted"));
+}
+function convertVideo(node, ctx) {
+	const { style, attrs } = readNode(node, ctx);
+	const width = resolvedWidth(style, ctx.columnWidth);
+	const alt = asString$1(attrs.altText);
+	return finish(createVideoBlock({
+		url: videoUrl(attrs),
+		thumbnailUrl: asString$1(attrs.src) ?? "",
+		...alt !== void 0 ? { alt } : {},
+		...width !== void 0 ? { width } : {},
+		align: parseAlignment(attrs.align ?? style.align, "center"),
+		...paddingStyles(style)
+	}), attrs, report("video", "video", "converted"));
+}
+function videoUrl(attrs) {
+	const link = asString$1(attrs.link);
+	if (link) return link;
+	const videoId = asString$1(attrs.videoId);
+	if (!videoId) return "";
+	const provider = asString$1(attrs.videoProvider)?.trim().toLowerCase();
+	if (provider === "youtube") return `https://www.youtube.com/watch?v=${videoId}`;
+	if (provider === "vimeo") return `https://vimeo.com/${videoId}`;
+	return "";
+}
+function convertCode(node, ctx) {
+	const { style, attrs } = readNode(node, ctx);
+	return finish(createHtmlBlock({
+		content: firstSetContent(attrs.html, attrs.code, attrs.content),
+		...paddingStyles(style)
+	}), attrs, report("code", "html", "converted"));
+}
+function convertUnknown(node, ctx) {
+	const { style, attrs } = readNode(node, ctx);
+	const sourceTag = node.type ?? "unknown";
+	return finish(createHtmlBlock({
+		content: JSON.stringify(node),
+		...paddingStyles(style)
+	}), attrs, report(sourceTag, "html", "html-fallback", `${sourceTag} has no Templatical block equivalent; the original node is preserved as JSON.`));
+}
+function readNode(node, ctx) {
+	return {
+		style: readStyle(node, ctx.variables, ctx.stats),
+		attrs: readAttrs(node, ctx.variables, ctx.stats)
+	};
+}
+function paddingStyles(style) {
+	return { styles: { padding: parsePadding(style) } };
+}
+function finish(block, attrs, entry) {
+	const visibility = readVisibility$1(attrs);
+	if (visibility) block.visibility = visibility;
+	return {
+		block,
+		entry
+	};
+}
+function readVisibility$1(attrs) {
+	const hideOnMobile = attrs.hideOnMobile === true;
+	const hideOnDesktop = attrs.hideOnDesktop === true;
+	if (!hideOnMobile && !hideOnDesktop) return void 0;
+	return {
+		desktop: !hideOnDesktop,
+		mobile: !hideOnMobile
+	};
+}
+function report(sourceTag, templaticalBlockType, status, note) {
+	return {
+		sourceTag,
+		templaticalBlockType,
+		status,
+		...note ? { note } : {}
+	};
+}
+function asString$1(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function firstSetContent(...values) {
+	for (const value of values) {
+		if (isUnset(value)) continue;
+		if (typeof value === "string") return value;
+		return JSON.stringify(value);
+	}
+	return "";
+}
+function resolvedWidth(style, columnWidth) {
+	const px = parsePx(styleValue(style, "width"));
+	if (px === void 0) return void 0;
+	return px >= columnWidth ? "full" : px;
+}
+function asLineStyle(value) {
+	if (typeof value !== "string") return void 0;
+	const v = value.trim().toLowerCase();
+	return v === "solid" || v === "dashed" || v === "dotted" ? v : void 0;
+}
+function typedTitleLevel(subType) {
+	if (subType === "title" || subType === "heading1") return 1;
+	if (subType === "heading2") return 2;
+	if (subType === "heading3") return 3;
+}
+function headingLooks(style, level, ctx) {
+	const nested = readNested(style[`h${level}`], ctx);
+	const color = parseColor(style[`h${level}Color`] ?? nested.color);
+	const fontFamily = firstFamily(style[`h${level}FontFamily`] ?? nested.fontFamily);
+	return {
+		...color ? { color } : {},
+		...fontFamily ? { fontFamily } : {}
+	};
+}
+function readNested(value, ctx) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+	const out = {};
+	for (const [key, raw] of Object.entries(value)) {
+		const unwrapped = unwrapValue(raw, ctx.variables, ctx.stats);
+		if (isUnset(unwrapped)) continue;
+		out[camelKey(key)] = unwrapped;
+	}
+	return out;
+}
+function alignFromMarkup(html) {
+	if (!html) return void 0;
+	return /text-align\s*:\s*(left|center|right)/i.exec(html)?.[1]?.toLowerCase();
+}
+//#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
+};
+function columnPixels(layout, container) {
+	switch (layout) {
+		case "2": return [container / 2, container / 2];
+		case "3": return [
+			container / 3,
+			container / 3,
+			container / 3
+		];
+		case "1-2": return [container / 3, container * 2 / 3];
+		case "2-1": return [container * 2 / 3, container / 3];
+		default: return [container];
+	}
+}
+/**
+* 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
+	};
+}
+/** Convert absolute px column widths to percents of `bodyWidth`. */
+function widthsToPercents(widthsPx, bodyWidth) {
+	return widthsPx.map((w) => w === void 0 ? null : w / bodyWidth * 100);
+}
+//#endregion
+//#region src/section-builder.ts
+/**
+* Build a `SectionBlock` from a Chamaileon `fullwidth`. Returns an array so
+* an empty fullwidth produces nothing.
+*
+* Boxes flatten into the parent. A nested `multicolumn` flattens into the
+* parent column — never a nested `type: "section"`.
+*/
+function buildFullwidth(node, ctx, entries) {
+	const style = readStyle(node, ctx.variables, ctx.stats);
+	const attrs = readAttrs(node, ctx.variables, ctx.stats);
+	const contentFill = parseColor(styleValue(style, "contentBackgroundColor"));
+	const outerFill = parseColor(styleValue(style, "backgroundColor"));
+	const original = node.children ?? [];
+	const sole = original.length === 1 ? original[0] : void 0;
+	const copySoleFill = sole?.type === "box" && isPaintedBox(sole, ctx) && contentFill === void 0;
+	const flattened = flattenBoxes(original, ctx, entries, copySoleFill ? sole : void 0);
+	if (flattened.length === 0) return [];
+	const mcIndex = flattened.findIndex((child) => child.type === "multicolumn");
+	const reasons = [];
+	const section = createSectionBlock();
+	if (mcIndex === -1) {
+		section.columns = "1";
+		section.children = [convertColumnChildren(flattened, withColumnWidth(ctx, ctx.bodyWidth), entries)];
+	} else {
+		const driving = flattened[mcIndex];
+		const before = flattened.slice(0, mcIndex);
+		const after = flattened.slice(mcIndex + 1);
+		if (before.length > 0 || after.length > 0) reasons.push("fullwidth mixes a multicolumn with sibling leaves; siblings were placed in column 0.");
+		const columns = (driving.children ?? []).filter((child) => child.type === "column");
+		const widthsPx = columns.map((column) => parsePx(styleValue(readStyle(column, ctx.variables, ctx.stats), "width")));
+		const { layout, exact } = matchColumnLayout(widthsToPercents(widthsPx, ctx.bodyWidth));
+		if (!exact) reasons.push(`Column widths ${formatWidths(widthsPx)} have no exact Templatical layout; resolved to "${layout}".`);
+		const stacking = asString(readAttrs(driving, ctx.variables, ctx.stats).stacking);
+		if (stacking === "none") section.stackOnMobile = false;
+		else if (stacking !== void 0 && stacking !== "left-on-top") reasons.push(`unknown stacking "${stacking}" omitted`);
+		const slots = COLUMN_COUNT[layout];
+		const pixels = columnPixels(layout, ctx.bodyWidth);
+		const children = Array.from({ length: slots }, () => []);
+		const slotCtx = (slot) => withColumnWidth(ctx, Math.round(pixels[slot] ?? ctx.bodyWidth));
+		children[0].push(...convertColumnChildren(before, slotCtx(0), entries));
+		columns.forEach((column, index) => {
+			const slot = Math.min(index, slots - 1);
+			children[slot].push(...convertColumnChildren(column.children ?? [], slotCtx(slot), entries));
+		});
+		children[0].push(...convertColumnChildren(after, slotCtx(0), entries));
+		section.columns = layout;
+		section.children = children;
+	}
+	const soleFill = copySoleFill ? parseColor(styleValue(readStyle(sole, ctx.variables, ctx.stats), "backgroundColor")) : void 0;
+	const fill = contentFill ?? soleFill;
+	section.styles.padding = contentPadding(style);
+	if (fill) section.styles.backgroundColor = fill;
+	if (outerFill) section.wrapper = { backgroundColor: outerFill };
+	const visibility = readVisibility(attrs);
+	if (visibility) section.visibility = visibility;
+	entries.push({
+		sourceTag: "fullwidth",
+		templaticalBlockType: "section",
+		status: reasons.length > 0 ? "approximated" : "converted",
+		...reasons.length > 0 ? { note: reasons.join(" ") } : {}
+	});
+	return [section];
+}
+function flattenBoxes(nodes, ctx, entries, silent) {
+	const out = [];
+	for (const child of nodes) {
+		if (child.type === "placeholder") continue;
+		if (child.type !== "box") {
+			out.push(child);
+			continue;
+		}
+		if (child !== silent && isPaintedBox(child, ctx)) reportPaintedBox(child, ctx, entries);
+		out.push(...flattenBoxes(child.children ?? [], ctx, entries, void 0));
+	}
+	return out;
+}
+function convertColumnChildren(nodes, ctx, entries) {
+	const blocks = [];
+	for (const child of nodes) {
+		if (child.type === "placeholder") continue;
+		if (child.type === "box") {
+			if (isPaintedBox(child, ctx)) reportPaintedBox(child, ctx, entries);
+			blocks.push(...convertColumnChildren(child.children ?? [], ctx, entries));
+			continue;
+		}
+		if (child.type === "multicolumn") {
+			const innerColumns = (child.children ?? []).filter((column) => column.type === "column");
+			entries.push({
+				sourceTag: "multicolumn",
+				templaticalBlockType: null,
+				status: "approximated",
+				note: `nested multicolumn flattened (${innerColumns.length} columns)`
+			});
+			for (const column of innerColumns) blocks.push(...convertColumnChildren(column.children ?? [], ctx, entries));
+			continue;
+		}
+		if (child.type === "column") {
+			blocks.push(...convertColumnChildren(child.children ?? [], ctx, entries));
+			continue;
+		}
+		if (isLoopType(child.type)) {
+			const type = child.type ?? "loop";
+			const expression = readLoopExpression(child, ctx);
+			const kids = child.children ?? [];
+			if (kids.length === 0) {
+				entries.push(skippedLoopEntry(type, expression));
+				continue;
+			}
+			const from = entries.length;
+			blocks.push(...convertColumnChildren(kids, ctx, entries));
+			markLoopApproximated(entries, from, type, expression);
+			continue;
+		}
+		const converted = convertLeaf(child, ctx);
+		entries.push(converted.entry);
+		if (converted.block) blocks.push(converted.block);
+	}
+	return blocks;
+}
+function isPaintedBox(node, ctx) {
+	const style = readStyle(node, ctx.variables, ctx.stats);
+	if (parseColor(styleValue(style, "backgroundColor"))) return true;
+	const padding = parsePadding(style);
+	if (padding.top !== 0 || padding.right !== 0 || padding.bottom !== 0 || padding.left !== 0) return true;
+	const radius = parsePx(styleValue(style, "borderRadius"));
+	return radius !== void 0 && radius > 0;
+}
+function reportPaintedBox(node, ctx, entries) {
+	const fill = parseColor(styleValue(readStyle(node, ctx.variables, ctx.stats), "backgroundColor"));
+	entries.push({
+		sourceTag: "box",
+		templaticalBlockType: null,
+		status: "approximated",
+		note: fill ? `box fill ${fill} dropped` : "box padding/radius dropped"
+	});
+}
+function contentPadding(style) {
+	return {
+		top: parsePx(styleValue(style, "contentPaddingTop")) ?? 0,
+		right: parsePx(styleValue(style, "contentPaddingRight")) ?? 0,
+		bottom: parsePx(styleValue(style, "contentPaddingBottom")) ?? 0,
+		left: parsePx(styleValue(style, "contentPaddingLeft")) ?? 0
+	};
+}
+function withColumnWidth(ctx, columnWidth) {
+	return {
+		...ctx,
+		columnWidth
+	};
+}
+function formatWidths(widthsPx) {
+	return widthsPx.map((width) => width === void 0 ? "auto" : `${width}px`).join(", ");
+}
+function readVisibility(attrs) {
+	const hideOnMobile = attrs.hideOnMobile === true;
+	const hideOnDesktop = attrs.hideOnDesktop === true;
+	if (!hideOnMobile && !hideOnDesktop) return void 0;
+	return {
+		desktop: !hideOnDesktop,
+		mobile: !hideOnMobile
+	};
+}
+function asString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+//#endregion
+//#region src/converter.ts
+const INVALID_MESSAGE = "Invalid Chamaileon template: expected the document JSON object from getDocument().";
+const WRONG_BODY_MESSAGE = "Invalid Chamaileon template: expected body.type to be \"body\".";
+const EMPTY_WARNING = "No convertible content was found in the Chamaileon document. Check that body.children holds at least one fullwidth.";
+/**
+* `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 a Chamaileon `getDocument()` tree into a Templatical template.
+*
+* The input is the document object itself — `{ body, variables?, … }` —
+* not `getEmailHtml()` markup and not an API envelope. That is documented
+* rather than sniffed: guessing between the persist JSON and compiled HTML
+* would send the HTML through the wrong package.
+*
+* @example
+* ```ts
+* const document = await editorInstance.methods.getDocument();
+* const { content, report } = convertChamaileonTemplate(document);
+* ```
+*/
+function convertChamaileonTemplate(doc) {
+	const root = typeof doc === "string" ? safeParse(doc) : doc;
+	if (typeof root !== "object" || root === null || Array.isArray(root)) throw new Error(INVALID_MESSAGE);
+	const document = root;
+	const body = document.body;
+	if (!body || body.type !== "body") throw new Error(WRONG_BODY_MESSAGE);
+	const entries = [];
+	const warnings = [];
+	const blocks = [];
+	const stats = { resolvedVariables: 0 };
+	const variables = document.variables ?? [];
+	const bodyStyle = readStyle(body, variables, stats);
+	const width = parsePx(styleValue(bodyStyle, "bodyWidth")) ?? REQUIRED_DEFAULTS.width;
+	const backgroundColor = parseColor(styleValue(bodyStyle, "backgroundColor")) ?? REQUIRED_DEFAULTS.backgroundColor;
+	const previewRaw = typeof document.previewText === "string" ? document.previewText.trim() : "";
+	if (typeof document.subjectLine === "string" ? document.subjectLine.trim() : "") warnings.push(`Dropped subjectLine ("${document.subjectLine}") — Templatical templates have no subject-line field.`);
+	const fontFiles = document.fontFiles;
+	if (fontFiles && typeof fontFiles === "object" && !Array.isArray(fontFiles) && Object.keys(fontFiles).length > 0) warnings.push("Dropped fontFiles — Templatical templates have no document-level font-file table.");
+	const ctx = {
+		bodyWidth: width,
+		columnWidth: width,
+		variables,
+		warnings,
+		stats
+	};
+	for (const child of body.children ?? []) convertBodyChild(child, ctx, entries, blocks);
+	if (stats.resolvedVariables > 0) warnings.push(`Resolved ${stats.resolvedVariables} colour/image variables to their default values.`);
+	if (blocks.length === 0) warnings.push(EMPTY_WARNING);
+	const defaults = createDefaultTemplateContent();
+	return {
+		content: {
+			...defaults,
+			blocks,
+			settings: {
+				...defaults.settings,
+				width,
+				backgroundColor,
+				...previewRaw ? { preheaderText: previewRaw } : {}
+			}
+		},
+		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 convertBodyChild(node, ctx, entries, blocks) {
+	if (node.type === "fullwidth") {
+		blocks.push(...buildFullwidth(node, ctx, entries));
+		return;
+	}
+	if (isLoopType(node.type)) {
+		convertLoop(node, ctx, entries, blocks);
+		return;
+	}
+	const converted = convertLeaf(node, ctx);
+	entries.push(converted.entry);
+	if (converted.block) blocks.push(converted.block);
+}
+function convertLoop(node, ctx, entries, blocks) {
+	const type = node.type ?? "loop";
+	const expression = readLoopExpression(node, ctx);
+	const children = node.children ?? [];
+	if (children.length === 0) {
+		entries.push(skippedLoopEntry(type, expression));
+		return;
+	}
+	const from = entries.length;
+	for (const child of children) convertBodyChild(child, ctx, entries, blocks);
+	markLoopApproximated(entries, from, type, expression);
+}
+function safeParse(source) {
+	try {
+		return JSON.parse(source);
+	} catch {
+		throw new Error(INVALID_MESSAGE);
+	}
+}
+//#endregion
+export { convertChamaileonTemplate };
+
+//# sourceMappingURL=index.js.map