@maizzle/framework 6.0.0-8 → 6.0.0-rc.0

package/dist/transformers/purgeCSS.mjs

@@ -0,0 +1,66 @@
+import { parse } from "../utils/ast/parser.mjs";
+import { serialize } from "../utils/ast/serializer.mjs";
+import "../utils/ast/index.mjs";
+import { defu } from "defu";
+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 transformer.
+*
+* Uses `email-comb` to strip CSS selectors and corresponding class/id
+* references that are not matched anywhere in the HTML body.
+*
+* Enable by setting `css.purge: true` (or passing options).
+* The user-supplied options are merged on top of the defaults, so
+* `safelist` values are **appended** to the built-in safelist rather
+* than replacing it.
+*
+* Accepts `ChildNode[]` as input, serializes internally before passing
+* to email-comb (which requires a raw HTML string), then parses the
+* result back to `ChildNode[]` so it fits in the DOM pipeline.
+*/
+function purgeCSS(dom, config = {}) {
+	const option = config.purge;
+	if (!option) return dom;
+	const userOptions = typeof option === "object" ? option : {};
+	const userSafelist = Array.isArray(userOptions.safelist) ? userOptions.safelist : [];
+	const { safelist: _discard, ...restUserOptions } = userOptions;
+	const options = defu({
+		...restUserOptions,
+		whitelist: [...DEFAULT_SAFELIST, ...userSafelist]
+	}, DEFAULT_OPTIONS);
+	const { result } = comb(serialize(dom), options);
+	return parse(result);
+}
+
+//#endregion
+export { purgeCSS };
+//# sourceMappingURL=purgeCSS.mjs.map

package/dist/transformers/purgeCSS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"purgeCSS.mjs","names":["merge"],"sources":["../../src/transformers/purgeCSS.ts"],"sourcesContent":["import { comb } from 'email-comb'\nimport { defu as merge } from 'defu'\nimport type { ChildNode } from 'domhandler'\nimport { parse, serialize } from '../utils/ast/index.ts'\nimport type { CssConfig } from '../types/config.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  '.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 * Remove unused CSS transformer.\n *\n * Uses `email-comb` to strip CSS selectors and corresponding class/id\n * references that are not matched anywhere in the HTML body.\n *\n * Enable by setting `css.purge: true` (or passing options).\n * The user-supplied options are merged on top of the defaults, so\n * `safelist` values are **appended** to the built-in safelist rather\n * than replacing it.\n *\n * Accepts `ChildNode[]` as input, serializes internally before passing\n * to email-comb (which requires a raw HTML string), then parses the\n * result back to `ChildNode[]` so it fits in the DOM pipeline.\n */\nexport function purgeCSS(dom: ChildNode[], config: CssConfig = {}): ChildNode[] {\n  const option = config.purge\n\n  if (!option) return dom\n\n  const userOptions = typeof option === 'object' ? option : {}\n\n  // Merge user options on top of defaults.\n  // defu merges objects deeply; for arrays it appends user values.\n  // We want the user safelist appended to the default safelist,\n  // so we build whitelist manually.\n  const userSafelist = Array.isArray((userOptions as any).safelist)\n    ? (userOptions as any).safelist as string[]\n    : []\n\n  const { safelist: _discard, ...restUserOptions } = userOptions as any\n\n  const options = merge(\n    { ...restUserOptions, whitelist: [...DEFAULT_SAFELIST, ...userSafelist] },\n    DEFAULT_OPTIONS,\n  )\n\n  const { result } = comb(serialize(dom), options)\n\n  return parse(result)\n}\n"],"mappings":";;;;;;;AAMA,MAAM,mBAA6B;CACjC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD;AAED,MAAM,kBAAkB;CACtB,SAAS,CACP;EAAE,OAAO;EAAM,OAAO;EAAM,EAC5B;EAAE,OAAO;EAAM,OAAO;EAAM,CAC7B;CACD,WAAW,CAAC,GAAG,iBAAiB;CACjC;;;;;;;;;;;;;;;;AAiBD,SAAgB,SAAS,KAAkB,SAAoB,EAAE,EAAe;CAC9E,MAAM,SAAS,OAAO;AAEtB,KAAI,CAAC,OAAQ,QAAO;CAEpB,MAAM,cAAc,OAAO,WAAW,WAAW,SAAS,EAAE;CAM5D,MAAM,eAAe,MAAM,QAAS,YAAoB,SAAS,GAC5D,YAAoB,WACrB,EAAE;CAEN,MAAM,EAAE,UAAU,UAAU,GAAG,oBAAoB;CAEnD,MAAM,UAAUA,KACd;EAAE,GAAG;EAAiB,WAAW,CAAC,GAAG,kBAAkB,GAAG,aAAa;EAAE,EACzE,gBACD;CAED,MAAM,EAAE,WAAW,KAAK,UAAU,IAAI,EAAE,QAAQ;AAEhD,QAAO,MAAM,OAAO"}

package/dist/transformers/removeAttributes.d.mts

@@ -0,0 +1,31 @@
+import { AttributesConfig } from "../types/config.mjs";
+import { ChildNode } from "domhandler";
+
+//#region src/transformers/removeAttributes.d.ts
+/**
+ * Remove attributes transformer.
+ *
+ * Removes specified HTML attributes from elements.
+ *
+ * By default, removes empty `style` and `class` attributes.
+ *
+ * Supports:
+ * - String: removes attribute when empty (boolean or empty string)
+ * - Object with name and value: removes when attribute matches exactly
+ * - Object with name and RegExp value: removes when attribute value matches regex
+ *
+ * Configured via `remove` array:
+ * ```js
+ * {
+ *   remove: [
+ *     'data-src',                    // Remove empty data-src attributes
+ *     { name: 'id', value: 'test' }, // Remove id="test" exactly
+ *     { name: 'data-id', value: /\d/ } // Remove data-id when value contains digits
+ *   ]
+ * }
+ * ```
+ */
+declare function removeAttributes(dom: ChildNode[], config?: AttributesConfig): ChildNode[];
+//#endregion
+export { removeAttributes };
+//# sourceMappingURL=removeAttributes.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"removeAttributes.d.mts","names":[],"sources":["../../src/transformers/removeAttributes.ts"],"mappings":";;;;;;AAkCA;;;;;;;;;;;;;;;;;;;;;iBAAgB,gBAAA,CAAiB,GAAA,EAAK,SAAA,IAAa,MAAA,GAAQ,gBAAA,GAAwB,SAAA"}

