@maizzle/framework 6.0.0-rc.8 → 6.0.0

package/dist/transformers/columnWidth.d.ts

@@ -0,0 +1,31 @@
+import { ChildNode } from "domhandler";
+
+//#region src/transformers/columnWidth.d.ts
+/**
+ * Resolve `__MAIZZLE_COLW_{id}__` and `__MAIZZLE_OH_{id}__` placeholders.
+ *
+ * COLW (column width) — emitted by `<Column>` and `<Overlap>`. Walks up to
+ * the nearest ancestor marked `data-maizzle-cw` (Container, Section,
+ * Row, or another Column already resolved) and divides the source
+ * width by `data-maizzle-cw-count`. With `data-maizzle-cw-self`,
+ * reads from the element's own inlined max/width/min-width
+ * instead — used by `<Overlap>` with its own width class.
+ *
+ * OH (overlap height) — emitted by `<Overlap>`. Reads max-height, height,
+ * or min-height from the element's own inlined style.
+ *
+ * Resolution rules:
+ * - Style placeholders for `min-width`: replaced when resolvable, otherwise
+ *   the entire `min-width` declaration is stripped.
+ * - Other style placeholders (Overlap td `width`, etc.): replaced when
+ *   resolvable, otherwise replaced with the count-based fallback or `100%`.
+ * - Comment placeholders: same fallback chain.
+ *
+ * Resolved column widths are written back to `data-maizzle-cw` so nested
+ * rows cascade. All `data-maizzle-cw*` and `data-maizzle-oh-*` are
+ * stripped at the end of the second walk pass.
+ */
+declare function columnWidth(dom: ChildNode[]): ChildNode[];
+//#endregion
+export { columnWidth };
+//# sourceMappingURL=columnWidth.d.ts.map

package/dist/transformers/columnWidth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"columnWidth.d.ts","names":[],"sources":["../../src/transformers/columnWidth.ts"],"mappings":";;;;;AAqKA;;;;;;;;AAAwD;;;;;;;;;;;;;;iBAAxC,WAAA,CAAY,GAAA,EAAK,SAAA,KAAc,SAAS"}

package/dist/transformers/columnWidth.js

