@maizzle/framework 6.0.0-rc.9 → 6.0.0

package/dist/transformers/msoPlaceholders.js

@@ -0,0 +1,114 @@
+import { walk } from "../utils/ast/walker.js";
+import "../utils/ast/index.js";
+import { horizontalBorderPx } from "../utils/cssBox.js";
+import safeParser from "postcss-safe-parser";
+//#region src/transformers/msoPlaceholders.ts
+const RE_MAX_WIDTH = /(?:^|;\s*)max-width:\s*([^;]+)/i;
+const RE_WIDTH = /(?:^|;\s*)width:\s*([^;]+)/i;
+const RE_PERCENT = /^[\d.]+%$/;
+function resolveWidth(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`;
+}
+/**
+* Resolve all `__MAIZZLE_MSO*__` placeholders inside MSO conditional comments
+* by reading inlined style + `data-*` markers on the paired elements.
+*
+* Two placeholder families:
+*
+* MSOW (`__MAIZZLE_MSOW_{id}__`) — emitted by `<Container>` and `<Section>`.
+*   Source element is marked with `data-maizzle-msow-id`. Reads inlined
+*   `max-width:` (falls back to `width:`) and normalizes to px. Falls
+*   back to `data-maizzle-msow-fallback` (default `600px`) when the
+*   value can't be parsed.
+*
+* MSOTDSTYLE (`__MAIZZLE_MSOTDSTYLE_{id}__`) — emitted by `<Container>` and
+*   `<Section>`'s MSO `<td>`. Source element is marked with
+*   `data-maizzle-mso-td-id`. Extracts from the inlined style:
+*     - `background-color` (always, when present) so Word paints the cell.
+*     - `padding*` (only when no horizontal border on the element, since
+*       Word drops div padding without a border and a copy would
+*       double-pad with one).
+*   Appends the `data-maizzle-mso-style` value (the user's `msoStyle`
+*   prop) last so it wins on duplicates. Empty input resolves to ''
+*   so the placeholder collapses cleanly.
+*
+* Single collect-walk + single substitute-walk: the same Container div
+* carries both marker kinds, so one element visit fills both maps.
+*/
+function msoPlaceholders(dom) {
+	const widths = /* @__PURE__ */ new Map();
+	const tdStyles = /* @__PURE__ */ new Map();
+	walk(dom, (node) => {
+		const a = node.attribs;
+		if (!a) return;
+		const msowId = a["data-maizzle-msow-id"];
+		const tdId = a["data-maizzle-mso-td-id"];
+		if (!msowId && !tdId) return;
+		const style = a.style ?? "";
+		if (msowId) {
+			delete a["data-maizzle-msow-id"];
+			const fallback = a["data-maizzle-msow-fallback"] ?? "600px";
+			delete a["data-maizzle-msow-fallback"];
+			const raw = style.match(RE_MAX_WIDTH)?.[1] ?? style.match(RE_WIDTH)?.[1];
+			const resolved = raw ? resolveWidth(raw) : null;
+			widths.set(msowId, resolved ?? fallback);
+		}
+		if (tdId) {
+			delete a["data-maizzle-mso-td-id"];
+			const msoStyle = (a["data-maizzle-mso-style"] ?? "").trim().replace(/;\s*$/, "");
+			delete a["data-maizzle-mso-style"];
+			/**
+			* Build the MSO td's inline style from three sources, in CSS priority order
+			* (earlier = lower, later wins on dupes):
+			*
+			*   1. `background-color` (always, when present) — Word paints the cell
+			*      under any padding area or inline-block gap, not just the div.
+			*
+			*   2. `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.
+			*
+			*   3. The user's `mso-style` prop — last so it overrides anything the
+			*      auto-hoist computed.
+			*/
+			const parts = [];
+			if (style) {
+				const root = safeParser(style);
+				let bgDecl;
+				root.walkDecls("background-color", (d) => {
+					bgDecl = `background-color: ${d.value}${d.important ? " !important" : ""}`;
+				});
+				if (bgDecl) parts.push(bgDecl);
+				if (horizontalBorderPx(root) === 0) root.walkDecls((d) => {
+					if (/^padding(-|$)/.test(d.prop)) parts.push(`${d.prop}: ${d.value}${d.important ? " !important" : ""}`);
+				});
+			}
+			if (msoStyle) parts.push(msoStyle);
+			tdStyles.set(tdId, parts.length ? ` style="${parts.join("; ")}"` : "");
+		}
+	});
+	if (widths.size === 0 && tdStyles.size === 0) return dom;
+	walk(dom, (node) => {
+		if (node.type !== "comment") return;
+		let data = node.data;
+		if (!data) return;
+		const hasMsow = widths.size > 0 && data.includes("__MAIZZLE_MSOW_");
+		const hasTd = tdStyles.size > 0 && data.includes("__MAIZZLE_MSOTDSTYLE_");
+		if (!hasMsow && !hasTd) return;
+		if (hasMsow) for (const [id, val] of widths) data = data.replaceAll(`__MAIZZLE_MSOW_${id}__`, val);
+		if (hasTd) for (const [id, val] of tdStyles) data = data.replaceAll(`__MAIZZLE_MSOTDSTYLE_${id}__`, val);
+		node.data = data;
+	});
+	return dom;
+}
+//#endregion
+export { msoPlaceholders };
+
+//# sourceMappingURL=msoPlaceholders.js.map