package/dist/transformers/removeAttributes.mjs

@@ -0,0 +1,63 @@
+import { walk } from "../utils/ast/walker.mjs";
+import "../utils/ast/index.mjs";
+
+//#region src/transformers/removeAttributes.ts
+/**
+* Remove attributes transformer.
+*
+* Removes specified HTML attributes from elements.
+*
+* By default, removes empty `style` and `class` attributes.
+*
+* Supports:
+* - String: removes attribute when empty (boolean or empty string)
+* - Object with name and value: removes when attribute matches exactly
+* - Object with name and RegExp value: removes when attribute value matches regex
+*
+* Configured via `remove` array:
+* ```js
+* {
+*   remove: [
+*     'data-src',                    // Remove empty data-src attributes
+*     { name: 'id', value: 'test' }, // Remove id="test" exactly
+*     { name: 'data-id', value: /\d/ } // Remove data-id when value contains digits
+*   ]
+* }
+* ```
+*/
+function removeAttributes(dom, config = {}) {
+	const removeOptions = config.remove;
+	const alwaysRemove = ["style", "class"];
+	let userOptions = [];
+	if (Array.isArray(removeOptions)) userOptions = removeOptions;
+	const attributesToRemove = [...alwaysRemove, ...userOptions];
+	if (attributesToRemove.length === 0) return dom;
+	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) shouldRemove = attrValue.test(currentValue);
+			else shouldRemove = currentValue === "";
+			if (shouldRemove) delete el.attribs[attrName];
+		}
+	});
+	return dom;
+}
+
+//#endregion
+export { removeAttributes };
+//# sourceMappingURL=removeAttributes.mjs.map

package/dist/transformers/removeAttributes.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"removeAttributes.mjs","names":[],"sources":["../../src/transformers/removeAttributes.ts"],"sourcesContent":["import type { ChildNode, Element } from 'domhandler'\nimport { walk } from '../utils/ast/index.ts'\nimport type { AttributesConfig } from '../types/config.ts'\n\ninterface RemoveAttributeConfig {\n  name: string\n  value?: string | RegExp | boolean\n}\n\ntype RemoveAttributeOption = string | RemoveAttributeConfig\n\n/**\n * Remove attributes transformer.\n *\n * Removes specified HTML attributes from elements.\n *\n * By default, removes empty `style` and `class` attributes.\n *\n * Supports:\n * - String: removes attribute when empty (boolean or empty string)\n * - Object with name and value: removes when attribute matches exactly\n * - Object with name and RegExp value: removes when attribute value matches regex\n *\n * Configured via `remove` array:\n * ```js\n * {\n *   remove: [\n *     'data-src',                    // Remove empty data-src attributes\n *     { name: 'id', value: 'test' }, // Remove id=\"test\" exactly\n *     { name: 'data-id', value: /\\d/ } // Remove data-id when value contains digits\n *   ]\n * }\n * ```\n */\nexport function removeAttributes(dom: ChildNode[], config: AttributesConfig = {}): ChildNode[] {\n  const removeOptions = config.remove\n\n  // Always remove empty style and class attributes by default\n  const alwaysRemove: RemoveAttributeOption[] = ['style', 'class']\n\n  // Parse user options\n  let userOptions: RemoveAttributeOption[] = []\n  if (Array.isArray(removeOptions)) {\n    userOptions = removeOptions as RemoveAttributeOption[]\n  }\n\n  // Combine default and user options\n  const attributesToRemove: RemoveAttributeOption[] = [...alwaysRemove, ...userOptions]\n\n  if (attributesToRemove.length === 0) {\n    return dom\n  }\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\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,iBAAiB,KAAkB,SAA2B,EAAE,EAAe;CAC7F,MAAM,gBAAgB,OAAO;CAG7B,MAAM,eAAwC,CAAC,SAAS,QAAQ;CAGhE,IAAI,cAAuC,EAAE;AAC7C,KAAI,MAAM,QAAQ,cAAc,CAC9B,eAAc;CAIhB,MAAM,qBAA8C,CAAC,GAAG,cAAc,GAAG,YAAY;AAErF,KAAI,mBAAmB,WAAW,EAChC,QAAO;AAGT,MAAK,MAAM,SAAS;EAClB,MAAM,KAAK;AACX,MAAI,CAAC,GAAG,QAAS;AAEjB,OAAK,MAAM,QAAQ,oBAAoB;GACrC,IAAI;GACJ,IAAI;AAEJ,OAAI,OAAO,SAAS,UAAU;AAC5B,eAAW;AACX,gBAAY;UACP;AACL,eAAW,KAAK;AAChB,gBAAY,KAAK;;GAGnB,MAAM,eAAe,GAAG,QAAQ;AAGhC,OAAI,iBAAiB,OAAW;GAEhC,IAAI,eAAe;AAEnB,OAAI,OAAO,cAAc,UAEvB,gBAAe,iBAAiB,MAAO,iBAA6B;YAC3D,OAAO,cAAc,SAE9B,gBAAe,iBAAiB;YACvB,qBAAqB,OAE9B,gBAAe,UAAU,KAAK,aAAa;OAG3C,gBAAe,iBAAiB;AAGlC,OAAI,aACF,QAAO,GAAG,QAAQ;;GAGtB;AAEF,QAAO"}

package/dist/transformers/replaceStrings.d.mts

@@ -0,0 +1,16 @@
+import { MaizzleConfig } from "../types/config.mjs";
+
+//#region src/transformers/replaceStrings.d.ts
+/**
+ * Replace strings transformer.
+ *
+ * Replaces strings in the HTML using the key-value pairs defined in
+ * `config.replaceStrings`. Each key is treated as a regular expression
+ * pattern (case-insensitive, global), and the value is the replacement.
+ *
+ * Character classes must be escaped in keys, e.g. `\\s` for `\s`.
+ */
+declare function replaceStrings(html: string, config?: MaizzleConfig): string;
+//#endregion
+export { replaceStrings };
+//# sourceMappingURL=replaceStrings.d.mts.map

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

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