@@ -0,0 +1,527 @@
+import { walk } from "../utils/ast/walker.js";
+import "../utils/ast/index.js";
+import { horizontalBorderPx, horizontalPaddingPx, lengthToPx } from "../utils/cssBox.js";
+import postcss from "postcss";
+import safeParser from "postcss-safe-parser";
+//#region src/transformers/columnWidth.ts
+const RE_PERCENT = /^[\d.]+%$/;
+/**
+* Stringify decls into a `; `-joined inline-style attribute. PostCSS raws
+* preserve the original source spacing, which mixes poorly with
+* the fresh decls we inject — plain join keeps output uniform.
+*/
+function serializeStyle(root) {
+	const parts = [];
+	root.walkDecls((d) => {
+		parts.push(`${d.prop}: ${d.value}${d.important ? " !important" : ""}`);
+	});
+	return parts.join("; ");
+}
+function firstDeclValue(root, prop) {
+	let found;
+	root.walkDecls(prop, (d) => {
+		found = d.value;
+		return false;
+	});
+	return found;
+}
+/**
+* Find the user-set `min-width:` value on a column. Juice keeps both ours
+* and the one inlined from a class like `min-w-1/3` — we skip any
+* min-width whose value still contains our placeholder token,
+* returning the first remaining user value, or null.
+*/
+function findUserMinWidth(root) {
+	let userVal = null;
+	root.walkDecls("min-width", (d) => {
+		if (!d.value.includes("__MAIZZLE_COLW_")) {
+			userVal = d.value;
+			return false;
+		}
+	});
+	return userVal;
+}
+function resolveLength(value) {
+	const trimmed = value.trim();
+	if (RE_PERCENT.test(trimmed)) return trimmed;
+	const m = trimmed.match(/^([\d.]+)(px|rem|em|pt)?$/i);
+	if (!m) return null;
+	const n = parseFloat(m[1]);
+	const unit = (m[2] || "px").toLowerCase();
+	return `${Math.round(n * (unit === "rem" || unit === "em" ? 16 : unit === "pt" ? 1.333 : 1))}px`;
+}
+function divideLength(value, divisor) {
+	const m = value.match(/^([\d.]+)(px|%)$/);
+	if (!m || divisor < 1) return null;
+	const n = parseFloat(m[1]);
+	return `${parseFloat((n / divisor).toFixed(2))}${m[2]}`;
+}
+function subtractInsetPx(width, insetPx) {
+	if (insetPx <= 0) return width;
+	const m = width.match(/^([\d.]+)(px|%)$/);
+	if (!m) return width;
+	if (m[2] === "%") return width;
+	const n = parseFloat(m[1]) - insetPx;
+	return `${Math.max(0, Math.round(n))}px`;
+}
+/**
+* Return the smaller of two px lengths. Clamps our count-based min-width
+* down to the user's `max-width:` so the cap is never silently
+* violated when our computed min would exceed the user's max.
+*/
+function minPxLength(a, b) {
+	const am = a.match(/^([\d.]+)px$/);
+	const bm = b.match(/^([\d.]+)px$/);
+	if (!am || !bm) return a;
+	return parseFloat(am[1]) < parseFloat(bm[1]) ? a : b;
+}
+function depth(node) {
+	let d = 0;
+	let cur = node.parent;
+	while (cur) {
+		d++;
+		cur = cur.parent ?? null;
+	}
+	return d;
+}
+function readWidthFromRoot(root) {
+	const raw = firstDeclValue(root, "max-width") ?? firstDeclValue(root, "width") ?? firstDeclValue(root, "min-width");
+	return raw ? resolveLength(raw) : null;
+}
+function readHeightFromRoot(root) {
+	const raw = firstDeclValue(root, "max-height") ?? firstDeclValue(root, "height") ?? firstDeclValue(root, "min-height");
+	return raw ? resolveLength(raw) : null;
+}
+function readWidthSource(el, root) {
+	const explicit = el.attribs?.["data-maizzle-cw"];
+	if (explicit) {
+		const r = resolveLength(explicit);
+		if (r) return r;
+	}
+	return root ? readWidthFromRoot(root) : null;
+}
+/**
+* Convert a user-supplied length to absolute px against the column's source
+* width (post-inset). Percentages multiply against the source while
+* absolute units pass through `resolveLength`. Returns null when
+* the value or source can't be expressed in px.
+*/
+function userValueToPx(rawValue, sourcePx) {
+	const trimmed = rawValue.trim();
+	if (trimmed.match(/^([\d.]+)(px|rem|em|pt)$/i)) return resolveLength(trimmed);
+	const pctMatch = trimmed.match(/^([\d.]+)%$/);
+	if (!pctMatch || !sourcePx) return null;
+	const sourceMatch = sourcePx.match(/^([\d.]+)px$/);
+	if (!sourceMatch) return null;
+	const pct = parseFloat(pctMatch[1]);
+	const src = parseFloat(sourceMatch[1]);
+	return `${Math.round(pct / 100 * src)}px`;
+}
+/**
+* Resolve `__MAIZZLE_COLW_{id}__` and `__MAIZZLE_OH_{id}__` placeholders.
+*
+* COLW (column width) — emitted by `<Column>` and `<Overlap>`. Walks up to
+* the nearest ancestor marked `data-maizzle-cw` (Container, Section,
+* Row, or another Column already resolved) and divides the source
+* width by `data-maizzle-cw-count`. With `data-maizzle-cw-self`,
+* reads from the element's own inlined max/width/min-width
+* instead — used by `<Overlap>` with its own width class.
+*
+* OH (overlap height) — emitted by `<Overlap>`. Reads max-height, height,
+* or min-height from the element's own inlined style.
+*
+* Resolution rules:
+* - Style placeholders for `min-width`: replaced when resolvable, otherwise
+*   the entire `min-width` declaration is stripped.
+* - Other style placeholders (Overlap td `width`, etc.): replaced when
+*   resolvable, otherwise replaced with the count-based fallback or `100%`.
+* - Comment placeholders: same fallback chain.
+*
+* Resolved column widths are written back to `data-maizzle-cw` so nested
+* rows cascade. All `data-maizzle-cw*` and `data-maizzle-oh-*` are
+* stripped at the end of the second walk pass.
+*/
+function columnWidth(dom) {
+	/**
+	* Cache parsed style ASTs for this columnWidth invocation. The walk-up
+	* loop visits the same Section/Container once per column of a Row,
+	* so without caching each column re-parses every ancestor's style.
+	* Cache is function-local — no cross-build leak via the WeakMap.
+	*/
+	const styleCache = /* @__PURE__ */ new WeakMap();
+	const parseElStyle = (el) => {
+		const cached = styleCache.get(el);
+		if (cached) return cached;
+		const style = el.attribs?.style ?? "";
+		const root = style ? safeParser(style) : postcss.root();
+		styleCache.set(el, root);
+		return root;
+	};
+	const columns = [];
+	const heightTargets = [];
+	walk(dom, (node) => {
+		const el = node;
+		if (!el.attribs) return;
+		const id = el.attribs["data-maizzle-cw-id"];
+		if (id) {
+			const count = parseInt(el.attribs["data-maizzle-cw-count"] || "1", 10);
+			const self = "data-maizzle-cw-self" in el.attribs;
+			columns.push({
+				el,
+				id,
+				count,
+				d: depth(node),
+				self
+			});
+		}
+		const ohId = el.attribs["data-maizzle-oh-id"];
+		if (ohId) heightTargets.push({
+			el,
+			id: ohId
+		});
+	});
+	columns.sort((a, b) => a.d - b.d);
+	const widthResolutions = /* @__PURE__ */ new Map();
+	const widthFallbacks = /* @__PURE__ */ new Map();
+	/**
+	* Column ids whose absolute user `width:` was promoted to `min-width:`
+	* — the original `width:` declaration must be stripped from the
+	* column's style (otherwise it'd compete with the min-width).
+	*/
+	const stripWidth = /* @__PURE__ */ new Set();
+	/**
+	* Column ids where the user wrote a percentage `width:` (e.g. `w-1/2`) —
+	* explicit opt-out of px-based stacking. Keep the user's `width: X%`
+	* and drop our `min-width:` placeholder so the column stays at
+	* that percentage of its parent forever and never stacks.
+	*/
+	const dropMinWidth = /* @__PURE__ */ new Set();
+	/**
+	* Column ids where the user wrote their own `min-width:` (via `min-w-1/3`).
+	* Juice inlines theirs after ours, so two `min-width:` decls land in
+	* the style — we strip the user's after using its value as the
+	* column's resolution, leaving our placeholder as last word.
+	*/
+	const stripUserMinWidth = /* @__PURE__ */ new Set();
+	/**
+	* Column ids where the user already supplied a `max-width:` of their own.
+	* Our default `max-width: 100%` would just be shadowed by it via
+	* last-wins and bloat the style — so we skip emitting it.
+	*/
+	const userHasMaxWidth = /* @__PURE__ */ new Set();
+	/**
+	* Horizontal padding+border (px) of each column whose width was auto-
+	* derived from count-based math. The column's own border/padding eats
+	* its content box under content-box sizing, so the emitted `width:`
+	* must be the slice MINUS this inset; otherwise two bordered cols
+	* sum past the container and wrap. Only populated for auto paths
+	* — user-explicit `width:`/`min-width:`/`max-width:`-wins paths
+	* leave the value alone so the user's number stays the user's.
+	*/
+	const autoColumnInsets = /* @__PURE__ */ new Map();
+	/**
+	* Extra inline-style decls that get stamped onto each column's MSO `<td>`
+	* via its COLTDX placeholder. Carries `background-color` (so Word
+	* paints the cell behind any padding area or whitespace, not just
+	* the div) and hoisted `padding*` decls (when no border is present
+	* — without one Word silently drops div padding, with one a td
+	* copy would double-pad). The div keeps both for modern clients
+	* since the MSO td is conditional-comment-only.
+	*/
+	const tdExtras = /* @__PURE__ */ new Map();
+	/**
+	* MSO td width override for hoisted columns. With padding on the td and
+	* CSS content-box sizing for table cells, td_outer = width + 2*pad,
+	* so we set td width to the slot MINUS 2*horizontal-padding to keep
+	* the cell at its outer slot. Skipped when the slot is a %.
+	*/
+	const hoistedTdWidths = /* @__PURE__ */ new Map();
+	for (const { id, count } of columns) widthFallbacks.set(id, `${Math.round(100 / Math.max(count, 1))}%`);
+	const groupInfos = /* @__PURE__ */ new Map();
+	for (const c of columns) {
+		if (c.self) continue;
+		const ownRoot = parseElStyle(c.el);
+		const ownInset = horizontalPaddingPx(ownRoot) + horizontalBorderPx(ownRoot);
+		let cls = {
+			kind: "auto",
+			pxOuter: 0,
+			pctOuter: 0
+		};
+		const userVal = findUserMinWidth(ownRoot) ?? firstDeclValue(ownRoot, "width");
+		if (userVal) {
+			const resolved = resolveLength(userVal);
+			if (resolved?.endsWith("px")) {
+				const px = lengthToPx(resolved);
+				if (px != null) cls = {
+					kind: "explicit",
+					pxOuter: px + ownInset,
+					pctOuter: 0
+				};
+			} else if (resolved?.endsWith("%")) cls = {
+				kind: "explicit",
+				pxOuter: ownInset,
+				pctOuter: parseFloat(resolved)
+			};
+		}
+		const parent = c.el.parent;
+		if (!parent) continue;
+		let info = groupInfos.get(parent);
+		if (!info) {
+			info = {
+				explicitPxOuterSum: 0,
+				explicitPctOuterSum: 0,
+				autoCount: 0
+			};
+			groupInfos.set(parent, info);
+		}
+		info.explicitPxOuterSum += cls.pxOuter;
+		info.explicitPctOuterSum += cls.pctOuter;
+		if (cls.kind === "auto") info.autoCount++;
+	}
+	for (const { el, id, count, self } of columns) {
+		const ownRoot = parseElStyle(el);
+		let sourceWidth = null;
+		let accumulatedInsetPx = 0;
+		if (self) {
+			sourceWidth = readWidthFromRoot(ownRoot);
+			accumulatedInsetPx = horizontalPaddingPx(ownRoot) + horizontalBorderPx(ownRoot);
+		} else {
+			/**
+			* Walk up through every ancestor with attribs, accumulating horizontal
+			* padding+border along the way (including the source). Stop at the
+			* first `data-maizzle-cw` ancestor whose width is resolvable.
+			* Markers without a resolvable width (Row emitted empty after
+			* Tailwind dropped a bogus class) shouldn't shadow a real
+			* width on a higher ancestor like `<Container>`.
+			*
+			* With CSS content-box this is technically generous toward the
+			* source's own padding/border, but matches user expectations
+			* when they put `px-9` or `border-2` on a wrapper.
+			*/
+			let cur = el.parent;
+			while (cur) {
+				const parentEl = cur;
+				if (parentEl.attribs) {
+					let pRoot = null;
+					if (parentEl.attribs.style) {
+						pRoot = parseElStyle(parentEl);
+						accumulatedInsetPx += horizontalPaddingPx(pRoot) + horizontalBorderPx(pRoot);
+					}
+					if ("data-maizzle-cw" in parentEl.attribs) {
+						const w = readWidthSource(parentEl, pRoot);
+						if (w) {
+							sourceWidth = w;
+							break;
+						}
+					}
+				}
+				cur = cur.parent ?? null;
+			}
+		}
+		const adjusted = sourceWidth ? subtractInsetPx(sourceWidth, accumulatedInsetPx) : null;
+		let countBased = adjusted ? divideLength(adjusted, count) : null;
+		/**
+		* Sibling-aware redistribution kicks in only when the auto col has at
+		* least one explicit-width sibling and the source is in px (can't
+		* mix px subtraction with a % source). When that's true, the auto
+		* col's share becomes `(source − sum_explicit_px − pct% of source)
+		* / autoCount`, replacing the naive `source/totalCount`.
+		*/
+		if (!self && adjusted?.endsWith("px") && countBased && el.parent) {
+			const group = groupInfos.get(el.parent);
+			if (group && group.autoCount > 0 && (group.explicitPxOuterSum > 0 || group.explicitPctOuterSum > 0)) {
+				const adjPx = lengthToPx(adjusted);
+				if (adjPx != null) {
+					const remaining = adjPx - group.explicitPxOuterSum - adjPx * group.explicitPctOuterSum / 100;
+					countBased = `${Math.max(0, Math.floor(remaining * 100 / group.autoCount) / 100)}px`;
+				}
+			}
+		}
+		/**
+		* Four user-override paths, decided by which CSS property the user
+		* actually wrote:
+		*
+		*   - `min-width: X` → user's value wins. Convert to px against
+		*                     the source (if %), use as the column's
+		*                     resolution, and strip the user's min-width
+		*                     declaration so our placeholder substitution
+		*                     remains the last `min-width:` in style.
+		*   - `width: X%`   → opt-out of px stacking. Keep `width:` in
+		*                     style, drop our `min-width:` placeholder.
+		*                     Cols stay at X% of parent forever, never stack.
+		*   - `width: Xpx` (or rem/em/pt) → fixed pixel column. Promote to
+		*                     `min-width:`, strip the original `width:` so
+		*                     it doesn't compete.
+		*   - `max-width: X` → CSS cap. Keep the `max-width:` declaration;
+		*                     clamp our count-based min-width *down* to
+		*                     the user's max-width when our min would
+		*                     otherwise violate it.
+		*/
+		const userMinRaw = findUserMinWidth(ownRoot);
+		const widthRaw = firstDeclValue(ownRoot, "width");
+		const maxRaw = firstDeclValue(ownRoot, "max-width");
+		if (userMinRaw) {
+			const minPx = userValueToPx(userMinRaw, adjusted) ?? resolveLength(userMinRaw);
+			if (minPx) {
+				widthResolutions.set(id, minPx);
+				el.attribs["data-maizzle-cw"] = minPx;
+				stripUserMinWidth.add(id);
+				continue;
+			}
+		}
+		if (widthRaw) {
+			const widthVal = resolveLength(widthRaw);
+			if (widthVal?.endsWith("%")) {
+				widthResolutions.set(id, widthVal);
+				el.attribs["data-maizzle-cw"] = widthVal;
+				dropMinWidth.add(id);
+				continue;
+			}
+			if (widthVal) {
+				widthResolutions.set(id, widthVal);
+				el.attribs["data-maizzle-cw"] = widthVal;
+				stripWidth.add(id);
+				continue;
+			}
+		}
+		if (maxRaw && countBased) {
+			const maxPx = userValueToPx(maxRaw, adjusted);
+			if (maxPx) {
+				const cappedMin = countBased.endsWith("px") ? minPxLength(countBased, maxPx) : maxPx;
+				widthResolutions.set(id, cappedMin);
+				el.attribs["data-maizzle-cw"] = cappedMin;
+				userHasMaxWidth.add(id);
+				if (cappedMin === countBased) {
+					const ownInset = horizontalPaddingPx(ownRoot) + horizontalBorderPx(ownRoot);
+					if (ownInset > 0) autoColumnInsets.set(id, ownInset);
+				}
+				continue;
+			}
+		}
+		if (countBased) {
+			widthResolutions.set(id, countBased);
+			el.attribs["data-maizzle-cw"] = countBased;
+			const ownPaddingPx = horizontalPaddingPx(ownRoot);
+			const ownBorderPx = horizontalBorderPx(ownRoot);
+			const ownInset = ownPaddingPx + ownBorderPx;
+			if (ownInset > 0) autoColumnInsets.set(id, ownInset);
+			/**
+			* Build the MSO td's "extras" string — decls that need to live on
+			* the td in addition to width + vertical-align. Two contributors:
+			*
+			*   - `background-color` (always, when present) — Word renders the
+			*     div bg inside the cell, but anything outside the div (the
+			*     td's padding area when hoisted, or any whitespace gap)
+			*     would show the parent's bg instead of the column's. Painting
+			*     the td matches the user's intent.
+			*
+			*   - `padding*` (hoisted only when no horizontal border) — Word
+			*     drops div padding without a stabilizing border, so the td
+			*     has to carry it. With a border, Word renders div padding
+			*     and a td copy would double-pad. Skip when the slot is `%`:
+			*     td width math can't subtract px padding from a percentage.
+			*/
+			const extras = [];
+			let bgColor;
+			ownRoot.walkDecls("background-color", (d) => {
+				bgColor = d.value;
+			});
+			if (bgColor) extras.push(`background-color: ${bgColor}`);
+			if (ownPaddingPx > 0 && ownBorderPx === 0 && countBased.endsWith("px")) {
+				ownRoot.walkDecls((d) => {
+					if (/^padding(-|$)/.test(d.prop)) extras.push(`${d.prop}: ${d.value}`);
+				});
+				hoistedTdWidths.set(id, subtractInsetPx(countBased, ownPaddingPx));
+			}
+			if (extras.length) tdExtras.set(id, extras.join("; "));
+		}
+	}
+	const heightResolutions = /* @__PURE__ */ new Map();
+	for (const { el, id } of heightTargets) {
+		if (!el.attribs?.style) continue;
+		const h = readHeightFromRoot(parseElStyle(el));
+		if (h) heightResolutions.set(id, h);
+	}
+	walk(dom, (node) => {
+		if (node.type === "comment") {
+			const data = node.data;
+			if (!data) return;
+			const hasCW = data.includes("__MAIZZLE_COLW_");
+			const hasOH = data.includes("__MAIZZLE_OH_");
+			const hasTDX = data.includes("__MAIZZLE_COLTDX_");
+			if (!hasCW && !hasOH && !hasTDX) return;
+			node.data = data.replace(/__MAIZZLE_COLW_([^_]+)__/g, (_m, mid) => hoistedTdWidths.get(mid) ?? widthResolutions.get(mid) ?? widthFallbacks.get(mid) ?? "100%").replace(/;\s*__MAIZZLE_COLTDX_([^_]+)__/g, (_m, mid) => {
+				const pad = tdExtras.get(mid);
+				return pad ? `; ${pad}` : "";
+			}).replace(/__MAIZZLE_OH_([^_]+)__/g, (_m, hid) => heightResolutions.get(hid) ?? "100%");
+			return;
+		}
+		const el = node;
+		if (!el.attribs) return;
+		const style = el.attribs.style;
+		if (style && (style.includes("__MAIZZLE_COLW_") || style.includes("__MAIZZLE_OH_"))) {
+			const root = parseElStyle(el);
+			const cwId = el.attribs["data-maizzle-cw-id"];
+			/**
+			* Strip user dups BEFORE substitution — last-wins CSS would
+			* otherwise shadow our resolved values in the output.
+			*/
+			if (cwId && stripUserMinWidth.has(cwId)) root.walkDecls("min-width", (d) => {
+				if (!d.value.includes("__MAIZZLE_COLW_")) d.remove();
+			});
+			if (cwId && stripWidth.has(cwId)) root.walkDecls("width", (d) => {
+				d.remove();
+			});
+			/**
+			* Substitute the column's `min-width:` placeholder with `width: <res>;
+			* max-width: 100%`. Width gives the same stacking trigger as
+			* min-width — inline-block wraps when children sum > parent
+			* — and the `max-width: 100%` clamp keeps the column from
+			* overflowing the viewport once it drops to its own row on
+			* mobile. Skip the clamp when the user supplied their own.
+			*
+			* Other placeholders (Overlap td `width`, comment markers,
+			* OH height) get a plain value substitution.
+			*/
+			root.walkDecls((d) => {
+				if (d.prop === "min-width") {
+					const m = d.value.match(/^__MAIZZLE_COLW_([^_]+)__$/);
+					if (m) {
+						const mid = m[1];
+						if (dropMinWidth.has(mid) || !widthResolutions.has(mid)) {
+							d.remove();
+							return;
+						}
+						let resolved = widthResolutions.get(mid);
+						const inset = autoColumnInsets.get(mid);
+						if (inset) resolved = subtractInsetPx(resolved, inset);
+						const repl = [postcss.decl({
+							prop: "width",
+							value: resolved
+						})];
+						if (!userHasMaxWidth.has(mid)) repl.push(postcss.decl({
+							prop: "max-width",
+							value: "100%"
+						}));
+						d.replaceWith(...repl);
+						return;
+					}
+				}
+				if (d.value.includes("__MAIZZLE_COLW_") || d.value.includes("__MAIZZLE_OH_")) d.value = d.value.replace(/__MAIZZLE_COLW_([^_]+)__/g, (_m, mid) => widthResolutions.get(mid) ?? widthFallbacks.get(mid) ?? "100%").replace(/__MAIZZLE_OH_([^_]+)__/g, (_m, hid) => heightResolutions.get(hid) ?? "100%");
+			});
+			const out = serializeStyle(root);
+			if (out) el.attribs.style = out;
+			else delete el.attribs.style;
+		}
+		delete el.attribs["data-maizzle-cw"];
+		delete el.attribs["data-maizzle-cw-id"];
+		delete el.attribs["data-maizzle-cw-count"];
+		delete el.attribs["data-maizzle-cw-self"];
+		delete el.attribs["data-maizzle-oh-id"];
+	});
+	return dom;
+}
+//#endregion
+export { columnWidth };
+
+//# sourceMappingURL=columnWidth.js.map