package/dist/transformers/msoPlaceholders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"msoPlaceholders.js","names":["el"],"sources":["../../src/transformers/msoPlaceholders.ts"],"sourcesContent":["import safeParser from 'postcss-safe-parser'\nimport { walk } from '../utils/ast/index.ts'\nimport { horizontalBorderPx } from '../utils/cssBox.ts'\nimport type { ChildNode, Element } from 'domhandler'\n\nconst RE_MAX_WIDTH = /(?:^|;\\s*)max-width:\\s*([^;]+)/i\nconst RE_WIDTH = /(?:^|;\\s*)width:\\s*([^;]+)/i\nconst RE_PERCENT = /^[\\d.]+%$/\n\nfunction resolveWidth(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\n/**\n * Resolve all `__MAIZZLE_MSO*__` placeholders inside MSO conditional comments\n * by reading inlined style + `data-*` markers on the paired elements.\n *\n * Two placeholder families:\n *\n * MSOW (`__MAIZZLE_MSOW_{id}__`) — emitted by `<Container>` and `<Section>`.\n *   Source element is marked with `data-maizzle-msow-id`. Reads inlined\n *   `max-width:` (falls back to `width:`) and normalizes to px. Falls\n *   back to `data-maizzle-msow-fallback` (default `600px`) when the\n *   value can't be parsed.\n *\n * MSOTDSTYLE (`__MAIZZLE_MSOTDSTYLE_{id}__`) — emitted by `<Container>` and\n *   `<Section>`'s MSO `<td>`. Source element is marked with\n *   `data-maizzle-mso-td-id`. Extracts from the inlined style:\n *     - `background-color` (always, when present) so Word paints the cell.\n *     - `padding*` (only when no horizontal border on the element, since\n *       Word drops div padding without a border and a copy would\n *       double-pad with one).\n *   Appends the `data-maizzle-mso-style` value (the user's `msoStyle`\n *   prop) last so it wins on duplicates. Empty input resolves to ''\n *   so the placeholder collapses cleanly.\n *\n * Single collect-walk + single substitute-walk: the same Container div\n * carries both marker kinds, so one element visit fills both maps.\n */\nexport function msoPlaceholders(dom: ChildNode[]): ChildNode[] {\n  const widths = new Map<string, string>()\n  const tdStyles = new Map<string, string>()\n\n  walk(dom, (node) => {\n    const el = node as Element\n    const a = el.attribs\n    if (!a) return\n\n    const msowId = a['data-maizzle-msow-id']\n    const tdId = a['data-maizzle-mso-td-id']\n    if (!msowId && !tdId) return\n\n    const style = a.style ?? ''\n\n    if (msowId) {\n      delete a['data-maizzle-msow-id']\n      const fallback = a['data-maizzle-msow-fallback'] ?? '600px'\n      delete a['data-maizzle-msow-fallback']\n      const raw = style.match(RE_MAX_WIDTH)?.[1] ?? style.match(RE_WIDTH)?.[1]\n      const resolved = raw ? resolveWidth(raw) : null\n      widths.set(msowId, resolved ?? fallback)\n    }\n\n    if (tdId) {\n      delete a['data-maizzle-mso-td-id']\n      const msoStyle = (a['data-maizzle-mso-style'] ?? '').trim().replace(/;\\s*$/, '')\n      delete a['data-maizzle-mso-style']\n\n      /**\n       * Build the MSO td's inline style from three sources, in CSS priority order\n       * (earlier = lower, later wins on dupes):\n       *\n       *   1. `background-color` (always, when present) — Word paints the cell\n       *      under any padding area or inline-block gap, not just the div.\n       *\n       *   2. `padding*` (hoisted only when no horizontal border) — Word drops\n       *      div padding without a stabilizing border, so the td has to\n       *      carry it. With a border, Word renders div padding and a td\n       *      copy would double-pad.\n       *\n       *   3. The user's `mso-style` prop — last so it overrides anything the\n       *      auto-hoist computed.\n       */\n      const parts: string[] = []\n      if (style) {\n        const root = safeParser(style)\n\n        let bgDecl: string | undefined\n        root.walkDecls('background-color', (d) => {\n          bgDecl = `background-color: ${d.value}${d.important ? ' !important' : ''}`\n        })\n        if (bgDecl) parts.push(bgDecl)\n\n        if (horizontalBorderPx(root) === 0) {\n          root.walkDecls((d) => {\n            if (/^padding(-|$)/.test(d.prop)) {\n              parts.push(`${d.prop}: ${d.value}${d.important ? ' !important' : ''}`)\n            }\n          })\n        }\n      }\n      if (msoStyle) parts.push(msoStyle)\n\n      tdStyles.set(tdId, parts.length ? ` style=\"${parts.join('; ')}\"` : '')\n    }\n  })\n\n  if (widths.size === 0 && tdStyles.size === 0) return dom\n\n  walk(dom, (node) => {\n    if (node.type !== 'comment') return\n    let data = (node as any).data as string\n    if (!data) return\n    const hasMsow = widths.size > 0 && data.includes('__MAIZZLE_MSOW_')\n    const hasTd = tdStyles.size > 0 && data.includes('__MAIZZLE_MSOTDSTYLE_')\n    if (!hasMsow && !hasTd) return\n\n    if (hasMsow) {\n      for (const [id, val] of widths) {\n        data = data.replaceAll(`__MAIZZLE_MSOW_${id}__`, val)\n      }\n    }\n    if (hasTd) {\n      for (const [id, val] of tdStyles) {\n        data = data.replaceAll(`__MAIZZLE_MSOTDSTYLE_${id}__`, val)\n      }\n    }\n    ;(node as any).data = data\n  })\n\n  return dom\n}\n"],"mappings":";;;;;AAKA,MAAM,eAAe;AACrB,MAAM,WAAW;AACjB,MAAM,aAAa;AAEnB,SAAS,aAAa,OAA8B;CAClD,MAAM,UAAU,MAAM,KAAK;CAC3B,IAAI,WAAW,KAAK,OAAO,GAAG,OAAO;CACrC,MAAM,IAAI,QAAQ,MAAM,4BAA4B;CACpD,IAAI,CAAC,GAAG,OAAO;CACf,MAAM,IAAI,WAAW,EAAE,EAAE;CACzB,MAAM,QAAQ,EAAE,MAAM,KAAA,CAAM,YAAY;CAExC,OAAO,GAAG,KAAK,MAAM,KADN,SAAS,SAAS,SAAS,OAAO,KAAK,SAAS,OAAO,QAAQ,EAC/C,EAAE;AACnC;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,gBAAgB,KAA+B;CAC7D,MAAM,yBAAS,IAAI,IAAoB;CACvC,MAAM,2BAAW,IAAI,IAAoB;CAEzC,KAAK,MAAM,SAAS;EAElB,MAAM,IAAIA,KAAG;EACb,IAAI,CAAC,GAAG;EAER,MAAM,SAAS,EAAE;EACjB,MAAM,OAAO,EAAE;EACf,IAAI,CAAC,UAAU,CAAC,MAAM;EAEtB,MAAM,QAAQ,EAAE,SAAS;EAEzB,IAAI,QAAQ;GACV,OAAO,EAAE;GACT,MAAM,WAAW,EAAE,iCAAiC;GACpD,OAAO,EAAE;GACT,MAAM,MAAM,MAAM,MAAM,YAAY,CAAC,GAAG,MAAM,MAAM,MAAM,QAAQ,CAAC,GAAG;GACtE,MAAM,WAAW,MAAM,aAAa,GAAG,IAAI;GAC3C,OAAO,IAAI,QAAQ,YAAY,QAAQ;EACzC;EAEA,IAAI,MAAM;GACR,OAAO,EAAE;GACT,MAAM,YAAY,EAAE,6BAA6B,GAAA,CAAI,KAAK,CAAC,CAAC,QAAQ,SAAS,EAAE;GAC/E,OAAO,EAAE;;;;;;;;;;;;;;;;GAiBT,MAAM,QAAkB,CAAC;GACzB,IAAI,OAAO;IACT,MAAM,OAAO,WAAW,KAAK;IAE7B,IAAI;IACJ,KAAK,UAAU,qBAAqB,MAAM;KACxC,SAAS,qBAAqB,EAAE,QAAQ,EAAE,YAAY,gBAAgB;IACxE,CAAC;IACD,IAAI,QAAQ,MAAM,KAAK,MAAM;IAE7B,IAAI,mBAAmB,IAAI,MAAM,GAC/B,KAAK,WAAW,MAAM;KACpB,IAAI,gBAAgB,KAAK,EAAE,IAAI,GAC7B,MAAM,KAAK,GAAG,EAAE,KAAK,IAAI,EAAE,QAAQ,EAAE,YAAY,gBAAgB,IAAI;IAEzE,CAAC;GAEL;GACA,IAAI,UAAU,MAAM,KAAK,QAAQ;GAEjC,SAAS,IAAI,MAAM,MAAM,SAAS,WAAW,MAAM,KAAK,IAAI,EAAE,KAAK,EAAE;EACvE;CACF,CAAC;CAED,IAAI,OAAO,SAAS,KAAK,SAAS,SAAS,GAAG,OAAO;CAErD,KAAK,MAAM,SAAS;EAClB,IAAI,KAAK,SAAS,WAAW;EAC7B,IAAI,OAAQ,KAAa;EACzB,IAAI,CAAC,MAAM;EACX,MAAM,UAAU,OAAO,OAAO,KAAK,KAAK,SAAS,iBAAiB;EAClE,MAAM,QAAQ,SAAS,OAAO,KAAK,KAAK,SAAS,uBAAuB;EACxE,IAAI,CAAC,WAAW,CAAC,OAAO;EAExB,IAAI,SACF,KAAK,MAAM,CAAC,IAAI,QAAQ,QACtB,OAAO,KAAK,WAAW,kBAAkB,GAAG,KAAK,GAAG;EAGxD,IAAI,OACF,KAAK,MAAM,CAAC,IAAI,QAAQ,UACtB,OAAO,KAAK,WAAW,wBAAwB,GAAG,KAAK,GAAG;EAG7D,KAAc,OAAO;CACxB,CAAC;CAED,OAAO;AACT"}