package/dist/transformers/replaceStrings.mjs

@@ -0,0 +1,19 @@
+//#region src/transformers/replaceStrings.ts
+/**
+* Replace strings transformer.
+*
+* Replaces strings in the HTML using the key-value pairs defined in
+* `config.replaceStrings`. Each key is treated as a regular expression
+* pattern (case-insensitive, global), and the value is the replacement.
+*
+* Character classes must be escaped in keys, e.g. `\\s` for `\s`.
+*/
+function replaceStrings(html, config = {}) {
+	const replacements = config.replaceStrings;
+	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

package/dist/transformers/replaceStrings.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"replaceStrings.mjs","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,EAAE,EAAU;CAC/E,MAAM,eAAe,OAAO;AAE5B,KAAI,CAAC,gBAAgB,OAAO,KAAK,aAAa,CAAC,WAAW,EAAG,QAAO;AAEpE,QAAO,OAAO,QAAQ,aAAa,CAAC,QACjC,QAAQ,CAAC,SAAS,iBAAiB,OAAO,QAAQ,IAAI,OAAO,SAAS,KAAK,EAAE,YAAY,EAC1F,KACD"}

package/dist/transformers/safeClassNames.d.mts

@@ -0,0 +1,22 @@
+import { CssConfig } from "../types/config.mjs";
+import { ChildNode } from "domhandler";
+
+//#region src/transformers/safeClassNames.d.ts
+/**
+ * Safe class names 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.
+ */
+declare function safeClassNames(dom: ChildNode[], config?: CssConfig): ChildNode[];
+//#endregion
+export { safeClassNames };
+//# sourceMappingURL=safeClassNames.d.mts.map

package/dist/transformers/safeClassNames.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeClassNames.d.mts","names":[],"sources":["../../src/transformers/safeClassNames.ts"],"mappings":";;;;;;AAsGA;;;;;;;;;;;;iBAAgB,cAAA,CAAe,GAAA,EAAK,SAAA,IAAa,MAAA,GAAQ,SAAA,GAAiB,SAAA"}

package/dist/transformers/safeClassNames.mjs