package/dist/transformers/columnWidth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"columnWidth.js","names":[],"sources":["../../src/transformers/columnWidth.ts"],"sourcesContent":["import postcss, { type Root, type Declaration } from 'postcss'\nimport safeParser from 'postcss-safe-parser'\nimport { walk } from '../utils/ast/index.ts'\nimport { horizontalBorderPx, horizontalPaddingPx, lengthToPx } from '../utils/cssBox.ts'\nimport type { ChildNode, Element, ParentNode } from 'domhandler'\n\nconst RE_PERCENT = /^[\\d.]+%$/\n\n/**\n * Stringify decls into a `; `-joined inline-style attribute. PostCSS raws\n * preserve the original source spacing, which mixes poorly with\n * the fresh decls we inject — plain join keeps output uniform.\n */\nfunction serializeStyle(root: Root): string {\n  const parts: string[] = []\n  root.walkDecls((d) => {\n    parts.push(`${d.prop}: ${d.value}${d.important ? ' !important' : ''}`)\n  })\n  return parts.join('; ')\n}\n\nfunction firstDeclValue(root: Root, prop: string): string | undefined {\n  let found: string | undefined\n  root.walkDecls(prop, (d) => {\n    found = d.value\n    return false\n  })\n  return found\n}\n\n/**\n * Find the user-set `min-width:` value on a column. Juice keeps both ours\n * and the one inlined from a class like `min-w-1/3` — we skip any\n * min-width whose value still contains our placeholder token,\n * returning the first remaining user value, or null.\n */\nfunction findUserMinWidth(root: Root): string | null {\n  let userVal: string | null = null\n  root.walkDecls('min-width', (d) => {\n    if (!d.value.includes('__MAIZZLE_COLW_')) {\n      userVal = d.value\n      return false\n    }\n  })\n  return userVal\n}\n\nfunction resolveLength(value: string): string | null {\n  const trimmed = value.trim()\n  if (RE_PERCENT.test(trimmed)) return trimmed\n  const m = trimmed.match(/^([\\d.]+)(px|rem|em|pt)?$/i)\n  if (!m) return null\n  const n = parseFloat(m[1])\n  const unit = (m[2] || 'px').toLowerCase()\n  const factor = unit === 'rem' || unit === 'em' ? 16 : unit === 'pt' ? 1.333 : 1\n  return `${Math.round(n * factor)}px`\n}\n\nfunction divideLength(value: string, divisor: number): string | null {\n  const m = value.match(/^([\\d.]+)(px|%)$/)\n  if (!m || divisor < 1) return null\n  const n = parseFloat(m[1])\n  return `${parseFloat((n / divisor).toFixed(2))}${m[2]}`\n}\n\nfunction subtractInsetPx(width: string, insetPx: number): string {\n  if (insetPx <= 0) return width\n  const m = width.match(/^([\\d.]+)(px|%)$/)\n  if (!m) return width\n  // Don't subtract px from percentage widths — units don't match.\n  if (m[2] === '%') return width\n  const n = parseFloat(m[1]) - insetPx\n  return `${Math.max(0, Math.round(n))}px`\n}\n\n/**\n * Return the smaller of two px lengths. Clamps our count-based min-width\n * down to the user's `max-width:` so the cap is never silently\n * violated when our computed min would exceed the user's max.\n */\nfunction minPxLength(a: string, b: string): string {\n  const am = a.match(/^([\\d.]+)px$/)\n  const bm = b.match(/^([\\d.]+)px$/)\n  if (!am || !bm) return a\n  return parseFloat(am[1]) < parseFloat(bm[1]) ? a : b\n}\n\nfunction depth(node: ChildNode): number {\n  let d = 0\n  let cur: ParentNode | null = node.parent\n  while (cur) {\n    d++\n    cur = (cur as any).parent ?? null\n  }\n  return d\n}\n\nfunction readWidthFromRoot(root: Root): string | null {\n  const raw = firstDeclValue(root, 'max-width')\n    ?? firstDeclValue(root, 'width')\n    ?? firstDeclValue(root, 'min-width')\n  return raw ? resolveLength(raw) : null\n}\n\nfunction readHeightFromRoot(root: Root): string | null {\n  const raw = firstDeclValue(root, 'max-height')\n    ?? firstDeclValue(root, 'height')\n    ?? firstDeclValue(root, 'min-height')\n  return raw ? resolveLength(raw) : null\n}\n\nfunction readWidthSource(el: Element, root: Root | null): string | null {\n  const explicit = el.attribs?.['data-maizzle-cw']\n  if (explicit) {\n    const r = resolveLength(explicit)\n    if (r) return r\n  }\n  return root ? readWidthFromRoot(root) : null\n}\n\n/**\n * Convert a user-supplied length to absolute px against the column's source\n * width (post-inset). Percentages multiply against the source while\n * absolute units pass through `resolveLength`. Returns null when\n * the value or source can't be expressed in px.\n */\nfunction userValueToPx(rawValue: string, sourcePx: string | null): string | null {\n  const trimmed = rawValue.trim()\n\n  const absMatch = trimmed.match(/^([\\d.]+)(px|rem|em|pt)$/i)\n  if (absMatch) return resolveLength(trimmed)\n\n  const pctMatch = trimmed.match(/^([\\d.]+)%$/)\n  if (!pctMatch || !sourcePx) return null\n  const sourceMatch = sourcePx.match(/^([\\d.]+)px$/)\n  if (!sourceMatch) return null\n  const pct = parseFloat(pctMatch[1])\n  const src = parseFloat(sourceMatch[1])\n  return `${Math.round((pct / 100) * src)}px`\n}\n\n/**\n * Resolve `__MAIZZLE_COLW_{id}__` and `__MAIZZLE_OH_{id}__` placeholders.\n *\n * COLW (column width) — emitted by `<Column>` and `<Overlap>`. Walks up to\n * the nearest ancestor marked `data-maizzle-cw` (Container, Section,\n * Row, or another Column already resolved) and divides the source\n * width by `data-maizzle-cw-count`. With `data-maizzle-cw-self`,\n * reads from the element's own inlined max/width/min-width\n * instead — used by `<Overlap>` with its own width class.\n *\n * OH (overlap height) — emitted by `<Overlap>`. Reads max-height, height,\n * or min-height from the element's own inlined style.\n *\n * Resolution rules:\n * - Style placeholders for `min-width`: replaced when resolvable, otherwise\n *   the entire `min-width` declaration is stripped.\n * - Other style placeholders (Overlap td `width`, etc.): replaced when\n *   resolvable, otherwise replaced with the count-based fallback or `100%`.\n * - Comment placeholders: same fallback chain.\n *\n * Resolved column widths are written back to `data-maizzle-cw` so nested\n * rows cascade. All `data-maizzle-cw*` and `data-maizzle-oh-*` are\n * stripped at the end of the second walk pass.\n */\nexport function columnWidth(dom: ChildNode[]): ChildNode[] {\n  /**\n   * Cache parsed style ASTs for this columnWidth invocation. The walk-up\n   * loop visits the same Section/Container once per column of a Row,\n   * so without caching each column re-parses every ancestor's style.\n   * Cache is function-local — no cross-build leak via the WeakMap.\n   */\n  const styleCache = new WeakMap<Element, Root>()\n  const parseElStyle = (el: Element): Root => {\n    const cached = styleCache.get(el)\n    if (cached) return cached\n    const style = el.attribs?.style ?? ''\n    const root = style ? safeParser(style) : postcss.root()\n    styleCache.set(el, root)\n    return root\n  }\n\n  const columns: { el: Element; id: string; count: number; d: number; self: boolean }[] = []\n  const heightTargets: { el: Element; id: string }[] = []\n\n  walk(dom, (node) => {\n    const el = node as Element\n    if (!el.attribs) return\n\n    const id = el.attribs['data-maizzle-cw-id']\n    if (id) {\n      const count = parseInt(el.attribs['data-maizzle-cw-count'] || '1', 10)\n      const self = 'data-maizzle-cw-self' in el.attribs\n      columns.push({ el, id, count, d: depth(node), self })\n    }\n\n    const ohId = el.attribs['data-maizzle-oh-id']\n    if (ohId) heightTargets.push({ el, id: ohId })\n  })\n\n  columns.sort((a, b) => a.d - b.d)\n\n  const widthResolutions = new Map<string, string>()\n  const widthFallbacks = new Map<string, string>()\n  /**\n   * Column ids whose absolute user `width:` was promoted to `min-width:`\n   * — the original `width:` declaration must be stripped from the\n   * column's style (otherwise it'd compete with the min-width).\n   */\n  const stripWidth = new Set<string>()\n  /**\n   * Column ids where the user wrote a percentage `width:` (e.g. `w-1/2`) —\n   * explicit opt-out of px-based stacking. Keep the user's `width: X%`\n   * and drop our `min-width:` placeholder so the column stays at\n   * that percentage of its parent forever and never stacks.\n   */\n  const dropMinWidth = new Set<string>()\n  /**\n   * Column ids where the user wrote their own `min-width:` (via `min-w-1/3`).\n   * Juice inlines theirs after ours, so two `min-width:` decls land in\n   * the style — we strip the user's after using its value as the\n   * column's resolution, leaving our placeholder as last word.\n   */\n  const stripUserMinWidth = new Set<string>()\n  /**\n   * Column ids where the user already supplied a `max-width:` of their own.\n   * Our default `max-width: 100%` would just be shadowed by it via\n   * last-wins and bloat the style — so we skip emitting it.\n   */\n  const userHasMaxWidth = new Set<string>()\n  /**\n   * Horizontal padding+border (px) of each column whose width was auto-\n   * derived from count-based math. The column's own border/padding eats\n   * its content box under content-box sizing, so the emitted `width:`\n   * must be the slice MINUS this inset; otherwise two bordered cols\n   * sum past the container and wrap. Only populated for auto paths\n   * — user-explicit `width:`/`min-width:`/`max-width:`-wins paths\n   * leave the value alone so the user's number stays the user's.\n   */\n  const autoColumnInsets = new Map<string, number>()\n  /**\n   * Extra inline-style decls that get stamped onto each column's MSO `<td>`\n   * via its COLTDX placeholder. Carries `background-color` (so Word\n   * paints the cell behind any padding area or whitespace, not just\n   * the div) and hoisted `padding*` decls (when no border is present\n   * — without one Word silently drops div padding, with one a td\n   * copy would double-pad). The div keeps both for modern clients\n   * since the MSO td is conditional-comment-only.\n   */\n  const tdExtras = new Map<string, string>()\n  /**\n   * MSO td width override for hoisted columns. With padding on the td and\n   * CSS content-box sizing for table cells, td_outer = width + 2*pad,\n   * so we set td width to the slot MINUS 2*horizontal-padding to keep\n   * the cell at its outer slot. Skipped when the slot is a %.\n   */\n  const hoistedTdWidths = new Map<string, string>()\n\n  for (const { id, count } of columns) {\n    widthFallbacks.set(id, `${Math.round(100 / Math.max(count, 1))}%`)\n  }\n\n  /**\n   * Sibling-aware redistribution.\n   *\n   * Without this, every auto column slices its source `/ totalCount`,\n   * ignoring siblings that already declared a fixed `w-5` (20px) or\n   * `w-1/3` (%). Three auto cols next to a `w-5` would each take\n   * `source/3` and overflow the row by 20px.\n   *\n   * Pre-pass: classify each col against its inlined style.\n   *   - explicit-px:  `width:` or `min-width:` resolving to px. The col\n   *                   occupies (px value + own horizontal padding +\n   *                   own horizontal border) of the source.\n   *   - explicit-pct: `width:` or `min-width:` resolving to %. The col\n   *                   occupies (pct * source / 100 + own inset).\n   *   - auto:         everything else. Shares the remainder with other\n   *                   auto siblings.\n   *\n   * Group cols by their immediate `el.parent` (the Row div). For each\n   * group, sum the explicit contributions and count the autos. The\n   * countBased path below uses these to redistribute leftover space\n   * instead of dividing the raw source by total count.\n   *\n   * `data-maizzle-cw-self` cols (Overlap) are excluded — they own their\n   * source independently and don't share a parent's slot with cols.\n   */\n  interface ColClassification {\n    kind: 'auto' | 'explicit'\n    pxOuter: number\n    pctOuter: number\n  }\n  interface GroupInfo {\n    explicitPxOuterSum: number\n    explicitPctOuterSum: number\n    autoCount: number\n  }\n  const groupInfos = new Map<ParentNode, GroupInfo>()\n\n  for (const c of columns) {\n    if (c.self) continue\n    const ownRoot = parseElStyle(c.el)\n    const ownInset = horizontalPaddingPx(ownRoot) + horizontalBorderPx(ownRoot)\n\n    let cls: ColClassification = { kind: 'auto', pxOuter: 0, pctOuter: 0 }\n    const userVal = findUserMinWidth(ownRoot) ?? firstDeclValue(ownRoot, 'width')\n    if (userVal) {\n      const resolved = resolveLength(userVal)\n      if (resolved?.endsWith('px')) {\n        const px = lengthToPx(resolved)\n        if (px != null) cls = { kind: 'explicit', pxOuter: px + ownInset, pctOuter: 0 }\n      }\n      else if (resolved?.endsWith('%')) {\n        cls = { kind: 'explicit', pxOuter: ownInset, pctOuter: parseFloat(resolved) }\n      }\n    }\n\n    const parent = c.el.parent as ParentNode | null\n    if (!parent) continue\n    let info = groupInfos.get(parent)\n    if (!info) {\n      info = { explicitPxOuterSum: 0, explicitPctOuterSum: 0, autoCount: 0 }\n      groupInfos.set(parent, info)\n    }\n    info.explicitPxOuterSum += cls.pxOuter\n    info.explicitPctOuterSum += cls.pctOuter\n    if (cls.kind === 'auto') info.autoCount++\n  }\n\n  for (const { el, id, count, self } of columns) {\n    const ownRoot = parseElStyle(el)\n\n    let sourceWidth: string | null = null\n    let accumulatedInsetPx = 0\n\n    if (self) {\n      sourceWidth = readWidthFromRoot(ownRoot)\n      accumulatedInsetPx = horizontalPaddingPx(ownRoot) + horizontalBorderPx(ownRoot)\n    }\n    else {\n      /**\n       * Walk up through every ancestor with attribs, accumulating horizontal\n       * padding+border along the way (including the source). Stop at the\n       * first `data-maizzle-cw` ancestor whose width is resolvable.\n       * Markers without a resolvable width (Row emitted empty after\n       * Tailwind dropped a bogus class) shouldn't shadow a real\n       * width on a higher ancestor like `<Container>`.\n       *\n       * With CSS content-box this is technically generous toward the\n       * source's own padding/border, but matches user expectations\n       * when they put `px-9` or `border-2` on a wrapper.\n       */\n      let cur: ParentNode | null = el.parent\n      while (cur) {\n        const parentEl = cur as Element\n        if (parentEl.attribs) {\n          let pRoot: Root | null = null\n          if (parentEl.attribs.style) {\n            pRoot = parseElStyle(parentEl)\n            accumulatedInsetPx += horizontalPaddingPx(pRoot) + horizontalBorderPx(pRoot)\n          }\n          if ('data-maizzle-cw' in parentEl.attribs) {\n            const w = readWidthSource(parentEl, pRoot)\n            if (w) {\n              sourceWidth = w\n              break\n            }\n          }\n        }\n        cur = (cur as any).parent ?? null\n      }\n    }\n\n    const adjusted = sourceWidth ? subtractInsetPx(sourceWidth, accumulatedInsetPx) : null\n    let countBased = adjusted ? divideLength(adjusted, count) : null\n\n    /**\n     * Sibling-aware redistribution kicks in only when the auto col has at\n     * least one explicit-width sibling and the source is in px (can't\n     * mix px subtraction with a % source). When that's true, the auto\n     * col's share becomes `(source − sum_explicit_px − pct% of source)\n     * / autoCount`, replacing the naive `source/totalCount`.\n     */\n    if (!self && adjusted?.endsWith('px') && countBased && el.parent) {\n      const group = groupInfos.get(el.parent as ParentNode)\n      if (group && group.autoCount > 0\n        && (group.explicitPxOuterSum > 0 || group.explicitPctOuterSum > 0)) {\n        const adjPx = lengthToPx(adjusted)\n        if (adjPx != null) {\n          const remaining = adjPx - group.explicitPxOuterSum - (adjPx * group.explicitPctOuterSum / 100)\n          /**\n           * Floor-to-2-decimals on the per-auto share. Two reasons:\n           *\n           *   1. Matches `divideLength`'s precision so the auto path and\n           *      group-aware path emit consistent units.\n           *   2. Rounding up (e.g. 536/3 = 178.6̄ → round to 179) pushes\n           *      the sum past the slot — 3×179 + 2×20 = 577 > 576 →\n           *      inline-block wraps and the row stacks. Flooring at 2\n           *      decimals keeps the sum ≤ slot with at most ~0.0(autoCount)\n           *      px unused, which is sub-pixel and invisible.\n           */\n          const share = Math.max(0, Math.floor((remaining * 100) / group.autoCount) / 100)\n          countBased = `${share}px`\n        }\n      }\n    }\n\n    /**\n     * Four user-override paths, decided by which CSS property the user\n     * actually wrote:\n     *\n     *   - `min-width: X` → user's value wins. Convert to px against\n     *                     the source (if %), use as the column's\n     *                     resolution, and strip the user's min-width\n     *                     declaration so our placeholder substitution\n     *                     remains the last `min-width:` in style.\n     *   - `width: X%`   → opt-out of px stacking. Keep `width:` in\n     *                     style, drop our `min-width:` placeholder.\n     *                     Cols stay at X% of parent forever, never stack.\n     *   - `width: Xpx` (or rem/em/pt) → fixed pixel column. Promote to\n     *                     `min-width:`, strip the original `width:` so\n     *                     it doesn't compete.\n     *   - `max-width: X` → CSS cap. Keep the `max-width:` declaration;\n     *                     clamp our count-based min-width *down* to\n     *                     the user's max-width when our min would\n     *                     otherwise violate it.\n     */\n    const userMinRaw = findUserMinWidth(ownRoot)\n    const widthRaw = firstDeclValue(ownRoot, 'width')\n    const maxRaw = firstDeclValue(ownRoot, 'max-width')\n\n    if (userMinRaw) {\n      const minPx = userValueToPx(userMinRaw, adjusted) ?? resolveLength(userMinRaw)\n      if (minPx) {\n        widthResolutions.set(id, minPx)\n        el.attribs['data-maizzle-cw'] = minPx\n        stripUserMinWidth.add(id)\n        continue\n      }\n    }\n\n    if (widthRaw) {\n      const widthVal = resolveLength(widthRaw)\n      if (widthVal?.endsWith('%')) {\n        widthResolutions.set(id, widthVal)\n        el.attribs['data-maizzle-cw'] = widthVal\n        dropMinWidth.add(id)\n        continue\n      }\n      if (widthVal) {\n        widthResolutions.set(id, widthVal)\n        el.attribs['data-maizzle-cw'] = widthVal\n        stripWidth.add(id)\n        continue\n      }\n    }\n\n    if (maxRaw && countBased) {\n      const maxPx = userValueToPx(maxRaw, adjusted)\n      if (maxPx) {\n        const cappedMin = countBased.endsWith('px')\n          ? minPxLength(countBased, maxPx)\n          : maxPx\n        widthResolutions.set(id, cappedMin)\n        el.attribs['data-maizzle-cw'] = cappedMin\n        userHasMaxWidth.add(id)\n        if (cappedMin === countBased) {\n          const ownInset = horizontalPaddingPx(ownRoot) + horizontalBorderPx(ownRoot)\n          if (ownInset > 0) autoColumnInsets.set(id, ownInset)\n        }\n        continue\n      }\n    }\n\n    if (countBased) {\n      widthResolutions.set(id, countBased)\n      el.attribs['data-maizzle-cw'] = countBased\n      const ownPaddingPx = horizontalPaddingPx(ownRoot)\n      const ownBorderPx = horizontalBorderPx(ownRoot)\n      const ownInset = ownPaddingPx + ownBorderPx\n      if (ownInset > 0) autoColumnInsets.set(id, ownInset)\n\n      /**\n       * Build the MSO td's \"extras\" string — decls that need to live on\n       * the td in addition to width + vertical-align. Two contributors:\n       *\n       *   - `background-color` (always, when present) — Word renders the\n       *     div bg inside the cell, but anything outside the div (the\n       *     td's padding area when hoisted, or any whitespace gap)\n       *     would show the parent's bg instead of the column's. Painting\n       *     the td matches the user's intent.\n       *\n       *   - `padding*` (hoisted only when no horizontal border) — Word\n       *     drops div padding without a stabilizing border, so the td\n       *     has to carry it. With a border, Word renders div padding\n       *     and a td copy would double-pad. Skip when the slot is `%`:\n       *     td width math can't subtract px padding from a percentage.\n       */\n      const extras: string[] = []\n      let bgColor: string | undefined\n      ownRoot.walkDecls('background-color', (d) => { bgColor = d.value })\n      if (bgColor) extras.push(`background-color: ${bgColor}`)\n\n      if (ownPaddingPx > 0 && ownBorderPx === 0 && countBased.endsWith('px')) {\n        ownRoot.walkDecls((d) => {\n          if (/^padding(-|$)/.test(d.prop)) extras.push(`${d.prop}: ${d.value}`)\n        })\n        hoistedTdWidths.set(id, subtractInsetPx(countBased, ownPaddingPx))\n      }\n\n      if (extras.length) tdExtras.set(id, extras.join('; '))\n    }\n  }\n\n  const heightResolutions = new Map<string, string>()\n  for (const { el, id } of heightTargets) {\n    if (!el.attribs?.style) continue\n    const h = readHeightFromRoot(parseElStyle(el))\n    if (h) heightResolutions.set(id, h)\n  }\n\n  walk(dom, (node) => {\n    if (node.type === 'comment') {\n      const data = (node as any).data as string\n      if (!data) return\n      const hasCW = data.includes('__MAIZZLE_COLW_')\n      const hasOH = data.includes('__MAIZZLE_OH_')\n      const hasTDX = data.includes('__MAIZZLE_COLTDX_')\n      if (!hasCW && !hasOH && !hasTDX) return\n      ;(node as any).data = data\n        .replace(/__MAIZZLE_COLW_([^_]+)__/g,\n          (_m, mid) => hoistedTdWidths.get(mid) ?? widthResolutions.get(mid) ?? widthFallbacks.get(mid) ?? '100%')\n        .replace(/;\\s*__MAIZZLE_COLTDX_([^_]+)__/g,\n          (_m, mid) => {\n            const pad = tdExtras.get(mid)\n            return pad ? `; ${pad}` : ''\n          })\n        .replace(/__MAIZZLE_OH_([^_]+)__/g,\n          (_m, hid) => heightResolutions.get(hid) ?? '100%')\n      return\n    }\n\n    const el = node as Element\n    if (!el.attribs) return\n\n    const style = el.attribs.style\n    if (style && (style.includes('__MAIZZLE_COLW_') || style.includes('__MAIZZLE_OH_'))) {\n      const root = parseElStyle(el)\n      const cwId = el.attribs['data-maizzle-cw-id']\n\n      /**\n       * Strip user dups BEFORE substitution — last-wins CSS would\n       * otherwise shadow our resolved values in the output.\n       */\n      if (cwId && stripUserMinWidth.has(cwId)) {\n        root.walkDecls('min-width', (d) => {\n          if (!d.value.includes('__MAIZZLE_COLW_')) d.remove()\n        })\n      }\n      if (cwId && stripWidth.has(cwId)) {\n        root.walkDecls('width', (d) => { d.remove() })\n      }\n\n      /**\n       * Substitute the column's `min-width:` placeholder with `width: <res>;\n       * max-width: 100%`. Width gives the same stacking trigger as\n       * min-width — inline-block wraps when children sum > parent\n       * — and the `max-width: 100%` clamp keeps the column from\n       * overflowing the viewport once it drops to its own row on\n       * mobile. Skip the clamp when the user supplied their own.\n       *\n       * Other placeholders (Overlap td `width`, comment markers,\n       * OH height) get a plain value substitution.\n       */\n      root.walkDecls((d) => {\n        if (d.prop === 'min-width') {\n          const m = d.value.match(/^__MAIZZLE_COLW_([^_]+)__$/)\n          if (m) {\n            const mid = m[1]\n            if (dropMinWidth.has(mid) || !widthResolutions.has(mid)) {\n              d.remove()\n              return\n            }\n            let resolved = widthResolutions.get(mid)!\n            const inset = autoColumnInsets.get(mid)\n            if (inset) resolved = subtractInsetPx(resolved, inset)\n            const repl: Declaration[] = [postcss.decl({ prop: 'width', value: resolved })]\n            if (!userHasMaxWidth.has(mid)) {\n              repl.push(postcss.decl({ prop: 'max-width', value: '100%' }))\n            }\n            d.replaceWith(...repl)\n            return\n          }\n        }\n        if (d.value.includes('__MAIZZLE_COLW_') || d.value.includes('__MAIZZLE_OH_')) {\n          d.value = d.value\n            .replace(/__MAIZZLE_COLW_([^_]+)__/g,\n              (_m, mid) => widthResolutions.get(mid) ?? widthFallbacks.get(mid) ?? '100%')\n            .replace(/__MAIZZLE_OH_([^_]+)__/g,\n              (_m, hid) => heightResolutions.get(hid) ?? '100%')\n        }\n      })\n\n      const out = serializeStyle(root)\n      if (out) el.attribs.style = out\n      else delete el.attribs.style\n    }\n\n    delete el.attribs['data-maizzle-cw']\n    delete el.attribs['data-maizzle-cw-id']\n    delete el.attribs['data-maizzle-cw-count']\n    delete el.attribs['data-maizzle-cw-self']\n    delete el.attribs['data-maizzle-oh-id']\n  })\n\n  return dom\n}\n"],"mappings":"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"}