package/dist/transformers/purgeCss.d.ts

@@ -0,0 +1,43 @@
+import { ChildNode } from "domhandler";
+import { Opts } from "email-comb";
+
+//#region src/transformers/purgeCss.d.ts
+/**
+ * Options for the `purgeCss` transformer.
+ */
+interface PurgeCssOptions extends Partial<Omit<Opts, 'whitelist'>> {
+  /**
+   * Selectors to preserve regardless of whether they're matched in the
+   * markup. Appended to Maizzle's built-in safelist (Gmail, Apple Mail,
+   * Outlook.com hooks, etc). Mapped to email-comb's `whitelist` option.
+   */
+  safelist?: string[];
+}
+/**
+ * Remove unused CSS from an HTML string.
+ *
+ * Uses `email-comb` together with a DOM-aware deep-purge step to strip
+ * CSS selectors and class/id references that are not matched anywhere
+ * in the document body.
+ *
+ * @param html    HTML string to transform.
+ * @param options Email-comb options plus a Maizzle `safelist`.
+ * @returns       The transformed HTML string.
+ *
+ * @example
+ * import { purgeCss } from '@maizzle/framework'
+ *
+ * const out = purgeCss('<style>.a{}.b{}</style><p class="a">x</p>', {
+ *   safelist: ['.keep'],
+ * })
+ */
+declare function purgeCss(html: string, options?: PurgeCssOptions): string;
+/**
+ * DOM-form of {@link purgeCss} 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 purgeCssDom(dom: ChildNode[], options?: PurgeCssOptions): ChildNode[];
+//#endregion
+export { PurgeCssOptions, purgeCss, purgeCssDom };
+//# sourceMappingURL=purgeCss.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"purgeCss.d.ts","names":[],"sources":["../../src/transformers/purgeCss.ts"],"mappings":";;;;;;AAsCA;UAAiB,eAAA,SAAwB,OAAA,CAAQ,IAAA,CAAK,IAAA;;;;;;EAMpD,QAAA;AAAA;;;;;AAAQ;AAqBV;;;;;;;;AAAoE;AASpE;;;;iBATgB,QAAA,CAAS,IAAA,UAAc,OAAA,GAAS,eAAoB;;;;;;iBASpD,WAAA,CAAY,GAAA,EAAK,SAAA,IAAa,OAAA,GAAS,eAAA,GAAuB,SAAA"}

package/dist/transformers/purgeCss.js

@@ -0,0 +1,207 @@
+import { parse } from "../utils/ast/parser.js";
+import { walk } from "../utils/ast/walker.js";
+import { serialize } from "../utils/ast/serializer.js";
+import "../utils/ast/index.js";
+import { defu as defu$1 } from "defu";
+import safeParser from "postcss-safe-parser";
+import { selectAll } from "css-select";
+import { comb } from "email-comb";
+//#region src/transformers/purgeCss.ts
+const DEFAULT_SAFELIST = [
+	"*body*",
+	".gmail*",
+	".apple*",
+	".ios*",
+	".ox-*",
+	".outlook*",
+	"[data-ogs*",
+	".bloop_container",
+	".Singleton",
+	".unused",
+	".moz-text-html",
+	".mail-detail-content",
+	"*edo*",
+	"#*",
+	".\\&*",
+	".lang*"
+];
+const DEFAULT_OPTIONS = {
+	backend: [{
+		heads: "{{",
+		tails: "}}"
+	}, {
+		heads: "{%",
+		tails: "%}"
+	}],
+	whitelist: [...DEFAULT_SAFELIST]
+};
+/**
+* Remove unused CSS from an HTML string.
+*
+* Uses `email-comb` together with a DOM-aware deep-purge step to strip
+* CSS selectors and class/id references that are not matched anywhere
+* in the document body.
+*
+* @param html    HTML string to transform.
+* @param options Email-comb options plus a Maizzle `safelist`.
+* @returns       The transformed HTML string.
+*
+* @example
+* import { purgeCss } from '@maizzle/framework'
+*
+* const out = purgeCss('<style>.a{}.b{}</style><p class="a">x</p>', {
+*   safelist: ['.keep'],
+* })
+*/
+function purgeCss(html, options = {}) {
+	return serialize(purgeCssDom(parse(html), options));
+}
+/**
+* DOM-form of {@link purgeCss} 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.
+*/
+function purgeCssDom(dom, options = {}) {
+	const userSafelist = Array.isArray(options.safelist) ? options.safelist : [];
+	const { safelist: _discard, ...restUserOptions } = options;
+	/**
+	* Merge user options on top of defaults. defu merges objects deeply;
+	* for arrays it appends user values. We want the user safelist
+	* appended to the default safelist, so we build whitelist
+	* manually.
+	*/
+	const combOptions = defu$1({
+		...restUserOptions,
+		whitelist: [...DEFAULT_SAFELIST, ...userSafelist]
+	}, DEFAULT_OPTIONS);
+	/**
+	* Deep purge first: DOM-aware selector removal via PostCSS + css-select.
+	* Runs before email-comb so that email-comb can clean up orphaned
+	* classes in HTML attributes left behind by removed CSS rules.
+	*/
+	const safelist = [...DEFAULT_SAFELIST, ...userSafelist];
+	dom = deepPurge(dom, safelist);
+	/**
+	* Shield embed style tags from email-comb. Comb has no skip option,
+	* so it strips CSS comments and drops class refs it can't match
+	* against visible CSS. Swap each embed tag's body for a unique
+	* stub rule (`.maizzle-keep-N{}`) so comb keeps the tag, then
+	* whitelist that stub plus every selector from the original
+	* CSS so comb leaves matching refs alone elsewhere — and
+	* finally restore the original CSS once comb has run.
+	*/
+	const stash = [];
+	const extraWhitelist = [];
+	walk(dom, (node) => {
+		const el = node;
+		if (el.name !== "style" || !el.attribs) return;
+		if (!("embed" in el.attribs) && !("data-embed" in el.attribs) && !("amp-custom" in el.attribs)) return;
+		const textNode = el.children?.find((c) => c.type === "text");
+		if (!textNode?.data) return;
+		const token = `.maizzle-keep-${stash.length}`;
+		extraWhitelist.push(token);
+		for (const m of textNode.data.matchAll(/(?<![\w-])[.#][a-zA-Z_][\w-]*/g)) extraWhitelist.push(m[0]);
+		stash.push({
+			token,
+			original: textNode.data,
+			textNode
+		});
+		textNode.data = `${token}{}`;
+	});
+	if (extraWhitelist.length) combOptions.whitelist = [...combOptions.whitelist ?? [], ...extraWhitelist];
+	const { result } = comb(serialize(dom), combOptions);
+	/**
+	* Comb returns a fresh string, so we work off the post-parse tree:
+	* find each embed style tag whose body still starts with the stub
+	* token we planted earlier and swap the original CSS back in.
+	*/
+	let purgedDom = parse(result);
+	if (stash.length) walk(purgedDom, (node) => {
+		const el = node;
+		if (el.name !== "style" || !el.attribs) return;
+		if (!("embed" in el.attribs) && !("data-embed" in el.attribs) && !("amp-custom" in el.attribs)) return;
+		const textNode = el.children?.find((c) => c.type === "text");
+		if (!textNode?.data) return;
+		const trimmed = textNode.data.trim();
+		const match = stash.find((s) => trimmed === `${s.token}{}` || trimmed.startsWith(`${s.token}{`));
+		if (match) textNode.data = match.original;
+	});
+	/**
+	* Clean up data-embed/embed attributes — no longer needed after purging.
+	* `amp-custom` stays as-is (it's the user-authored AMP4Email attr).
+	*/
+	walk(purgedDom, (node) => {
+		const el = node;
+		if (el.name === "style" && el.attribs) {
+			delete el.attribs["data-embed"];
+			delete el.attribs.embed;
+		}
+	});
+	return purgedDom;
+}
+/**
+* Deep purge: uses PostCSS to parse CSS in non-embedded style tags,
+* then checks each selector against the DOM with css-select.
+* Removes rules where no selector matches any element.
+*/
+function isSafelisted(selector, safelist) {
+	return safelist.some((pattern) => {
+		if (pattern.startsWith("*") && pattern.endsWith("*")) return selector.includes(pattern.slice(1, -1));
+		if (pattern.endsWith("*")) return selector.startsWith(pattern.slice(0, -1));
+		if (pattern.startsWith("*")) return selector.endsWith(pattern.slice(1));
+		return selector === pattern;
+	});
+}
+function deepPurge(dom, safelist) {
+	walk(dom, (node) => {
+		const el = node;
+		if (el.name !== "style" || !el.attribs) return;
+		if ("data-embed" in el.attribs || "embed" in el.attribs || "amp-custom" in el.attribs) return;
+		const textNode = el.children?.find((c) => c.type === "text");
+		if (!textNode?.data?.trim()) return;
+		const root = safeParser(textNode.data);
+		root.walkRules((rule) => {
+			/**
+			* Skip rules inside @media or other at-rules — those may target
+			* states we can't match statically (hover, responsive, etc.).
+			*/
+			if (rule.parent?.type === "atrule") return;
+			const selectors = rule.selectors ?? [rule.selector];
+			const matched = selectors.filter((sel) => {
+				if (isSafelisted(sel, safelist)) return true;
+				/**
+				* Skip pseudo-classes/elements that can't be matched statically.
+				* Functional pseudos like :not(), :is(), :where(), :has() are
+				* matchable by css-select, so we only skip dynamic/state
+				* ones.
+				*/
+				if (/::[\w-]/.test(sel)) return true;
+				if (/(?<!:):(?!not\b|is\b|where\b|has\b)[\w-]/.test(sel.replace(/\\./g, ""))) return true;
+				try {
+					return selectAll(sel, dom).length > 0;
+				} catch {
+					return true;
+				}
+			});
+			if (matched.length === 0) rule.remove();
+			else if (matched.length < selectors.length) rule.selectors = matched;
+		});
+		root.walkAtRules((atRule) => {
+			if (atRule.nodes?.length === 0) atRule.remove();
+		});
+		const purgedCss = root.toString();
+		if (purgedCss.trim()) textNode.data = purgedCss;
+		else {
+			const parent = el.parent;
+			if (parent && "children" in parent) {
+				const idx = parent.children.indexOf(el);
+				if (idx !== -1) parent.children.splice(idx, 1);
+			}
+		}
+	});
+	return dom;
+}
+//#endregion
+export { purgeCss, purgeCssDom };
+
+//# sourceMappingURL=purgeCss.js.map

package/dist/transformers/purgeCss.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"purgeCss.js","names":["merge"],"sources":["../../src/transformers/purgeCss.ts"],"sourcesContent":["import { comb } from 'email-comb'\nimport { defu as merge } from 'defu'\nimport safeParser from 'postcss-safe-parser'\nimport { selectAll } from 'css-select'\nimport type { ChildNode, Element } from 'domhandler'\nimport type { Opts as CombOptions } from 'email-comb'\nimport { parse, serialize, walk } from '../utils/ast/index.ts'\n\nconst DEFAULT_SAFELIST: string[] = [\n  '*body*', // Gmail\n  '.gmail*', // Gmail\n  '.apple*', // Apple Mail\n  '.ios*', // Mail on iOS\n  '.ox-*', // Open-Xchange\n  '.outlook*', // Outlook.com\n  '[data-ogs*', // Outlook.com\n  '.bloop_container', // Airmail\n  '.Singleton', // Apple Mail 10\n  '.unused', // Notes 8\n  '.moz-text-html', // Thunderbird\n  '.mail-detail-content', // Comcast, Libero webmail\n  '*edo*', // Edison (all)\n  '#*', // Freenet uses #msgBody\n  '.\\\\&*', // Yahoo Mail wraps content in a class literally named \"&\"\n  '.lang*', // Fenced code blocks\n]\n\nconst DEFAULT_OPTIONS = {\n  backend: [\n    { heads: '{{', tails: '}}' },\n    { heads: '{%', tails: '%}' },\n  ],\n  whitelist: [...DEFAULT_SAFELIST],\n}\n\n/**\n * Options for the `purgeCss` transformer.\n */\nexport interface PurgeCssOptions extends Partial<Omit<CombOptions, 'whitelist'>> {\n  /**\n   * Selectors to preserve regardless of whether they're matched in the\n   * markup. Appended to Maizzle's built-in safelist (Gmail, Apple Mail,\n   * Outlook.com hooks, etc). Mapped to email-comb's `whitelist` option.\n   */\n  safelist?: string[]\n}\n\n/**\n * Remove unused CSS from an HTML string.\n *\n * Uses `email-comb` together with a DOM-aware deep-purge step to strip\n * CSS selectors and class/id references that are not matched anywhere\n * in the document body.\n *\n * @param html    HTML string to transform.\n * @param options Email-comb options plus a Maizzle `safelist`.\n * @returns       The transformed HTML string.\n *\n * @example\n * import { purgeCss } from '@maizzle/framework'\n *\n * const out = purgeCss('<style>.a{}.b{}</style><p class=\"a\">x</p>', {\n *   safelist: ['.keep'],\n * })\n */\nexport function purgeCss(html: string, options: PurgeCssOptions = {}): string {\n  return serialize(purgeCssDom(parse(html), options))\n}\n\n/**\n * DOM-form of {@link purgeCss} used by the internal transformer\n * pipeline. Takes a parsed DOM, returns a parsed DOM — avoids redundant\n * serialize/parse round-trips when chained with other transformers.\n */\nexport function purgeCssDom(dom: ChildNode[], options: PurgeCssOptions = {}): ChildNode[] {\n  const userSafelist = Array.isArray(options.safelist) ? options.safelist : []\n\n  const { safelist: _discard, ...restUserOptions } = options\n\n  /**\n   * Merge user options on top of defaults. defu merges objects deeply;\n   * for arrays it appends user values. We want the user safelist\n   * appended to the default safelist, so we build whitelist\n   * manually.\n   */\n  const combOptions = merge(\n    { ...restUserOptions, whitelist: [...DEFAULT_SAFELIST, ...userSafelist] },\n    DEFAULT_OPTIONS,\n  )\n\n  /**\n   * Deep purge first: DOM-aware selector removal via PostCSS + css-select.\n   * Runs before email-comb so that email-comb can clean up orphaned\n   * classes in HTML attributes left behind by removed CSS rules.\n   */\n  const safelist = [...DEFAULT_SAFELIST, ...userSafelist]\n  dom = deepPurge(dom, safelist)\n\n  /**\n   * Shield embed style tags from email-comb. Comb has no skip option,\n   * so it strips CSS comments and drops class refs it can't match\n   * against visible CSS. Swap each embed tag's body for a unique\n   * stub rule (`.maizzle-keep-N{}`) so comb keeps the tag, then\n   * whitelist that stub plus every selector from the original\n   * CSS so comb leaves matching refs alone elsewhere — and\n   * finally restore the original CSS once comb has run.\n   */\n  const stash: { token: string; original: string; textNode: any }[] = []\n  const extraWhitelist: string[] = []\n  walk(dom, (node) => {\n    const el = node as Element\n    if (el.name !== 'style' || !el.attribs) return\n    if (!('embed' in el.attribs) && !('data-embed' in el.attribs) && !('amp-custom' in el.attribs)) return\n    const textNode = el.children?.find((c: any) => c.type === 'text') as any\n    if (!textNode?.data) return\n    const idx = stash.length\n    const token = `.maizzle-keep-${idx}`\n    extraWhitelist.push(token)\n    for (const m of textNode.data.matchAll(/(?<![\\w-])[.#][a-zA-Z_][\\w-]*/g)) {\n      extraWhitelist.push(m[0])\n    }\n    stash.push({ token, original: textNode.data, textNode })\n    textNode.data = `${token}{}`\n  })\n\n  if (extraWhitelist.length) {\n    combOptions.whitelist = [...(combOptions.whitelist as string[] ?? []), ...extraWhitelist]\n  }\n\n  const { result } = comb(serialize(dom), combOptions)\n\n  /**\n   * Comb returns a fresh string, so we work off the post-parse tree:\n   * find each embed style tag whose body still starts with the stub\n   * token we planted earlier and swap the original CSS back in.\n   */\n  let purgedDom = parse(result)\n\n  if (stash.length) {\n    walk(purgedDom, (node) => {\n      const el = node as Element\n      if (el.name !== 'style' || !el.attribs) return\n      if (!('embed' in el.attribs) && !('data-embed' in el.attribs) && !('amp-custom' in el.attribs)) return\n      const textNode = el.children?.find((c: any) => c.type === 'text') as any\n      if (!textNode?.data) return\n      const trimmed = textNode.data.trim()\n      const match = stash.find(s => trimmed === `${s.token}{}` || trimmed.startsWith(`${s.token}{`))\n      if (match) textNode.data = match.original\n    })\n  }\n\n  /**\n   * Clean up data-embed/embed attributes — no longer needed after purging.\n   * `amp-custom` stays as-is (it's the user-authored AMP4Email attr).\n   */\n  walk(purgedDom, (node) => {\n    const el = node as Element\n    if (el.name === 'style' && el.attribs) {\n      delete el.attribs['data-embed']\n      delete el.attribs.embed\n    }\n  })\n\n  return purgedDom\n}\n\n/**\n * Deep purge: uses PostCSS to parse CSS in non-embedded style tags,\n * then checks each selector against the DOM with css-select.\n * Removes rules where no selector matches any element.\n */\nfunction isSafelisted(selector: string, safelist: string[]): boolean {\n  return safelist.some((pattern) => {\n    if (pattern.startsWith('*') && pattern.endsWith('*')) {\n      return selector.includes(pattern.slice(1, -1))\n    }\n    if (pattern.endsWith('*')) {\n      return selector.startsWith(pattern.slice(0, -1))\n    }\n    if (pattern.startsWith('*')) {\n      return selector.endsWith(pattern.slice(1))\n    }\n    return selector === pattern\n  })\n}\n\nfunction deepPurge(dom: ChildNode[], safelist: string[]): ChildNode[] {\n  walk(dom, (node) => {\n    const el = node as Element\n\n    if (el.name !== 'style' || !el.attribs) return\n    if ('data-embed' in el.attribs || 'embed' in el.attribs || 'amp-custom' in el.attribs) return\n\n    const textNode = el.children?.find((c: any) => c.type === 'text') as any\n    if (!textNode?.data?.trim()) return\n\n    const root = safeParser(textNode.data)\n\n    root.walkRules((rule) => {\n      /**\n       * Skip rules inside @media or other at-rules — those may target\n       * states we can't match statically (hover, responsive, etc.).\n       */\n      if (rule.parent?.type === 'atrule') return\n\n      const selectors = rule.selectors ?? [rule.selector]\n      const matched = selectors.filter((sel) => {\n        // Keep safelisted selectors\n        if (isSafelisted(sel, safelist)) return true\n\n        /**\n         * Skip pseudo-classes/elements that can't be matched statically.\n         * Functional pseudos like :not(), :is(), :where(), :has() are\n         * matchable by css-select, so we only skip dynamic/state\n         * ones.\n         */\n        if (/::[\\w-]/.test(sel)) return true\n        if (/(?<!:):(?!not\\b|is\\b|where\\b|has\\b)[\\w-]/.test(sel.replace(/\\\\./g, ''))) return true\n\n        try {\n          return selectAll(sel, dom).length > 0\n        } catch {\n          // If css-select can't parse the selector, keep it\n          return true\n        }\n      })\n\n      if (matched.length === 0) {\n        rule.remove()\n      } else if (matched.length < selectors.length) {\n        rule.selectors = matched\n      }\n    })\n\n    // Remove empty at-rules\n    root.walkAtRules((atRule) => {\n      if (atRule.nodes?.length === 0) {\n        atRule.remove()\n      }\n    })\n\n    const purgedCss = root.toString()\n\n    if (purgedCss.trim()) {\n      textNode.data = purgedCss\n    } else {\n      // Remove the style tag entirely if empty\n      const parent = el.parent\n      if (parent && 'children' in parent) {\n        const idx = parent.children.indexOf(el as any)\n        if (idx !== -1) parent.children.splice(idx, 1)\n      }\n    }\n  })\n\n  return dom\n}\n"],"mappings":"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"}

package/dist/transformers/removeAttributes.d.ts

@@ -0,0 +1,54 @@
+import { ChildNode } from "domhandler";
+
+//#region src/transformers/removeAttributes.d.ts
+/**
+ * Single attribute-removal rule.
+ */
+interface RemoveAttributeRule {
+  /** Attribute name to match. */
+  name: string;
+  /**
+   * Match condition for the attribute's value:
+   * - `string` — remove when the value matches exactly.
+   * - `RegExp` — remove when the value matches the regex.
+   * - `boolean` / omitted — remove when the value is empty.
+   */
+  value?: string | RegExp | boolean;
+}
+/**
+ * Entry passed to {@link removeAttributes}. A bare string targets the named
+ * attribute and removes it when its value is empty.
+ */
+type RemoveAttributeOption = string | RemoveAttributeRule;
+/**
+ * Remove HTML attributes from elements.
+ *
+ * Empty `style` and `class` attributes are always stripped, regardless of
+ * what you pass. Your entries are appended to those defaults.
+ *
+ * - `'data-src'` — remove when the value is empty.
+ * - `{ name: 'id', value: 'test' }` — remove when the value matches exactly.
+ * - `{ name: 'data-id', value: /\d/ }` — remove when the value matches the regex.
+ *
+ * @param html       HTML string to transform.
+ * @param attributes Additional attribute-removal rules to apply on top of the defaults.
+ * @returns          The transformed HTML string.
+ *
+ * @example
+ * import { removeAttributes } from '@maizzle/framework'
+ *
+ * const out = removeAttributes('<p style="" data-x="">x</p>', [
+ *   'data-x',
+ *   { name: 'role', value: 'none' },
+ * ])
+ */
+declare function removeAttributes(html: string, attributes?: RemoveAttributeOption[]): string;
+/**
+ * DOM-form of {@link removeAttributes} 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 removeAttributesDom(dom: ChildNode[], attributes?: RemoveAttributeOption[]): ChildNode[];
+//#endregion
+export { RemoveAttributeOption, RemoveAttributeRule, removeAttributes, removeAttributesDom };
+//# sourceMappingURL=removeAttributes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"removeAttributes.d.ts","names":[],"sources":["../../src/transformers/removeAttributes.ts"],"mappings":";;;;;AAMA;UAAiB,mBAAA;;EAEf,IAAA;EAAA;;;;AAOuB;AAOzB;EAPE,KAAA,YAAiB,MAAM;AAAA;;AAOuC;AAwBhE;;KAxBY,qBAAA,YAAiC,mBAAmB;;;;;;AAwBuB;AASvF;;;;;;;;;;;;;;AAA0G;;iBAT1F,gBAAA,CAAiB,IAAA,UAAc,UAAA,GAAY,qBAAqB;;;;;;iBAShE,mBAAA,CAAoB,GAAA,EAAK,SAAA,IAAa,UAAA,GAAY,qBAAA,KAA+B,SAAA"}

package/dist/transformers/removeAttributes.js

@@ -0,0 +1,72 @@
+import { parse } from "../utils/ast/parser.js";
+import { walk } from "../utils/ast/walker.js";
+import { serialize } from "../utils/ast/serializer.js";
+import "../utils/ast/index.js";
+//#region src/transformers/removeAttributes.ts
+/**
+* Remove HTML attributes from elements.
+*
+* Empty `style` and `class` attributes are always stripped, regardless of
+* what you pass. Your entries are appended to those defaults.
+*
+* - `'data-src'` — remove when the value is empty.
+* - `{ name: 'id', value: 'test' }` — remove when the value matches exactly.
+* - `{ name: 'data-id', value: /\d/ }` — remove when the value matches the regex.
+*
+* @param html       HTML string to transform.
+* @param attributes Additional attribute-removal rules to apply on top of the defaults.
+* @returns          The transformed HTML string.
+*
+* @example
+* import { removeAttributes } from '@maizzle/framework'
+*
+* const out = removeAttributes('<p style="" data-x="">x</p>', [
+*   'data-x',
+*   { name: 'role', value: 'none' },
+* ])
+*/
+function removeAttributes(html, attributes = []) {
+	return serialize(removeAttributesDom(parse(html), attributes));
+}
+/**
+* DOM-form of {@link removeAttributes} 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.
+*/
+function removeAttributesDom(dom, attributes = []) {
+	const attributesToRemove = [
+		"style",
+		"class",
+		...attributes
+	];
+	walk(dom, (node) => {
+		const el = node;
+		if (!el.attribs) return;
+		for (const attr of attributesToRemove) {
+			let attrName;
+			let attrValue;
+			if (typeof attr === "string") {
+				attrName = attr;
+				attrValue = true;
+			} else {
+				attrName = attr.name;
+				attrValue = attr.value;
+			}
+			const currentValue = el.attribs[attrName];
+			if (currentValue === void 0) continue;
+			let shouldRemove = false;
+			if (typeof attrValue === "boolean") shouldRemove = currentValue === "" || currentValue === true;
+			else if (typeof attrValue === "string") shouldRemove = currentValue === attrValue;
+			else if (attrValue instanceof RegExp) {
+				attrValue.lastIndex = 0;
+				shouldRemove = attrValue.test(currentValue);
+			} else shouldRemove = currentValue === "";
+			if (shouldRemove) delete el.attribs[attrName];
+		}
+	});
+	return dom;
+}
+//#endregion
+export { removeAttributes, removeAttributesDom };
+
+//# sourceMappingURL=removeAttributes.js.map

package/dist/transformers/removeAttributes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"removeAttributes.js","names":[],"sources":["../../src/transformers/removeAttributes.ts"],"sourcesContent":["import type { ChildNode, Element } from 'domhandler'\nimport { parse, serialize, walk } from '../utils/ast/index.ts'\n\n/**\n * Single attribute-removal rule.\n */\nexport interface RemoveAttributeRule {\n  /** Attribute name to match. */\n  name: string\n  /**\n   * Match condition for the attribute's value:\n   * - `string` — remove when the value matches exactly.\n   * - `RegExp` — remove when the value matches the regex.\n   * - `boolean` / omitted — remove when the value is empty.\n   */\n  value?: string | RegExp | boolean\n}\n\n/**\n * Entry passed to {@link removeAttributes}. A bare string targets the named\n * attribute and removes it when its value is empty.\n */\nexport type RemoveAttributeOption = string | RemoveAttributeRule\n\n/**\n * Remove HTML attributes from elements.\n *\n * Empty `style` and `class` attributes are always stripped, regardless of\n * what you pass. Your entries are appended to those defaults.\n *\n * - `'data-src'` — remove when the value is empty.\n * - `{ name: 'id', value: 'test' }` — remove when the value matches exactly.\n * - `{ name: 'data-id', value: /\\d/ }` — remove when the value matches the regex.\n *\n * @param html       HTML string to transform.\n * @param attributes Additional attribute-removal rules to apply on top of the defaults.\n * @returns          The transformed HTML string.\n *\n * @example\n * import { removeAttributes } from '@maizzle/framework'\n *\n * const out = removeAttributes('<p style=\"\" data-x=\"\">x</p>', [\n *   'data-x',\n *   { name: 'role', value: 'none' },\n * ])\n */\nexport function removeAttributes(html: string, attributes: RemoveAttributeOption[] = []): string {\n  return serialize(removeAttributesDom(parse(html), attributes))\n}\n\n/**\n * DOM-form of {@link removeAttributes} used by the internal transformer\n * pipeline. Takes a parsed DOM, returns a parsed DOM — avoids redundant\n * serialize/parse round-trips when chained with other transformers.\n */\nexport function removeAttributesDom(dom: ChildNode[], attributes: RemoveAttributeOption[] = []): ChildNode[] {\n  // Empty style/class are always stripped; user entries are appended.\n  const attributesToRemove: RemoveAttributeOption[] = ['style', 'class', ...attributes]\n\n  walk(dom, (node) => {\n    const el = node as Element\n    if (!el.attribs) return\n\n    for (const attr of attributesToRemove) {\n      let attrName: string\n      let attrValue: string | RegExp | boolean | undefined\n\n      if (typeof attr === 'string') {\n        attrName = attr\n        attrValue = true // Remove when value is empty (boolean true or empty string)\n      } else {\n        attrName = attr.name\n        attrValue = attr.value\n      }\n\n      const currentValue = el.attribs[attrName]\n\n      // Skip if attribute doesn't exist\n      if (currentValue === undefined) continue\n\n      let shouldRemove = false\n\n      if (typeof attrValue === 'boolean') {\n        // Remove if value is empty (boolean true is treated as no-value attribute)\n        shouldRemove = currentValue === '' || (currentValue as unknown) === true\n      } else if (typeof attrValue === 'string') {\n        // Remove if value matches exactly\n        shouldRemove = currentValue === attrValue\n      } else if (attrValue instanceof RegExp) {\n        // Remove if value matches regex. Reset lastIndex first: a user-supplied\n        // /g or /y regex is stateful across .test() calls, so reusing it over\n        // many elements would otherwise match only every other one.\n        attrValue.lastIndex = 0\n        shouldRemove = attrValue.test(currentValue)\n      } else {\n        // Default: remove if empty\n        shouldRemove = currentValue === ''\n      }\n\n      if (shouldRemove) {\n        delete el.attribs[attrName]\n      }\n    }\n  })\n\n  return dom\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,SAAgB,iBAAiB,MAAc,aAAsC,CAAC,GAAW;CAC/F,OAAO,UAAU,oBAAoB,MAAM,IAAI,GAAG,UAAU,CAAC;AAC/D;;;;;;AAOA,SAAgB,oBAAoB,KAAkB,aAAsC,CAAC,GAAgB;CAE3G,MAAM,qBAA8C;EAAC;EAAS;EAAS,GAAG;CAAU;CAEpF,KAAK,MAAM,SAAS;EAClB,MAAM,KAAK;EACX,IAAI,CAAC,GAAG,SAAS;EAEjB,KAAK,MAAM,QAAQ,oBAAoB;GACrC,IAAI;GACJ,IAAI;GAEJ,IAAI,OAAO,SAAS,UAAU;IAC5B,WAAW;IACX,YAAY;GACd,OAAO;IACL,WAAW,KAAK;IAChB,YAAY,KAAK;GACnB;GAEA,MAAM,eAAe,GAAG,QAAQ;GAGhC,IAAI,iBAAiB,KAAA,GAAW;GAEhC,IAAI,eAAe;GAEnB,IAAI,OAAO,cAAc,WAEvB,eAAe,iBAAiB,MAAO,iBAA6B;QAC/D,IAAI,OAAO,cAAc,UAE9B,eAAe,iBAAiB;QAC3B,IAAI,qBAAqB,QAAQ;IAItC,UAAU,YAAY;IACtB,eAAe,UAAU,KAAK,YAAY;GAC5C,OAEE,eAAe,iBAAiB;GAGlC,IAAI,cACF,OAAO,GAAG,QAAQ;EAEtB;CACF,CAAC;CAED,OAAO;AACT"}

package/dist/transformers/{replaceStrings.d.mts → replaceStrings.d.ts}

@@ -1,4 +1,4 @@
-import { MaizzleConfig } from "../types/config.mjs";
+import { MaizzleConfig } from "../types/config.js";
 
 //#region src/transformers/replaceStrings.d.ts
 /**
@@ -13,4 +13,4 @@ import { MaizzleConfig } from "../types/config.mjs";
 declare function replaceStrings(html: string, config?: MaizzleConfig): string;
 //#endregion
 export { replaceStrings };
-//# sourceMappingURL=replaceStrings.d.mts.map
+//# sourceMappingURL=replaceStrings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"replaceStrings.d.ts","names":[],"sources":["../../src/transformers/replaceStrings.ts"],"mappings":";;;;;AAWA;;;;;;;iBAAgB,cAAA,CAAe,IAAA,UAAc,MAAA,GAAQ,aAAkB"}

package/dist/transformers/{replaceStrings.mjs → replaceStrings.js}

@@ -13,7 +13,7 @@ function replaceStrings(html, config = {}) {
 	if (!replacements || Object.keys(replacements).length === 0) return html;
 	return Object.entries(replacements).reduce((result, [pattern, replacement]) => result.replace(new RegExp(pattern, "gi"), replacement), html);
 }
-
 //#endregion
 export { replaceStrings };
-//# sourceMappingURL=replaceStrings.mjs.map
+
+//# sourceMappingURL=replaceStrings.js.map

package/dist/transformers/replaceStrings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replaceStrings.js","names":[],"sources":["../../src/transformers/replaceStrings.ts"],"sourcesContent":["import type { MaizzleConfig } from '../types/config.ts'\n\n/**\n * Replace strings transformer.\n *\n * Replaces strings in the HTML using the key-value pairs defined in\n * `config.replaceStrings`. Each key is treated as a regular expression\n * pattern (case-insensitive, global), and the value is the replacement.\n *\n * Character classes must be escaped in keys, e.g. `\\\\s` for `\\s`.\n */\nexport function replaceStrings(html: string, config: MaizzleConfig = {}): string {\n  const replacements = config.replaceStrings\n\n  if (!replacements || Object.keys(replacements).length === 0) return html\n\n  return Object.entries(replacements).reduce(\n    (result, [pattern, replacement]) => result.replace(new RegExp(pattern, 'gi'), replacement),\n    html,\n  )\n}\n"],"mappings":";;;;;;;;;;AAWA,SAAgB,eAAe,MAAc,SAAwB,CAAC,GAAW;CAC/E,MAAM,eAAe,OAAO;CAE5B,IAAI,CAAC,gBAAgB,OAAO,KAAK,YAAY,CAAC,CAAC,WAAW,GAAG,OAAO;CAEpE,OAAO,OAAO,QAAQ,YAAY,CAAC,CAAC,QACjC,QAAQ,CAAC,SAAS,iBAAiB,OAAO,QAAQ,IAAI,OAAO,SAAS,IAAI,GAAG,WAAW,GACzF,IACF;AACF"}

package/dist/transformers/safeSelectors.d.ts

@@ -0,0 +1,37 @@
+import { CssConfig } from "../types/config.js";
+import { ChildNode } from "domhandler";
+
+//#region src/transformers/safeSelectors.d.ts
+/**
+ * Safe selectors transformer.
+ *
+ * Replaces unsafe characters (`:`, `/`, `[`, `]`, etc.) in:
+ * - CSS selectors inside `<style>` tags
+ * - HTML `class` attributes
+ *
+ * This makes Tailwind utility classes like `sm:text-base` safe for
+ * email clients that cannot handle escaped characters in class names.
+ *
+ * Enabled by default. Disable by setting `css.safe` to `false`.
+ * Customize replacements by passing a `Record<string, string>` — user
+ * values are merged on top of the defaults.
+ *
+ * @param html   HTML string to transform.
+ * @param config CSS config (see {@link CssConfig}).
+ * @returns      The transformed HTML string.
+ *
+ * @example
+ * import { safeSelectors } from '@maizzle/framework'
+ *
+ * const out = safeSelectors('<div class="sm:text-base"></div>')
+ */
+declare function safeSelectors(html: string, config?: CssConfig): string;
+/**
+ * DOM-form of {@link safeSelectors} 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 safeSelectorsDom(dom: ChildNode[], config?: CssConfig): ChildNode[];
+//#endregion
+export { safeSelectors, safeSelectorsDom };
+//# sourceMappingURL=safeSelectors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"safeSelectors.d.ts","names":[],"sources":["../../src/transformers/safeSelectors.ts"],"mappings":";;;;;;AA2HA;;;;;;;;AAAkE;AASlE;;;;;;;;;;;;iBATgB,aAAA,CAAc,IAAA,UAAc,MAAA,GAAQ,SAAc;;AASmB;;;;iBAArE,gBAAA,CAAiB,GAAA,EAAK,SAAA,IAAa,MAAA,GAAQ,SAAA,GAAiB,SAAA"}