@@ -0,0 +1,103 @@
+import { walk } from "../utils/ast/walker.mjs";
+import "../utils/ast/index.mjs";
+import postcss from "postcss";
+import safeParser from "postcss-safe-parser";
+
+//#region src/transformers/safeClassNames.ts
+const DEFAULT_REPLACEMENTS = {
+	":": "-",
+	"/": "-",
+	"%": "pc",
+	".": "_",
+	",": "_",
+	"#": "_",
+	"[": "",
+	"]": "",
+	"(": "",
+	")": "",
+	"{": "",
+	"}": "",
+	"!": "-i",
+	"&": "and-",
+	"<": "lt-",
+	"=": "eq-",
+	">": "gt-",
+	"|": "or-",
+	"@": "at-",
+	"?": "q-",
+	"\\": "-",
+	"\"": "-",
+	"'": "-",
+	"*": "-",
+	"+": "-",
+	";": "-",
+	"^": "-",
+	"`": "-",
+	"~": "-",
+	"$": "-"
+};
+function escapeForRegex(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+* Replace escaped special characters in CSS selectors.
+*
+* Tailwind generates selectors like `.sm\:text-base`. This function
+* replaces the `\:` with `-` (or whatever the configured replacement is)
+* so the selector becomes `.sm-text-base`, which is safe for email clients.
+*/
+function processCssSelectors(css, replacements) {
+	const selectorRegex = new RegExp(`\\\\(${Object.keys(replacements).map(escapeForRegex).join("|")})`, "g");
+	return postcss([(root) => {
+		root.walkRules((rule) => {
+			rule.selector = rule.selector.replace(selectorRegex, (_matched, char) => replacements[char] ?? _matched).replaceAll("\\2c ", "_");
+		});
+	}]).process(css, { parser: safeParser }).css;
+}
+/**
+* Replace unsafe special characters in a class attribute value.
+*
+* Splits on whitespace and replaces each char from the replacements map
+* in each class token individually.
+*/
+function processClassAttr(classStr, replacements) {
+	return classStr.split(/\s+/).filter(Boolean).map((cls) => {
+		for (const [from, to] of Object.entries(replacements)) cls = cls.split(from).join(to);
+		return cls;
+	}).join(" ");
+}
+/**
+* Safe class names 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.
+*/
+function safeClassNames(dom, config = {}) {
+	const option = config.safe ?? true;
+	if (!option) return dom;
+	const replacements = option && typeof option === "object" ? {
+		...DEFAULT_REPLACEMENTS,
+		...option
+	} : DEFAULT_REPLACEMENTS;
+	walk(dom, (node) => {
+		const el = node;
+		if (el.name === "style" && el.children?.length) {
+			const text = el.children.find((c) => c.type === "text");
+			if (text?.data?.trim()) text.data = processCssSelectors(text.data, replacements);
+		}
+		if ("attribs" in el && el.attribs?.class) el.attribs.class = processClassAttr(el.attribs.class, replacements);
+	});
+	return dom;
+}
+
+//#endregion
+export { safeClassNames };
+//# sourceMappingURL=safeClassNames.mjs.map

package/dist/transformers/safeClassNames.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeClassNames.mjs","names":[],"sources":["../../src/transformers/safeClassNames.ts"],"sourcesContent":["import postcss from 'postcss'\nimport safeParser from 'postcss-safe-parser'\nimport type { ChildNode, Element } from 'domhandler'\nimport { walk } from '../utils/ast/index.ts'\nimport type { CssConfig } from '../types/config.ts'\n\nconst DEFAULT_REPLACEMENTS: Record<string, string> = {\n  ':': '-',\n  '/': '-',\n  '%': 'pc',\n  '.': '_',\n  ',': '_',\n  '#': '_',\n  '[': '',\n  ']': '',\n  '(': '',\n  ')': '',\n  '{': '',\n  '}': '',\n  '!': '-i',\n  '&': 'and-',\n  '<': 'lt-',\n  '=': 'eq-',\n  '>': 'gt-',\n  '|': 'or-',\n  '@': 'at-',\n  '?': 'q-',\n  '\\\\': '-',\n  '\"': '-',\n  \"'\": '-',\n  '*': '-',\n  '+': '-',\n  ';': '-',\n  '^': '-',\n  '`': '-',\n  '~': '-',\n  '$': '-',\n}\n\nfunction escapeForRegex(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n\n/**\n * Replace escaped special characters in CSS selectors.\n *\n * Tailwind generates selectors like `.sm\\:text-base`. This function\n * replaces the `\\:` with `-` (or whatever the configured replacement is)\n * so the selector becomes `.sm-text-base`, which is safe for email clients.\n */\nfunction processCssSelectors(css: string, replacements: Record<string, string>): string {\n  // Matches \\<char> in CSS selectors — e.g. \\: \\/ \\. \\[ etc.\n  const selectorRegex = new RegExp(\n    `\\\\\\\\(${Object.keys(replacements).map(escapeForRegex).join('|')})`,\n    'g',\n  )\n\n  return postcss([\n    (root: postcss.Root) => {\n      root.walkRules((rule: postcss.Rule) => {\n        rule.selector = rule.selector\n          .replace(selectorRegex, (_matched, char) => replacements[char] ?? _matched)\n          // Handle CSS unicode escape for comma (\\2c  → _)\n          .replaceAll('\\\\2c ', '_')\n      })\n    },\n  ]).process(css, { parser: safeParser }).css\n}\n\n/**\n * Replace unsafe special characters in a class attribute value.\n *\n * Splits on whitespace and replaces each char from the replacements map\n * in each class token individually.\n */\nfunction processClassAttr(classStr: string, replacements: Record<string, string>): string {\n  return classStr\n    .split(/\\s+/)\n    .filter(Boolean)\n    .map((cls) => {\n      for (const [from, to] of Object.entries(replacements)) {\n        cls = cls.split(from).join(to)\n      }\n      return cls\n    })\n    .join(' ')\n}\n\n/**\n * Safe class names transformer.\n *\n * Replaces unsafe characters (`:`, `/`, `[`, `]`, etc.) in:\n * - CSS selectors inside `<style>` tags\n * - HTML `class` attributes\n *\n * This makes Tailwind utility classes like `sm:text-base` safe for\n * email clients that cannot handle escaped characters in class names.\n *\n * Enabled by default. Disable by setting `css.safe` to `false`.\n * Customize replacements by passing a `Record<string, string>` — user\n * values are merged on top of the defaults.\n */\nexport function safeClassNames(dom: ChildNode[], config: CssConfig = {}): ChildNode[] {\n  const option = config.safe ?? true\n\n  if (!option) return dom\n\n  const replacements: Record<string, string> =\n    option && typeof option === 'object'\n      ? { ...DEFAULT_REPLACEMENTS, ...option }\n      : DEFAULT_REPLACEMENTS\n\n  walk(dom, (node) => {\n    const el = node as Element\n\n    // Process CSS selectors inside <style> tags\n    if (el.name === 'style' && el.children?.length) {\n      const text = el.children.find((c) => c.type === 'text') as any\n      if (text?.data?.trim()) {\n        text.data = processCssSelectors(text.data, replacements)\n      }\n    }\n\n    // Replace special chars in class attributes\n    if ('attribs' in el && el.attribs?.class) {\n      el.attribs.class = processClassAttr(el.attribs.class, replacements)\n    }\n  })\n\n  return dom\n}\n"],"mappings":";;;;;;AAMA,MAAM,uBAA+C;CACnD,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,MAAM;CACN,MAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACN;AAED,SAAS,eAAe,GAAmB;AACzC,QAAO,EAAE,QAAQ,uBAAuB,OAAO;;;;;;;;;AAUjD,SAAS,oBAAoB,KAAa,cAA8C;CAEtF,MAAM,gBAAgB,IAAI,OACxB,QAAQ,OAAO,KAAK,aAAa,CAAC,IAAI,eAAe,CAAC,KAAK,IAAI,CAAC,IAChE,IACD;AAED,QAAO,QAAQ,EACZ,SAAuB;AACtB,OAAK,WAAW,SAAuB;AACrC,QAAK,WAAW,KAAK,SAClB,QAAQ,gBAAgB,UAAU,SAAS,aAAa,SAAS,SAAS,CAE1E,WAAW,SAAS,IAAI;IAC3B;GAEL,CAAC,CAAC,QAAQ,KAAK,EAAE,QAAQ,YAAY,CAAC,CAAC;;;;;;;;AAS1C,SAAS,iBAAiB,UAAkB,cAA8C;AACxF,QAAO,SACJ,MAAM,MAAM,CACZ,OAAO,QAAQ,CACf,KAAK,QAAQ;AACZ,OAAK,MAAM,CAAC,MAAM,OAAO,OAAO,QAAQ,aAAa,CACnD,OAAM,IAAI,MAAM,KAAK,CAAC,KAAK,GAAG;AAEhC,SAAO;GACP,CACD,KAAK,IAAI;;;;;;;;;;;;;;;;AAiBd,SAAgB,eAAe,KAAkB,SAAoB,EAAE,EAAe;CACpF,MAAM,SAAS,OAAO,QAAQ;AAE9B,KAAI,CAAC,OAAQ,QAAO;CAEpB,MAAM,eACJ,UAAU,OAAO,WAAW,WACxB;EAAE,GAAG;EAAsB,GAAG;EAAQ,GACtC;AAEN,MAAK,MAAM,SAAS;EAClB,MAAM,KAAK;AAGX,MAAI,GAAG,SAAS,WAAW,GAAG,UAAU,QAAQ;GAC9C,MAAM,OAAO,GAAG,SAAS,MAAM,MAAM,EAAE,SAAS,OAAO;AACvD,OAAI,MAAM,MAAM,MAAM,CACpB,MAAK,OAAO,oBAAoB,KAAK,MAAM,aAAa;;AAK5D,MAAI,aAAa,MAAM,GAAG,SAAS,MACjC,IAAG,QAAQ,QAAQ,iBAAiB,GAAG,QAAQ,OAAO,aAAa;GAErE;AAEF,QAAO"}

package/dist/transformers/shorthandCSS.d.mts