package/dist/transformers/entities.d.ts

@@ -0,0 +1,37 @@
+import { EntitiesConfig } from "../types/config.js";
+import { ChildNode } from "domhandler";
+
+//#region src/transformers/entities.d.ts
+/**
+ * Replace literal Unicode characters in text nodes with their HTML entity
+ * equivalents (zero-width joiners, non-breaking spaces, smart quotes,
+ * dashes, etc.) for better email-client rendering.
+ *
+ * @param html   HTML string to transform.
+ * @param custom Extra entries merged on top of the built-in entity map, or
+ *               `false` to disable the transform. Defaults to `true`
+ *               (built-ins only).
+ * @returns      The transformed HTML string.
+ *
+ * @example
+ * import { entities } from '@maizzle/framework'
+ *
+ * // Defaults only
+ * entities('hello world') // → 'hello world'
+ *
+ * // Add a custom mapping
+ * entities('© Maizzle', { '©': '©' })
+ *
+ * // Disable the transform
+ * entities('hello world', false)
+ */
+declare function entities(html: string, custom?: EntitiesConfig): string;
+/**
+ * DOM-form of {@link entities} used by the internal transformer pipeline.
+ * Takes a parsed DOM, returns a parsed DOM — avoids redundant
+ * serialize/parse round-trips when chained with other transformers.
+ */
+declare function entitiesDom(dom: ChildNode[], custom?: EntitiesConfig): ChildNode[];
+//#endregion
+export { entities, entitiesDom };
+//# sourceMappingURL=entities.d.ts.map