@@ -0,0 +1,24 @@
+import { CssConfig } from "../types/config.mjs";
+import { ChildNode } from "domhandler";
+
+//#region src/transformers/shorthandCSS.d.ts
+/**
+ * Shorthand CSS transformer.
+ *
+ * Rewrites longhand CSS inside `style` attributes with shorthand syntax.
+ * Works with margin, padding, and border when all sides are specified.
+ *
+ * For example:
+ * `margin-left: 2px; margin-right: 2px; margin-top: 4px; margin-bottom: 4px`
+ * becomes:
+ * `margin: 4px 2px`
+ *
+ * Enabled via `css.shorthand`:
+ * - `true`: enable for all tags
+ * - `{ tags: ['td', 'div'] }`: enable only for specified tags
+ * - `false` or omitted: disabled
+ */
+declare function shorthandCSS(dom: ChildNode[], config?: CssConfig): ChildNode[];
+//#endregion
+export { shorthandCSS };
+//# sourceMappingURL=shorthandCSS.d.mts.map

package/dist/transformers/shorthandCSS.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shorthandCSS.d.mts","names":[],"sources":["../../src/transformers/shorthandCSS.ts"],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;iBAAgB,YAAA,CAAa,GAAA,EAAK,SAAA,IAAa,MAAA,GAAQ,SAAA,GAAiB,SAAA"}

package/dist/transformers/shorthandCSS.mjs

@@ -0,0 +1,48 @@
+import { walk } from "../utils/ast/walker.mjs";
+import "../utils/ast/index.mjs";
+import postcss from "postcss";
+import safeParser from "postcss-safe-parser";
+import mergeLonghand from "postcss-merge-longhand";
+
+//#region src/transformers/shorthandCSS.ts
+/**
+* Shorthand CSS transformer.
+*
+* Rewrites longhand CSS inside `style` attributes with shorthand syntax.
+* Works with margin, padding, and border when all sides are specified.
+*
+* For example:
+* `margin-left: 2px; margin-right: 2px; margin-top: 4px; margin-bottom: 4px`
+* becomes:
+* `margin: 4px 2px`
+*
+* Enabled via `css.shorthand`:
+* - `true`: enable for all tags
+* - `{ tags: ['td', 'div'] }`: enable only for specified tags
+* - `false` or omitted: disabled
+*/
+function shorthandCSS(dom, config = {}) {
+	const option = config.shorthand;
+	if (!option) return dom;
+	const allowedTags = (typeof option === "object" ? option : {}).tags ?? [];
+	const hasTagFilter = allowedTags.length > 0;
+	walk(dom, (node) => {
+		const el = node;
+		if (!el.attribs?.style) return;
+		if (hasTagFilter && !allowedTags.includes(el.name)) return;
+		const styleValue = el.attribs.style;
+		try {
+			const { css } = postcss().use(mergeLonghand).process(`div { ${styleValue} }`, { parser: safeParser });
+			const match = css.match(/div\s*\{\s*([^}]+)\s*\}/);
+			if (match && match[1]) {
+				const newStyle = match[1].trim();
+				if (newStyle !== styleValue) el.attribs.style = newStyle;
+			}
+		} catch {}
+	});
+	return dom;
+}
+
+//#endregion
+export { shorthandCSS };
+//# sourceMappingURL=shorthandCSS.mjs.map

package/dist/transformers/shorthandCSS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shorthandCSS.mjs","names":[],"sources":["../../src/transformers/shorthandCSS.ts"],"sourcesContent":["import postcss from 'postcss'\nimport safeParser from 'postcss-safe-parser'\nimport mergeLonghand from 'postcss-merge-longhand'\nimport type { ChildNode, Element } from 'domhandler'\nimport { walk } from '../utils/ast/index.ts'\nimport type { CssConfig } from '../types/config.ts'\n\ninterface ShorthandCssOptions {\n  tags?: string[]\n}\n\n/**\n * Shorthand CSS transformer.\n *\n * Rewrites longhand CSS inside `style` attributes with shorthand syntax.\n * Works with margin, padding, and border when all sides are specified.\n *\n * For example:\n * `margin-left: 2px; margin-right: 2px; margin-top: 4px; margin-bottom: 4px`\n * becomes:\n * `margin: 4px 2px`\n *\n * Enabled via `css.shorthand`:\n * - `true`: enable for all tags\n * - `{ tags: ['td', 'div'] }`: enable only for specified tags\n * - `false` or omitted: disabled\n */\nexport function shorthandCSS(dom: ChildNode[], config: CssConfig = {}): ChildNode[] {\n  const option = config.shorthand\n\n  // Disabled by default\n  if (!option) {\n    return dom\n  }\n\n  // Parse options\n  const options: ShorthandCssOptions = typeof option === 'object' ? option : {}\n  const allowedTags = options.tags ?? []\n  const hasTagFilter = allowedTags.length > 0\n\n  walk(dom, (node) => {\n    const el = node as Element\n\n    // Skip if no attribs or no style\n    if (!el.attribs?.style) {\n      return\n    }\n\n    // Skip if tag filter is active and this tag is not allowed\n    if (hasTagFilter && !allowedTags.includes(el.name)) {\n      return\n    }\n\n    const styleValue = el.attribs.style\n\n    try {\n      // Process the style with postcss-merge-longhand\n      // Wrap in a dummy selector since postcss needs a rule\n      const { css } = postcss()\n        .use(mergeLonghand)\n        .process(`div { ${styleValue} }`, { parser: safeParser })\n\n      // Extract the content between the braces\n      const match = css.match(/div\\s*\\{\\s*([^}]+)\\s*\\}/)\n      if (match && match[1]) {\n        const newStyle = match[1].trim()\n        if (newStyle !== styleValue) {\n          el.attribs.style = newStyle\n        }\n      }\n    } catch {\n      // If processing fails, keep the original style\n    }\n  })\n\n  return dom\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA2BA,SAAgB,aAAa,KAAkB,SAAoB,EAAE,EAAe;CAClF,MAAM,SAAS,OAAO;AAGtB,KAAI,CAAC,OACH,QAAO;CAKT,MAAM,eAD+B,OAAO,WAAW,WAAW,SAAS,EAAE,EACjD,QAAQ,EAAE;CACtC,MAAM,eAAe,YAAY,SAAS;AAE1C,MAAK,MAAM,SAAS;EAClB,MAAM,KAAK;AAGX,MAAI,CAAC,GAAG,SAAS,MACf;AAIF,MAAI,gBAAgB,CAAC,YAAY,SAAS,GAAG,KAAK,CAChD;EAGF,MAAM,aAAa,GAAG,QAAQ;AAE9B,MAAI;GAGF,MAAM,EAAE,QAAQ,SAAS,CACtB,IAAI,cAAc,CAClB,QAAQ,SAAS,WAAW,KAAK,EAAE,QAAQ,YAAY,CAAC;GAG3D,MAAM,QAAQ,IAAI,MAAM,0BAA0B;AAClD,OAAI,SAAS,MAAM,IAAI;IACrB,MAAM,WAAW,MAAM,GAAG,MAAM;AAChC,QAAI,aAAa,WACf,IAAG,QAAQ,QAAQ;;UAGjB;GAGR;AAEF,QAAO"}

package/dist/transformers/tailwindcss.d.mts

@@ -0,0 +1,20 @@
+import { MaizzleConfig } from "../types/config.mjs";
+import { ChildNode } from "domhandler";
+
+//#region src/transformers/tailwindcss.d.ts
+/**
+ * Tailwind CSS transformer.
+ *
+ * Compiles CSS inside <style> tags in the DOM using
+ * @tailwindcss/postcss, then lowers modern CSS syntax with lightningcss.
+ *
+ * Uses the AST walker to find <style> tags and decodes HTML entities
+ * that Vue SSR encodes (e.g. &quot;) before CSS processing.
+ *
+ * Runs as the first transformer in the pipeline so that subsequent
+ * transformers (inliner, purge, etc.) work with fully compiled CSS.
+ */
+declare function tailwindcss(dom: ChildNode[], config: MaizzleConfig, filePath?: string): Promise<ChildNode[]>;
+//#endregion
+export { tailwindcss };
+//# sourceMappingURL=tailwindcss.d.mts.map

package/dist/transformers/tailwindcss.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tailwindcss.d.mts","names":[],"sources":["../../src/transformers/tailwindcss.ts"],"mappings":";;;;;;AA6FA;;;;;;;;;;iBAAsB,WAAA,CAAY,GAAA,EAAK,SAAA,IAAa,MAAA,EAAQ,aAAA,EAAe,QAAA,YAAoB,OAAA,CAAQ,SAAA"}

package/dist/transformers/tailwindcss.mjs

@@ -0,0 +1,136 @@
+import { walk } from "../utils/ast/walker.mjs";
+import "../utils/ast/index.mjs";
+import pruneVars_default from "../plugins/postcss/pruneVars.mjs";
+import { tailwindCleanup } from "../plugins/postcss/tailwindCleanup.mjs";
+import { mergeMediaQueries } from "../plugins/postcss/mergeMediaQueries.mjs";
+import { dirname, relative, resolve } from "node:path";
+import postcss from "postcss";
+import tailwindcssPostcss from "@tailwindcss/postcss";
+import customProperties from "postcss-custom-properties";
+import safeParser from "postcss-safe-parser";
+import { transform } from "lightningcss";
+
+//#region src/transformers/tailwindcss.ts
+function createProcessor(config) {
+	return postcss([
+		tailwindcssPostcss({
+			base: config.css?.base,
+			transformAssetUrls: false,
+			optimize: false
+		}),
+		customProperties({ preserve: false }),
+		pruneVars_default()
+	]);
+}
+/**
+* Decode HTML entities that Vue SSR encodes inside <style> tags.
+*
+* Vue's renderToString HTML-encodes quotes and other characters
+* inside <style> tags within templates, breaking CSS like
+* `@import "@maizzle/tailwindcss"` → `@import &quot;...&quot;`
+*/
+function decodeEntities(str) {
+	return str.replace(/&quot;/g, "\"").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&#39;/g, "'").replace(/&apos;/g, "'");
+}
+/**
+* Lower modern CSS syntax using lightningcss.
+*
+* Targets IE 1 to maximize syntax lowering — converts modern features
+* like nesting, oklch(), color-mix(), @property, etc. into simple CSS
+* that email clients can understand.
+*/
+function lowerSyntax(css) {
+	return transform({
+		filename: "email.css",
+		code: Buffer.from(css),
+		minify: false,
+		targets: { ie: 128 }
+	}).code.toString();
+}
+/**
+* Run cleanup and media query merging on the compiled CSS.
+*
+* Removes unwanted selectors (:host, :lang) and at-rules (@layer, @property),
+* then sorts and merges media queries.
+*/
+async function optimizeCss(css, config) {
+	const plugins = [...tailwindCleanup(config)];
+	const mediaPlugin = mergeMediaQueries(config);
+	if (mediaPlugin) plugins.push(mediaPlugin);
+	return (await postcss(plugins).process(css, { from: void 0 })).css;
+}
+/**
+* Tailwind CSS transformer.
+*
+* Compiles CSS inside <style> tags in the DOM using
+* @tailwindcss/postcss, then lowers modern CSS syntax with lightningcss.
+*
+* Uses the AST walker to find <style> tags and decodes HTML entities
+* that Vue SSR encodes (e.g. &quot;) before CSS processing.
+*
+* Runs as the first transformer in the pipeline so that subsequent
+* transformers (inliner, purge, etc.) work with fully compiled CSS.
+*/
+async function tailwindcss(dom, config, filePath) {
+	const sourceNotPaths = [resolve(config.output?.path ?? "dist"), ...(config.css?.exclude ?? []).map((p) => resolve(p))];
+	const styleTags = [];
+	walk(dom, (node) => {
+		if (node.name !== "style") return;
+		const el = node;
+		const attrs = el.attribs || {};
+		const markerAttr = [
+			"raw",
+			"embed",
+			"data-embed"
+		].find((attr) => attr in attrs);
+		if (markerAttr) {
+			delete el.attribs[markerAttr];
+			return;
+		}
+		const rawContent = el.children.filter((child) => child.type === "text").map((child) => child.data).join("");
+		if (!rawContent.trim()) return;
+		let cssContent = decodeEntities(rawContent);
+		if (filePath) {
+			if (sourceNotPaths.length) {
+				const fileDir = dirname(filePath);
+				const exclusions = sourceNotPaths.map((p) => `@source not "${relative(fileDir, resolve(p))}";`).join("\n");
+				cssContent = `${cssContent}\n${exclusions}`;
+			}
+		} else {
+			const classes = [];
+			walk(dom, (n) => {
+				const cls = n.attribs?.class;
+				if (cls) classes.push(cls);
+			});
+			if (classes.length) cssContent = `${cssContent}\n@source inline("${classes.join(" ")}");`;
+		}
+		styleTags.push({
+			node: el,
+			cssContent
+		});
+	});
+	for (let i = 0; i < styleTags.length; i++) {
+		const { node, cssContent } = styleTags[i];
+		try {
+			node.children = [{
+				type: "text",
+				data: await optimizeCss(lowerSyntax((await createProcessor(config).process(cssContent, {
+					from: `${filePath ?? resolve(process.cwd(), "template.vue")}?style=${i}`,
+					parser: safeParser
+				})).css), config),
+				parent: node
+			}];
+		} catch {
+			node.children = [{
+				type: "text",
+				data: cssContent,
+				parent: node
+			}];
+		}
+	}
+	return dom;
+}
+
+//#endregion
+export { tailwindcss };
+//# sourceMappingURL=tailwindcss.mjs.map

package/dist/transformers/tailwindcss.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"tailwindcss.mjs","names":["pruneVars"],"sources":["../../src/transformers/tailwindcss.ts"],"sourcesContent":["import postcss from 'postcss'\nimport tailwindcssPostcss from '@tailwindcss/postcss'\nimport customProperties from 'postcss-custom-properties'\nimport pruneVars from '../plugins/postcss/pruneVars.ts'\nimport safeParser from 'postcss-safe-parser'\nimport { transform } from 'lightningcss'\nimport { resolve, dirname, relative } from 'node:path'\nimport type { ChildNode, Element } from 'domhandler'\nimport { walk } from '../utils/ast/index.ts'\nimport { tailwindCleanup } from '../plugins/postcss/tailwindCleanup.ts'\nimport { mergeMediaQueries } from '../plugins/postcss/mergeMediaQueries.ts'\nimport type { MaizzleConfig } from '../types/config.ts'\n\nfunction createProcessor(config: MaizzleConfig) {\n  return postcss([\n    tailwindcssPostcss({\n      base: config.css?.base,\n      transformAssetUrls: false,\n      optimize: false, // we run Lightning CSS manually\n    }),\n    customProperties({\n      preserve: false,\n    }),\n    pruneVars(),\n  ])\n}\n\n/**\n * Decode HTML entities that Vue SSR encodes inside <style> tags.\n *\n * Vue's renderToString HTML-encodes quotes and other characters\n * inside <style> tags within templates, breaking CSS like\n * `@import \"@maizzle/tailwindcss\"` → `@import &quot;...&quot;`\n */\nfunction decodeEntities(str: string): string {\n  return str\n    .replace(/&quot;/g, '\"')\n    .replace(/&amp;/g, '&')\n    .replace(/&lt;/g, '<')\n    .replace(/&gt;/g, '>')\n    .replace(/&#39;/g, \"'\")\n    .replace(/&apos;/g, \"'\")\n}\n\n/**\n * Lower modern CSS syntax using lightningcss.\n *\n * Targets IE 1 to maximize syntax lowering — converts modern features\n * like nesting, oklch(), color-mix(), @property, etc. into simple CSS\n * that email clients can understand.\n */\nfunction lowerSyntax(css: string): string {\n  const result = transform({\n    filename: 'email.css',\n    code: Buffer.from(css),\n    minify: false,\n    targets: {\n      ie: 4 << 5,\n    },\n  })\n\n  return result.code.toString()\n}\n\n/**\n * Run cleanup and media query merging on the compiled CSS.\n *\n * Removes unwanted selectors (:host, :lang) and at-rules (@layer, @property),\n * then sorts and merges media queries.\n */\nasync function optimizeCss(css: string, config: MaizzleConfig): Promise<string> {\n  const plugins: postcss.Plugin[] = [...tailwindCleanup(config)]\n\n  const mediaPlugin = mergeMediaQueries(config)\n  if (mediaPlugin) plugins.push(mediaPlugin)\n\n  const result = await postcss(plugins).process(css, { from: undefined })\n\n  return result.css\n}\n\n/**\n * Tailwind CSS transformer.\n *\n * Compiles CSS inside <style> tags in the DOM using\n * @tailwindcss/postcss, then lowers modern CSS syntax with lightningcss.\n *\n * Uses the AST walker to find <style> tags and decodes HTML entities\n * that Vue SSR encodes (e.g. &quot;) before CSS processing.\n *\n * Runs as the first transformer in the pipeline so that subsequent\n * transformers (inliner, purge, etc.) work with fully compiled CSS.\n */\nexport async function tailwindcss(dom: ChildNode[], config: MaizzleConfig, filePath?: string): Promise<ChildNode[]> {\n  const sourceNotPaths = [\n    resolve(config.output?.path ?? 'dist'),\n    ...(config.css?.exclude ?? []).map(p => resolve(p)),\n  ]\n\n  const styleTags: { node: Element; cssContent: string }[] = []\n\n  walk(dom, (node) => {\n    if ((node as Element).name !== 'style') return\n\n    const el = node as Element\n    const attrs = el.attribs || {}\n\n    // Skip marked style tags, but remove the marker attribute first\n    const markerAttr = ['raw', 'embed', 'data-embed'].find(attr => attr in attrs)\n    if (markerAttr) {\n      delete el.attribs[markerAttr]\n      return\n    }\n\n    // Get text content from children and decode HTML entities\n    const rawContent = el.children\n      .filter(child => child.type === 'text')\n      .map(child => (child as any).data)\n      .join('')\n\n    if (!rawContent.trim()) return\n\n    let cssContent = decodeEntities(rawContent)\n\n    if (filePath) {\n      if (sourceNotPaths.length) {\n        const fileDir = dirname(filePath)\n        const exclusions = sourceNotPaths\n          .map(p => `@source not \"${relative(fileDir, resolve(p))}\";`)\n          .join('\\n')\n\n        cssContent = `${cssContent}\\n${exclusions}`\n      }\n    } else {\n      // No file path (e.g. component input) — extract classes from the DOM\n      // and tell Tailwind to scan them via @source inline()\n      const classes: string[] = []\n      walk(dom, (n) => {\n        const cls = (n as Element).attribs?.class\n        if (cls) classes.push(cls)\n      })\n\n      if (classes.length) {\n        cssContent = `${cssContent}\\n@source inline(\"${classes.join(' ')}\");`\n      }\n    }\n\n    styleTags.push({ node: el, cssContent })\n  })\n\n  for (let i = 0; i < styleTags.length; i++) {\n    const { node, cssContent } = styleTags[i]\n    try {\n      const processor = createProcessor(config)\n      const result = await processor.process(\n        cssContent,\n        {\n          from: `${filePath ?? resolve(process.cwd(), 'template.vue')}?style=${i}`,\n          parser: safeParser,\n        }\n      )\n\n      const lowered = lowerSyntax(result.css)\n      const optimized = await optimizeCss(lowered, config)\n\n      // Replace the style tag's children with the compiled CSS\n      node.children = [{\n        type: 'text',\n        data: optimized,\n        parent: node,\n      } as any]\n    } catch {\n      // If CSS processing fails, still replace with decoded content\n      // so HTML entities don't break the CSS\n      node.children = [{\n        type: 'text',\n        data: cssContent,\n        parent: node,\n      } as any]\n    }\n  }\n\n  return dom\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,SAAS,gBAAgB,QAAuB;AAC9C,QAAO,QAAQ;EACb,mBAAmB;GACjB,MAAM,OAAO,KAAK;GAClB,oBAAoB;GACpB,UAAU;GACX,CAAC;EACF,iBAAiB,EACf,UAAU,OACX,CAAC;EACFA,mBAAW;EACZ,CAAC;;;;;;;;;AAUJ,SAAS,eAAe,KAAqB;AAC3C,QAAO,IACJ,QAAQ,WAAW,KAAI,CACvB,QAAQ,UAAU,IAAI,CACtB,QAAQ,SAAS,IAAI,CACrB,QAAQ,SAAS,IAAI,CACrB,QAAQ,UAAU,IAAI,CACtB,QAAQ,WAAW,IAAI;;;;;;;;;AAU5B,SAAS,YAAY,KAAqB;AAUxC,QATe,UAAU;EACvB,UAAU;EACV,MAAM,OAAO,KAAK,IAAI;EACtB,QAAQ;EACR,SAAS,EACP,IAAI,KACL;EACF,CAAC,CAEY,KAAK,UAAU;;;;;;;;AAS/B,eAAe,YAAY,KAAa,QAAwC;CAC9E,MAAM,UAA4B,CAAC,GAAG,gBAAgB,OAAO,CAAC;CAE9D,MAAM,cAAc,kBAAkB,OAAO;AAC7C,KAAI,YAAa,SAAQ,KAAK,YAAY;AAI1C,SAFe,MAAM,QAAQ,QAAQ,CAAC,QAAQ,KAAK,EAAE,MAAM,QAAW,CAAC,EAEzD;;;;;;;;;;;;;;AAehB,eAAsB,YAAY,KAAkB,QAAuB,UAAyC;CAClH,MAAM,iBAAiB,CACrB,QAAQ,OAAO,QAAQ,QAAQ,OAAO,EACtC,IAAI,OAAO,KAAK,WAAW,EAAE,EAAE,KAAI,MAAK,QAAQ,EAAE,CAAC,CACpD;CAED,MAAM,YAAqD,EAAE;AAE7D,MAAK,MAAM,SAAS;AAClB,MAAK,KAAiB,SAAS,QAAS;EAExC,MAAM,KAAK;EACX,MAAM,QAAQ,GAAG,WAAW,EAAE;EAG9B,MAAM,aAAa;GAAC;GAAO;GAAS;GAAa,CAAC,MAAK,SAAQ,QAAQ,MAAM;AAC7E,MAAI,YAAY;AACd,UAAO,GAAG,QAAQ;AAClB;;EAIF,MAAM,aAAa,GAAG,SACnB,QAAO,UAAS,MAAM,SAAS,OAAO,CACtC,KAAI,UAAU,MAAc,KAAK,CACjC,KAAK,GAAG;AAEX,MAAI,CAAC,WAAW,MAAM,CAAE;EAExB,IAAI,aAAa,eAAe,WAAW;AAE3C,MAAI,UACF;OAAI,eAAe,QAAQ;IACzB,MAAM,UAAU,QAAQ,SAAS;IACjC,MAAM,aAAa,eAChB,KAAI,MAAK,gBAAgB,SAAS,SAAS,QAAQ,EAAE,CAAC,CAAC,IAAI,CAC3D,KAAK,KAAK;AAEb,iBAAa,GAAG,WAAW,IAAI;;SAE5B;GAGL,MAAM,UAAoB,EAAE;AAC5B,QAAK,MAAM,MAAM;IACf,MAAM,MAAO,EAAc,SAAS;AACpC,QAAI,IAAK,SAAQ,KAAK,IAAI;KAC1B;AAEF,OAAI,QAAQ,OACV,cAAa,GAAG,WAAW,oBAAoB,QAAQ,KAAK,IAAI,CAAC;;AAIrE,YAAU,KAAK;GAAE,MAAM;GAAI;GAAY,CAAC;GACxC;AAEF,MAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;EACzC,MAAM,EAAE,MAAM,eAAe,UAAU;AACvC,MAAI;AAcF,QAAK,WAAW,CAAC;IACf,MAAM;IACN,MALgB,MAAM,YADR,aARD,MADG,gBAAgB,OAAO,CACV,QAC7B,YACA;KACE,MAAM,GAAG,YAAY,QAAQ,QAAQ,KAAK,EAAE,eAAe,CAAC,SAAS;KACrE,QAAQ;KACT,CACF,EAEkC,IAAI,EACM,OAAO;IAMlD,QAAQ;IACT,CAAQ;UACH;AAGN,QAAK,WAAW,CAAC;IACf,MAAM;IACN,MAAM;IACN,QAAQ;IACT,CAAQ;;;AAIb,QAAO"}