@maizzle/framework 6.0.0-rc.17 → 6.0.0-rc.19

package/dist/transformers/entities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entities.js","names":["merge"],"sources":["../../src/transformers/entities.ts"],"sourcesContent":["import { defu as merge } from 'defu'\nimport type { ChildNode } from 'domhandler'\nimport { parse, serialize, walk } from '../utils/ast/index.ts'\nimport type { EntitiesConfig } from '../types/index.ts'\n\nconst DEFAULT_ENTITIES: Record<string, string> = {\n  '\\u200D': '&zwj;',\n  '\\u200C': '&zwnj;',\n  '\\u00A0': '&nbsp;',\n  '\\u00AD': '&shy;',\n  '\\u200B': '&#8203;',\n  '\\u2007': '&#8199;',\n  '\\u034F': '&#847;',\n  '\\u2003': '&emsp;',\n  '\\u2028': '&LineSeparator;',\n  '\\u2029': '&ParagraphSeparator;',\n  '\\u00B7': '&middot;',\n  '\\u2013': '&ndash;',\n  '\\u2014': '&mdash;',\n  '\\u2018': '&lsquo;',\n  '\\u2019': '&rsquo;',\n  '\\u201C': '&ldquo;',\n  '\\u201D': '&rdquo;',\n  '\\u00AB': '&laquo;',\n  '\\u00BB': '&raquo;',\n  '\\u2022': '&bull;',\n  '\\u2039': '&lsaquo;',\n  '\\u203A': '&rsaquo;'\n}\n\n/**\n * Replace literal Unicode characters in text nodes with their HTML entity\n * equivalents (zero-width joiners, non-breaking spaces, smart quotes,\n * dashes, etc.) for better email-client rendering.\n *\n * @param html   HTML string to transform.\n * @param custom Extra entries merged on top of the built-in entity map, or\n *               `false` to disable the transform. Defaults to `true`\n *               (built-ins only).\n * @returns      The transformed HTML string.\n *\n * @example\n * import { entities } from '@maizzle/framework'\n *\n * // Defaults only\n * entities('hello world') // → 'hello&nbsp;world'\n *\n * // Add a custom mapping\n * entities('© Maizzle', { '©': '&copy;' })\n *\n * // Disable the transform\n * entities('hello world', false)\n */\nexport function entities(html: string, custom: EntitiesConfig = true): string {\n  return serialize(entitiesDom(parse(html), custom))\n}\n\n/**\n * DOM-form of {@link entities} used by the internal transformer pipeline.\n * Takes a parsed DOM, returns a parsed DOM — avoids redundant\n * serialize/parse round-trips when chained with other transformers.\n */\nexport function entitiesDom(dom: ChildNode[], custom: EntitiesConfig = true): ChildNode[] {\n  if (!custom) return dom\n\n  const map = typeof custom === 'object'\n    ? merge(custom as Record<string, string>, DEFAULT_ENTITIES)\n    : DEFAULT_ENTITIES\n\n  walk(dom, (node) => {\n    if (node.type === 'text') {\n      for (const [char, entity] of Object.entries(map)) {\n        node.data = node.data.split(char).join(entity)\n      }\n    }\n  })\n\n  return dom\n}\n"],"mappings":";;;;;;AAKA,MAAM,mBAA2C;CAC/C,KAAU;CACV,KAAU;CACV,QAAU;CACV,KAAU;CACV,KAAU;CACV,KAAU;CACV,KAAU;CACV,KAAU;CACV,UAAU;CACV,UAAU;CACV,KAAU;CACV,KAAU;CACV,KAAU;CACV,KAAU;CACV,KAAU;CACV,KAAU;CACV,KAAU;CACV,KAAU;CACV,KAAU;CACV,KAAU;CACV,KAAU;CACV,KAAU;CACX;;;;;;;;;;;;;;;;;;;;;;;;AAyBD,SAAgB,SAAS,MAAc,SAAyB,MAAc;CAC5E,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,OAAO,CAAC;;;;;;;AAQpD,SAAgB,YAAY,KAAkB,SAAyB,MAAmB;CACxF,IAAI,CAAC,QAAQ,OAAO;CAEpB,MAAM,MAAM,OAAO,WAAW,WAC1BA,OAAM,QAAkC,iBAAiB,GACzD;CAEJ,KAAK,MAAM,SAAS;EAClB,IAAI,KAAK,SAAS,QAChB,KAAK,MAAM,CAAC,MAAM,WAAW,OAAO,QAAQ,IAAI,EAC9C,KAAK,OAAO,KAAK,KAAK,MAAM,KAAK,CAAC,KAAK,OAAO;GAGlD;CAEF,OAAO"}

package/dist/transformers/filters/{defaults.mjs → defaults.js}

@@ -72,7 +72,7 @@ const defaults = {
 	"url-decode": (str) => decodeURIComponent(str.replace(/\+/g, " ")),
 	"url-encode": (str) => encodeURIComponent(str)
 };
-
 //#endregion
 export { defaults };
-//# sourceMappingURL=defaults.mjs.map
+
+//# sourceMappingURL=defaults.js.map

package/dist/transformers/filters/defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.js","names":[],"sources":["../../../src/transformers/filters/defaults.ts"],"sourcesContent":["export type FilterFunction = (str: string, value: string) => string\n\nconst escapeMap: Record<string, string> = {\n  '\"': '&#34;',\n  '&': '&amp;',\n  \"'\": '&#39;',\n  '<': '&lt;',\n  '>': '&gt;',\n}\n\nconst escapeRegex = /[\"&'<>]/g\n\nfunction escapeHtml(str: string): string {\n  return str.replace(escapeRegex, ch => escapeMap[ch])\n}\n\nexport const defaults: Record<string, FilterFunction> = {\n  append: (str, value) => str + value,\n  prepend: (str, value) => value + str,\n  uppercase: str => str.toUpperCase(),\n  lowercase: str => str.toLowerCase(),\n  capitalize: str => str.charAt(0).toUpperCase() + str.slice(1),\n  ceil: str => String(Math.ceil(Number.parseFloat(str))),\n  floor: str => String(Math.floor(Number.parseFloat(str))),\n  round: str => String(Math.round(Number.parseFloat(str))),\n  escape: str => escapeHtml(str),\n  'escape-once': str => {\n    const decoded = str\n      .replace(/&amp;/g, '&')\n      .replace(/&lt;/g, '<')\n      .replace(/&gt;/g, '>')\n      .replace(/&#34;/g, '\"')\n      .replace(/&quot;/g, '\"')\n      .replace(/&#39;/g, \"'\")\n      .replace(/&apos;/g, \"'\")\n\n    return escapeHtml(decoded)\n  },\n  lstrip: str => str.trimStart(),\n  rstrip: str => str.trimEnd(),\n  trim: str => str.trim(),\n  minus: (str, value) => String(Number.parseFloat(str) - Number.parseFloat(value)),\n  plus: (str, value) => String(Number.parseFloat(str) + Number.parseFloat(value)),\n  multiply: (str, value) => String(Number.parseFloat(str) * Number.parseFloat(value)),\n  times: (str, value) => String(Number.parseFloat(str) * Number.parseFloat(value)),\n  'divide-by': (str, value) => String(Number.parseFloat(str) / Number.parseFloat(value)),\n  divide: (str, value) => String(Number.parseFloat(str) / Number.parseFloat(value)),\n  modulo: (str, value) => String(Number.parseFloat(str) % Number.parseFloat(value)),\n  'newline-to-br': str => str.replace(/\\n/g, '<br>'),\n  'strip-newlines': str => str.replace(/\\n/g, ''),\n  remove: (str, value) => str.split(value).join(''),\n  'remove-first': (str, value) => {\n    const i = str.indexOf(value)\n    return i === -1 ? str : str.slice(0, i) + str.slice(i + value.length)\n  },\n  replace: (str, value) => {\n    const [search = '', replacement = ''] = value.split('|')\n    return str.split(search).join(replacement)\n  },\n  'replace-first': (str, value) => {\n    const [search = '', replacement = ''] = value.split('|')\n    const i = str.indexOf(search)\n    return i === -1 ? str : str.slice(0, i) + replacement + str.slice(i + search.length)\n  },\n  size: str => String(str.length),\n  slice: (str, value) => {\n    const args = value.split(',').map(s => Number.parseInt(s.trim(), 10))\n    return str.slice(args[0], args[1])\n  },\n  truncate: (str, value) => {\n    const commaIndex = value.indexOf(',')\n    const length = Number.parseInt(commaIndex === -1 ? value : value.slice(0, commaIndex), 10)\n    const ellipsis = commaIndex === -1 ? '...' : value.slice(commaIndex + 1)\n\n    if (str.length <= length) return str\n\n    return str.slice(0, length) + ellipsis\n  },\n  'truncate-words': (str, value) => {\n    const commaIndex = value.indexOf(',')\n    const count = Number.parseInt(commaIndex === -1 ? value : value.slice(0, commaIndex), 10)\n    const ellipsis = commaIndex === -1 ? '...' : value.slice(commaIndex + 1)\n    const words = str.split(/\\s+/).filter(Boolean)\n\n    if (words.length <= count) return str\n\n    return words.slice(0, count).join(' ') + ellipsis\n  },\n  'url-decode': str => decodeURIComponent(str.replace(/\\+/g, ' ')),\n  'url-encode': str => encodeURIComponent(str),\n}\n"],"mappings":"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"}

package/dist/transformers/filters/index.d.ts

@@ -4,19 +4,40 @@ import { ChildNode } from "domhandler";
 //#region src/transformers/filters/index.d.ts
 type FiltersConfig = false | Record<string, (str: string, value: string) => string>;
 /**
- * Filters transformer.
+ * Apply transformation functions to the content of elements that have
+ * matching filter attributes. Multiple filters on the same element are
+ * executed in the order the attributes are defined.
  *
- * Applies transformation functions to the content of elements that
- * have matching filter attributes. Multiple filters on the same element
- * are executed in the order the attributes are defined.
+ * Default filters include string manipulation (`uppercase`, `lowercase`,
+ * `trim`, etc.), math operations (`plus`, `minus`, `multiply`, etc.),
+ * and more.
  *
- * Default filters include string manipulation (uppercase, lowercase, trim, etc.),
- * math operations (plus, minus, multiply, etc.), and more.
+ * @param html    HTML string to transform.
+ * @param custom  Custom filters to merge with the defaults. Pass `false`
+ *                to disable all filters (including the defaults).
+ * @returns       The transformed HTML string.
  *
- * Custom filters can be added via config, and will be merged with defaults.
- * Set config to `false` to disable all filters.
+ * @example
+ * import { filters } from '@maizzle/framework'
+ *
+ * // Defaults only
+ * const out = filters('<p uppercase>foo</p>') // → '<p>FOO</p>'
+ *
+ * // Add a custom filter
+ * filters('<p suffix=" world">hello</p>', {
+ *   suffix: (s, v) => s + v,
+ * })
+ *
+ * // Disable all filters
+ * filters('<p uppercase>foo</p>', false)
+ */
+declare function filters(html: string, custom?: FiltersConfig): string;
+/**
+ * DOM-form of {@link filters} 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 filters(dom: ChildNode[], config?: FiltersConfig): ChildNode[];
+declare function filtersDom(dom: ChildNode[], custom?: FiltersConfig): ChildNode[];
 //#endregion
-export { type FilterFunction, FiltersConfig, filters };
+export { type FilterFunction, FiltersConfig, filters, filtersDom };
 //# sourceMappingURL=index.d.ts.map

package/dist/transformers/filters/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/transformers/filters/index.ts"],"mappings":";;;;KAMY,aAAA,WAAwB,MAAA,UAAgB,GAAA,UAAa,KAAA;;AAAjE;;;;;;;;;AA4BA;;;iBAAgB,OAAA,CAAQ,GAAA,EAAK,SAAA,IAAa,MAAA,GAAQ,aAAA,GAAqB,SAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/transformers/filters/index.ts"],"mappings":";;;;KAMY,aAAA,WAAwB,MAAA,UAAgB,GAAA,UAAa,KAAA;;AAAjE;;;;;;;;;AA2CA;;;;;;;;;AASA;;;;;;;;;iBATgB,OAAA,CAAQ,IAAA,UAAc,MAAA,GAAQ,aAAA;;;;;;iBAS9B,UAAA,CAAW,GAAA,EAAK,SAAA,IAAa,MAAA,GAAQ,aAAA,GAAqB,SAAA"}

package/dist/transformers/filters/index.js

@@ -0,0 +1,89 @@
+import { parse } from "../../utils/ast/parser.js";
+import { serialize } from "../../utils/ast/serializer.js";
+import "../../utils/ast/index.js";
+import { defaults } from "./defaults.js";
+import { Text } from "domhandler";
+//#region src/transformers/filters/index.ts
+/**
+* Process children before parents so nested filter elements work correctly.
+*/
+function walkBottomUp(nodes, callback) {
+	for (const node of nodes.slice()) {
+		if ("children" in node && node.children?.length) walkBottomUp(node.children, callback);
+		callback(node);
+	}
+}
+/**
+* Apply transformation functions to the content of elements that have
+* matching filter attributes. Multiple filters on the same element are
+* executed in the order the attributes are defined.
+*
+* Default filters include string manipulation (`uppercase`, `lowercase`,
+* `trim`, etc.), math operations (`plus`, `minus`, `multiply`, etc.),
+* and more.
+*
+* @param html    HTML string to transform.
+* @param custom  Custom filters to merge with the defaults. Pass `false`
+*                to disable all filters (including the defaults).
+* @returns       The transformed HTML string.
+*
+* @example
+* import { filters } from '@maizzle/framework'
+*
+* // Defaults only
+* const out = filters('<p uppercase>foo</p>') // → '<p>FOO</p>'
+*
+* // Add a custom filter
+* filters('<p suffix=" world">hello</p>', {
+*   suffix: (s, v) => s + v,
+* })
+*
+* // Disable all filters
+* filters('<p uppercase>foo</p>', false)
+*/
+function filters(html, custom = {}) {
+	return serialize(filtersDom(parse(html), custom));
+}
+/**
+* DOM-form of {@link filters} 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 filtersDom(dom, custom = {}) {
+	if (custom === false) return dom;
+	const allFilters = {
+		...defaults,
+		...custom
+	};
+	const filterNames = new Set(Object.keys(allFilters));
+	walkBottomUp(dom, (node) => {
+		const el = node;
+		if (!el.attribs) return;
+		const matched = [];
+		for (const attr of Object.keys(el.attribs)) if (filterNames.has(attr)) matched.push({
+			name: attr,
+			value: el.attribs[attr]
+		});
+		if (matched.length === 0) return;
+		let content = serialize(el.children);
+		for (const { name, value } of matched) {
+			content = allFilters[name](content, value);
+			delete el.attribs[name];
+		}
+		if (content === "") el.children = [];
+		else if (/<[a-z/!]/i.test(content)) {
+			const newChildren = parse(content);
+			for (const child of newChildren) child.parent = el;
+			el.children = newChildren;
+		} else {
+			const textNode = new Text(content);
+			textNode.parent = el;
+			el.children = [textNode];
+		}
+	});
+	return dom;
+}
+//#endregion
+export { filters, filtersDom };
+
+//# sourceMappingURL=index.js.map

package/dist/transformers/filters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/transformers/filters/index.ts"],"sourcesContent":["import { Text } from 'domhandler'\nimport type { ChildNode, Element } from 'domhandler'\nimport { parse, serialize } from '../../utils/ast/index.ts'\nimport { defaults } from './defaults.ts'\n\nexport type { FilterFunction } from './defaults.ts'\nexport type FiltersConfig = false | Record<string, (str: string, value: string) => string>\n\n/**\n * Process children before parents so nested filter elements work correctly.\n */\nfunction walkBottomUp(nodes: ChildNode[], callback: (node: ChildNode) => void): void {\n  for (const node of nodes.slice()) {\n    if ('children' in node && node.children?.length) {\n      walkBottomUp(node.children as ChildNode[], callback)\n    }\n\n    callback(node)\n  }\n}\n\n/**\n * Apply transformation functions to the content of elements that have\n * matching filter attributes. Multiple filters on the same element are\n * executed in the order the attributes are defined.\n *\n * Default filters include string manipulation (`uppercase`, `lowercase`,\n * `trim`, etc.), math operations (`plus`, `minus`, `multiply`, etc.),\n * and more.\n *\n * @param html    HTML string to transform.\n * @param custom  Custom filters to merge with the defaults. Pass `false`\n *                to disable all filters (including the defaults).\n * @returns       The transformed HTML string.\n *\n * @example\n * import { filters } from '@maizzle/framework'\n *\n * // Defaults only\n * const out = filters('<p uppercase>foo</p>') // → '<p>FOO</p>'\n *\n * // Add a custom filter\n * filters('<p suffix=\" world\">hello</p>', {\n *   suffix: (s, v) => s + v,\n * })\n *\n * // Disable all filters\n * filters('<p uppercase>foo</p>', false)\n */\nexport function filters(html: string, custom: FiltersConfig = {}): string {\n  return serialize(filtersDom(parse(html), custom))\n}\n\n/**\n * DOM-form of {@link filters} used by the internal transformer pipeline.\n * Takes a parsed DOM, returns a parsed DOM — avoids redundant\n * serialize/parse round-trips when chained with other transformers.\n */\nexport function filtersDom(dom: ChildNode[], custom: FiltersConfig = {}): ChildNode[] {\n  if (custom === false) return dom\n\n  const allFilters = { ...defaults, ...custom }\n  const filterNames = new Set(Object.keys(allFilters))\n\n  walkBottomUp(dom, (node) => {\n    const el = node as Element\n\n    if (!el.attribs) return\n\n    // Collect matching filter attributes in source order\n    const matched: Array<{ name: string; value: string }> = []\n\n    for (const attr of Object.keys(el.attribs)) {\n      if (filterNames.has(attr)) {\n        matched.push({ name: attr, value: el.attribs[attr] })\n      }\n    }\n\n    if (matched.length === 0) return\n\n    // Serialize children to get innerHTML\n    let content = serialize(el.children as ChildNode[])\n\n    // Apply each filter in attribute order\n    for (const { name, value } of matched) {\n      content = allFilters[name](content, value)\n      delete el.attribs[name]\n    }\n\n    // Replace children with the filtered content\n    if (content === '') {\n      el.children = []\n    } else if (/<[a-z/!]/i.test(content)) {\n      // Result contains HTML elements — parse back to DOM\n      const newChildren = parse(content)\n\n      for (const child of newChildren) {\n        child.parent = el as any\n      }\n\n      el.children = newChildren as ChildNode[]\n    } else {\n      // Text-only result — create a text node directly to preserve entity strings\n      const textNode = new Text(content)\n      textNode.parent = el as any\n      el.children = [textNode]\n    }\n  })\n\n  return dom\n}\n"],"mappings":";;;;;;;;;AAWA,SAAS,aAAa,OAAoB,UAA2C;CACnF,KAAK,MAAM,QAAQ,MAAM,OAAO,EAAE;EAChC,IAAI,cAAc,QAAQ,KAAK,UAAU,QACvC,aAAa,KAAK,UAAyB,SAAS;EAGtD,SAAS,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgClB,SAAgB,QAAQ,MAAc,SAAwB,EAAE,EAAU;CACxE,OAAO,UAAU,WAAW,MAAM,KAAK,EAAE,OAAO,CAAC;;;;;;;AAQnD,SAAgB,WAAW,KAAkB,SAAwB,EAAE,EAAe;CACpF,IAAI,WAAW,OAAO,OAAO;CAE7B,MAAM,aAAa;EAAE,GAAG;EAAU,GAAG;EAAQ;CAC7C,MAAM,cAAc,IAAI,IAAI,OAAO,KAAK,WAAW,CAAC;CAEpD,aAAa,MAAM,SAAS;EAC1B,MAAM,KAAK;EAEX,IAAI,CAAC,GAAG,SAAS;EAGjB,MAAM,UAAkD,EAAE;EAE1D,KAAK,MAAM,QAAQ,OAAO,KAAK,GAAG,QAAQ,EACxC,IAAI,YAAY,IAAI,KAAK,EACvB,QAAQ,KAAK;GAAE,MAAM;GAAM,OAAO,GAAG,QAAQ;GAAO,CAAC;EAIzD,IAAI,QAAQ,WAAW,GAAG;EAG1B,IAAI,UAAU,UAAU,GAAG,SAAwB;EAGnD,KAAK,MAAM,EAAE,MAAM,WAAW,SAAS;GACrC,UAAU,WAAW,MAAM,SAAS,MAAM;GAC1C,OAAO,GAAG,QAAQ;;EAIpB,IAAI,YAAY,IACd,GAAG,WAAW,EAAE;OACX,IAAI,YAAY,KAAK,QAAQ,EAAE;GAEpC,MAAM,cAAc,MAAM,QAAQ;GAElC,KAAK,MAAM,SAAS,aAClB,MAAM,SAAS;GAGjB,GAAG,WAAW;SACT;GAEL,MAAM,WAAW,IAAI,KAAK,QAAQ;GAClC,SAAS,SAAS;GAClB,GAAG,WAAW,CAAC,SAAS;;GAE1B;CAEF,OAAO"}

package/dist/transformers/format.d.ts

@@ -1,15 +1,22 @@
-import { MaizzleConfig } from "../types/config.js";
+import { FormatOptions, FormatOptions as FormatOptions$1 } from "oxfmt";
 
 //#region src/transformers/format.d.ts
 /**
- * Format transformer.
+ * Pretty-print an HTML string with `oxfmt`. Maizzle defaults
+ * (`printWidth: 320`, `htmlWhitespaceSensitivity: 'ignore'`,
+ * `embeddedLanguageFormatting: 'off'`) are merged underneath any options
+ * you pass.
  *
- * Formats the HTML string using `oxfmt`. Accepts all oxfmt `FormatOptions`.
+ * @param html    HTML string to format.
+ * @param options [oxfmt `FormatOptions`](https://github.com/oxc-project/oxfmt).
+ * @returns       The formatted HTML string.
  *
- * Enable by setting `html.format: true` (or passing options).
- * User options are merged on top of the defaults.
+ * @example
+ * import { format } from '@maizzle/framework'
+ *
+ * const pretty = await format(html, { useTabs: true, tabWidth: 4 })
  */
-declare function format(html: string, config?: MaizzleConfig): Promise<string>;
+declare function format(html: string, options?: FormatOptions$1): Promise<string>;
 //#endregion
-export { format };
+export { type FormatOptions, format };
 //# sourceMappingURL=format.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"format.d.ts","names":[],"sources":["../../src/transformers/format.ts"],"mappings":";;;;;AAmBA;;;;;;iBAAsB,MAAA,CAAO,IAAA,UAAc,MAAA,GAAQ,aAAA,GAAqB,OAAA"}
+{"version":3,"file":"format.d.ts","names":[],"sources":["../../src/transformers/format.ts"],"mappings":";;;;AA2BA;;;;;;;;;;;;;;iBAAsB,MAAA,CAAO,IAAA,UAAc,OAAA,GAAS,eAAA,GAAqB,OAAA"}

package/dist/transformers/format.js

@@ -0,0 +1,30 @@
+import { defu as defu$1 } from "defu";
+import { format as format$1 } from "oxfmt";
+//#region src/transformers/format.ts
+const DEFAULT_OPTIONS = {
+	printWidth: 320,
+	htmlWhitespaceSensitivity: "ignore",
+	embeddedLanguageFormatting: "off"
+};
+/**
+* Pretty-print an HTML string with `oxfmt`. Maizzle defaults
+* (`printWidth: 320`, `htmlWhitespaceSensitivity: 'ignore'`,
+* `embeddedLanguageFormatting: 'off'`) are merged underneath any options
+* you pass.
+*
+* @param html    HTML string to format.
+* @param options [oxfmt `FormatOptions`](https://github.com/oxc-project/oxfmt).
+* @returns       The formatted HTML string.
+*
+* @example
+* import { format } from '@maizzle/framework'
+*
+* const pretty = await format(html, { useTabs: true, tabWidth: 4 })
+*/
+async function format(html, options = {}) {
+	return (await format$1("input.html", html, defu$1(options, DEFAULT_OPTIONS))).code;
+}
+//#endregion
+export { format };
+
+//# sourceMappingURL=format.js.map

package/dist/transformers/format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.js","names":["oxfmt","merge"],"sources":["../../src/transformers/format.ts"],"sourcesContent":["import { format as oxfmt } from 'oxfmt'\nimport { defu as merge } from 'defu'\nimport type { FormatOptions } from 'oxfmt'\n\nexport type { FormatOptions } from 'oxfmt'\n\nconst DEFAULT_OPTIONS: FormatOptions = {\n  printWidth: 320,\n  htmlWhitespaceSensitivity: 'ignore',\n  embeddedLanguageFormatting: 'off',\n}\n\n/**\n * Pretty-print an HTML string with `oxfmt`. Maizzle defaults\n * (`printWidth: 320`, `htmlWhitespaceSensitivity: 'ignore'`,\n * `embeddedLanguageFormatting: 'off'`) are merged underneath any options\n * you pass.\n *\n * @param html    HTML string to format.\n * @param options [oxfmt `FormatOptions`](https://github.com/oxc-project/oxfmt).\n * @returns       The formatted HTML string.\n *\n * @example\n * import { format } from '@maizzle/framework'\n *\n * const pretty = await format(html, { useTabs: true, tabWidth: 4 })\n */\nexport async function format(html: string, options: FormatOptions = {}): Promise<string> {\n  const merged = merge(options, DEFAULT_OPTIONS)\n  const result = await oxfmt('input.html', html, merged)\n  return result.code\n}\n"],"mappings":";;;AAMA,MAAM,kBAAiC;CACrC,YAAY;CACZ,2BAA2B;CAC3B,4BAA4B;CAC7B;;;;;;;;;;;;;;;;AAiBD,eAAsB,OAAO,MAAc,UAAyB,EAAE,EAAmB;CAGvF,QAAO,MADcA,SAAM,cAAc,MAD1BC,OAAM,SAAS,gBACuB,CAAC,EACxC"}

package/dist/transformers/index.js

@@ -0,0 +1,133 @@
+import { parse } from "../utils/ast/parser.js";
+import { serialize } from "../utils/ast/serializer.js";
+import "../utils/ast/index.js";
+import { inlineLinkDom } from "./inlineLink.js";
+import { tailwindComponent } from "./tailwindComponent.js";
+import { tailwindcss } from "./tailwindcss.js";
+import { safeClassNames } from "./safeClassNames.js";
+import { attributeToStyleDom } from "./attributeToStyle.js";
+import { inlineCssDom } from "./inlineCss.js";
+import { msoPlaceholders } from "./msoPlaceholders.js";
+import { columnWidth } from "./columnWidth.js";
+import { removeAttributesDom } from "./removeAttributes.js";
+import { shorthandCssDom } from "./shorthandCss.js";
+import { sixHexDom } from "./sixHex.js";
+import { addAttributes } from "./addAttributes.js";
+import { filtersDom } from "./filters/index.js";
+import { baseDom } from "./base.js";
+import { entitiesDom } from "./entities.js";
+import { urlQueryDom } from "./urlQuery.js";
+import { purgeCssDom } from "./purgeCss.js";
+import { replaceStrings } from "./replaceStrings.js";
+import { format } from "./format.js";
+import { minify } from "./minify.js";
+//#region src/transformers/index.ts
+/**
+* Run all Maizzle transformers on the rendered HTML.
+*
+* The HTML is parsed into a DOM once at the start and passed through all
+* DOM-based transformers as a shared `ChildNode[]`. After all DOM transformers
+* complete, the DOM is serialized back to a string exactly once.
+*
+* String-only transformers (those that rely on external tools that require a
+* raw HTML string) then run on the serialized output.
+*
+* Transformers run in a specific order:
+* 0.  Inline link stylesheets — replace `<link rel="stylesheet">` with `<style>` tags
+* 1.  Tailwind CSS — compile CSS, lower syntax, optimize (cleanup + merge media queries)
+* 2.  Safe class names
+* 3.  Attribute to style
+* 4.  CSS inliner
+* 5.  Remove attributes
+* 6.  Shorthand CSS
+* 7.  Six-digit HEX
+* 8.  Add attributes
+* 9.  Filters
+* 10. Base URL
+* 11. URL query
+* 12. Purge CSS (serializes/parses internally around email-comb)
+* 13. Entities
+* + Vue-generated comments stripped here (on serialized string)
+* 14. Replace strings
+* 15. Prettify
+* 16. Minify
+*/
+async function runTransformers(html, config, filePath, doctype, tailwindBlocks) {
+	const toggles = typeof config.useTransformers === "object" ? config.useTransformers : null;
+	const enabled = (key) => toggles?.[key] !== false;
+	let effective = config;
+	if (toggles) {
+		const cssOver = {};
+		const htmlOver = {};
+		if (toggles.inlineCss === true) cssOver.inline = true;
+		if (toggles.purgeCss === true) cssOver.purge = true;
+		if (toggles.safeClassNames === true) cssOver.safe = true;
+		if (toggles.shorthandCss === true) cssOver.shorthand = true;
+		if (toggles.sixHex === true) cssOver.sixHex = true;
+		if (toggles.prettify === true) htmlOver.format = true;
+		if (toggles.minify === true) htmlOver.minify = true;
+		if (toggles.entities === true) htmlOver.decodeEntities = true;
+		if (Object.keys(cssOver).length || Object.keys(htmlOver).length) effective = {
+			...config,
+			css: {
+				...config.css,
+				...cssOver
+			},
+			html: {
+				...config.html,
+				...htmlOver
+			}
+		};
+	}
+	let dom = parse(html);
+	dom = await inlineLinkDom(dom, filePath);
+	if (tailwindBlocks?.length) dom = await tailwindComponent(dom, tailwindBlocks, effective, filePath);
+	dom = await tailwindcss(dom, effective, filePath);
+	if (enabled("safeClassNames")) dom = safeClassNames(dom, effective.css);
+	if (enabled("attributeToStyle") && typeof effective.css?.inline === "object" && effective.css.inline.attributeToStyle) dom = attributeToStyleDom(dom, effective.css.inline.attributeToStyle);
+	if (enabled("inlineCss") && effective.css?.inline) {
+		const inlineOptions = typeof effective.css.inline === "object" ? effective.css.inline : {};
+		dom = inlineCssDom(dom, inlineOptions);
+	}
+	dom = msoPlaceholders(dom);
+	dom = columnWidth(dom);
+	if (enabled("removeAttributes")) {
+		const removeRules = effective.html?.attributes?.remove;
+		dom = removeAttributesDom(dom, Array.isArray(removeRules) ? removeRules : []);
+	}
+	if (enabled("shorthandCss") && effective.css?.shorthand) {
+		const shorthandOptions = typeof effective.css.shorthand === "object" ? effective.css.shorthand : {};
+		dom = shorthandCssDom(dom, shorthandOptions);
+	}
+	if (enabled("sixHex") && effective.css?.sixHex !== false) dom = sixHexDom(dom);
+	if (enabled("addAttributes")) dom = addAttributes(dom, effective.html?.attributes);
+	if (enabled("filters")) dom = filtersDom(dom, effective.filters);
+	if (enabled("baseURL") && effective.url?.base) dom = baseDom(dom, effective.url.base);
+	if (enabled("urlQuery") && effective.url?.query && Object.keys(effective.url.query).length > 0) {
+		const { _options: queryOptions, ...queryParams } = effective.url.query;
+		dom = urlQueryDom(dom, queryParams, queryOptions ?? {});
+	}
+	if (enabled("purgeCss") && effective.css?.purge) {
+		const purgeOptions = typeof effective.css.purge === "object" ? effective.css.purge : {};
+		dom = purgeCssDom(dom, purgeOptions);
+	}
+	if (enabled("entities")) dom = entitiesDom(dom, effective.html?.decodeEntities);
+	const isXhtml = doctype ? /xhtml/i.test(doctype) : false;
+	let result = serialize(dom, { selfClosingTags: isXhtml });
+	if (enabled("replaceStrings")) result = replaceStrings(result, effective);
+	const minifyWillRun = enabled("minify") && !!effective.html?.minify;
+	if (enabled("prettify") && !minifyWillRun && effective.html?.format) {
+		const formatOptions = typeof effective.html.format === "object" ? effective.html.format : {};
+		result = await format(result, formatOptions);
+	}
+	if (enabled("minify") && effective.html?.minify) {
+		const minifyOptions = typeof effective.html.minify === "object" ? effective.html.minify : {};
+		result = minify(result, minifyOptions);
+	}
+	if (!isXhtml) result = result.replace(/<!--\[if [^\]]*\]>[\s\S]*?<!\[endif\]-->|( \/>)/g, (match, selfClose) => selfClose ? ">" : match);
+	return result;
+}
+//#endregion
+export { runTransformers };
+
+//# sourceMappingURL=index.js.map

package/dist/transformers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/transformers/index.ts"],"sourcesContent":["import { parse, serialize } from '../utils/ast/index.ts'\nimport { inlineLinkDom } from './inlineLink.ts'\nimport { tailwindComponent } from './tailwindComponent.ts'\nimport { tailwindcss } from './tailwindcss.ts'\nimport { safeClassNames } from './safeClassNames.ts'\nimport { attributeToStyleDom } from './attributeToStyle.ts'\nimport { inlineCssDom } from './inlineCss.ts'\nimport { msoPlaceholders } from './msoPlaceholders.ts'\nimport { columnWidth } from './columnWidth.ts'\nimport { removeAttributesDom } from './removeAttributes.ts'\nimport { shorthandCssDom } from './shorthandCss.ts'\nimport { sixHexDom } from './sixHex.ts'\nimport { addAttributes } from './addAttributes.ts'\nimport { filtersDom } from './filters/index.ts'\nimport { baseDom } from './base.ts'\nimport { entitiesDom } from './entities.ts'\nimport { urlQueryDom } from './urlQuery.ts'\nimport { purgeCssDom } from './purgeCss.ts'\nimport { replaceStrings } from './replaceStrings.ts'\nimport { format } from './format.ts'\nimport { minify } from './minify.ts'\nimport type { MaizzleConfig } from '../types/config.ts'\nimport type { TailwindBlock } from '../composables/renderContext.ts'\n\n/**\n * Run all Maizzle transformers on the rendered HTML.\n *\n * The HTML is parsed into a DOM once at the start and passed through all\n * DOM-based transformers as a shared `ChildNode[]`. After all DOM transformers\n * complete, the DOM is serialized back to a string exactly once.\n *\n * String-only transformers (those that rely on external tools that require a\n * raw HTML string) then run on the serialized output.\n *\n * Transformers run in a specific order:\n * 0.  Inline link stylesheets — replace `<link rel=\"stylesheet\">` with `<style>` tags\n * 1.  Tailwind CSS — compile CSS, lower syntax, optimize (cleanup + merge media queries)\n * 2.  Safe class names\n * 3.  Attribute to style\n * 4.  CSS inliner\n * 5.  Remove attributes\n * 6.  Shorthand CSS\n * 7.  Six-digit HEX\n * 8.  Add attributes\n * 9.  Filters\n * 10. Base URL\n * 11. URL query\n * 12. Purge CSS (serializes/parses internally around email-comb)\n * 13. Entities\n * + Vue-generated comments stripped here (on serialized string)\n * 14. Replace strings\n * 15. Prettify\n * 16. Minify\n */\nexport async function runTransformers(\n  html: string,\n  config: MaizzleConfig,\n  filePath?: string,\n  doctype?: string,\n  tailwindBlocks?: TailwindBlock[],\n): Promise<string> {\n  // Per-transformer skip map — only honored when useTransformers is an object.\n  // Whole-pipeline opt-out (`useTransformers === false`) is handled upstream\n  // in build.ts / render so we never reach this function in that case.\n  //\n  // A toggle set to `true` *force-enables* its transformer for this run by\n  // layering on the matching config slice (e.g. `prettify: true` sets\n  // `html.format = true`). This only applies to transformers whose\n  // enable flag is a plain boolean — data-driven ones (filters,\n  // baseURL, urlQuery, etc.) need actual config values, so a\n  // bare `true` for those is a no-op.\n  const toggles = typeof config.useTransformers === 'object' ? config.useTransformers : null\n  const enabled = (key: keyof NonNullable<typeof toggles>) => toggles?.[key] !== false\n\n  let effective = config\n  if (toggles) {\n    const cssOver: Record<string, unknown> = {}\n    const htmlOver: Record<string, unknown> = {}\n    if (toggles.inlineCss === true) cssOver.inline = true\n    if (toggles.purgeCss === true) cssOver.purge = true\n    if (toggles.safeClassNames === true) cssOver.safe = true\n    if (toggles.shorthandCss === true) cssOver.shorthand = true\n    if (toggles.sixHex === true) cssOver.sixHex = true\n    if (toggles.prettify === true) htmlOver.format = true\n    if (toggles.minify === true) htmlOver.minify = true\n    if (toggles.entities === true) htmlOver.decodeEntities = true\n\n    if (Object.keys(cssOver).length || Object.keys(htmlOver).length) {\n      effective = {\n        ...config,\n        css: { ...config.css, ...cssOver },\n        html: { ...config.html, ...htmlOver },\n      }\n    }\n  }\n\n  // Parse once — all DOM transformers share this array\n  let dom = parse(html)\n\n  // 0. Inline <link> stylesheets\n  dom = await inlineLinkDom(dom, filePath)\n\n  // 0.5. <Tailwind> component — compile per-block scoped CSS, inject into <head>\n  if (tailwindBlocks?.length) {\n    dom = await tailwindComponent(dom, tailwindBlocks, effective, filePath)\n  }\n\n  // 1. Tailwind CSS — always runs first\n  dom = await tailwindcss(dom, effective, filePath)\n\n  // 2. Safe class names\n  if (enabled('safeClassNames')) dom = safeClassNames(dom, effective.css)\n\n  // 3. Attribute to style\n  if (enabled('attributeToStyle') && typeof effective.css?.inline === 'object' && effective.css.inline.attributeToStyle) {\n    dom = attributeToStyleDom(dom, effective.css.inline.attributeToStyle)\n  }\n\n  // 4. CSS inliner (serializes/parses internally around juice)\n  if (enabled('inlineCss') && effective.css?.inline) {\n    const inlineOptions = typeof effective.css.inline === 'object' ? effective.css.inline : {}\n    dom = inlineCssDom(dom, inlineOptions)\n  }\n\n  // 4.5. Resolve MSO placeholders (table width + td style) from inlined CSS\n  dom = msoPlaceholders(dom)\n\n  // 4.6. Resolve Column min-width placeholders from nearest sized ancestor\n  dom = columnWidth(dom)\n\n  // 5. Remove attributes\n  if (enabled('removeAttributes')) {\n    const removeRules = effective.html?.attributes?.remove\n    dom = removeAttributesDom(dom, Array.isArray(removeRules) ? removeRules : [])\n  }\n\n  // 6. Shorthand CSS\n  if (enabled('shorthandCss') && effective.css?.shorthand) {\n    const shorthandOptions = typeof effective.css.shorthand === 'object' ? effective.css.shorthand : {}\n    dom = shorthandCssDom(dom, shorthandOptions)\n  }\n\n  // 7. Six-digit HEX\n  if (enabled('sixHex') && effective.css?.sixHex !== false) dom = sixHexDom(dom)\n\n  // 8. Add attributes\n  if (enabled('addAttributes')) dom = addAttributes(dom, effective.html?.attributes)\n\n  // 9. Filters\n  if (enabled('filters')) dom = filtersDom(dom, effective.filters)\n\n  // 10. Base URL (serializes/parses internally for VML/MSO regex passes)\n  if (enabled('baseURL') && effective.url?.base) dom = baseDom(dom, effective.url.base)\n\n  // 11. URL query\n  if (enabled('urlQuery') && effective.url?.query && Object.keys(effective.url.query).length > 0) {\n    const { _options: queryOptions, ...queryParams } = effective.url.query as Record<string, unknown>\n    dom = urlQueryDom(dom, queryParams, (queryOptions ?? {}) as import('../types/config.ts').UrlQueryOptions)\n  }\n\n  // 12. Remove unused CSS (serializes/parses internally around email-comb)\n  if (enabled('purgeCss') && effective.css?.purge) {\n    const purgeOptions = typeof effective.css.purge === 'object' ? effective.css.purge : {}\n    dom = purgeCssDom(dom, purgeOptions)\n  }\n\n  // 13. Entities\n  if (enabled('entities')) dom = entitiesDom(dom, effective.html?.decodeEntities)\n\n  // Serialize once — remaining transformers operate on the HTML string\n  const isXhtml = doctype ? /xhtml/i.test(doctype) : false\n  let result = serialize(dom, { selfClosingTags: isXhtml })\n\n  // 14. Replace strings\n  if (enabled('replaceStrings')) result = replaceStrings(result, effective)\n\n  // 15. Format — skipped when `minify` is enabled\n  const minifyWillRun = enabled('minify') && !!effective.html?.minify\n  if (enabled('prettify') && !minifyWillRun && effective.html?.format) {\n    const formatOptions = typeof effective.html.format === 'object' ? effective.html.format : {}\n    result = await format(result, formatOptions)\n  }\n\n  // 16. Minify\n  if (enabled('minify') && effective.html?.minify) {\n    const minifyOptions = typeof effective.html.minify === 'object' ? effective.html.minify : {}\n    result = minify(result, minifyOptions)\n  }\n\n  // Strip self-closing slashes for HTML5 doctypes, but preserve content\n  // inside MSO conditional comments (which are XML-ish and case/syntax sensitive).\n  if (!isXhtml) {\n    result = result.replace(\n      /<!--\\[if [^\\]]*\\]>[\\s\\S]*?<!\\[endif\\]-->|( \\/>)/g,\n      (match, selfClose) => selfClose ? '>' : match,\n    )\n  }\n\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,eAAsB,gBACpB,MACA,QACA,UACA,SACA,gBACiB;CAWjB,MAAM,UAAU,OAAO,OAAO,oBAAoB,WAAW,OAAO,kBAAkB;CACtF,MAAM,WAAW,QAA2C,UAAU,SAAS;CAE/E,IAAI,YAAY;CAChB,IAAI,SAAS;EACX,MAAM,UAAmC,EAAE;EAC3C,MAAM,WAAoC,EAAE;EAC5C,IAAI,QAAQ,cAAc,MAAM,QAAQ,SAAS;EACjD,IAAI,QAAQ,aAAa,MAAM,QAAQ,QAAQ;EAC/C,IAAI,QAAQ,mBAAmB,MAAM,QAAQ,OAAO;EACpD,IAAI,QAAQ,iBAAiB,MAAM,QAAQ,YAAY;EACvD,IAAI,QAAQ,WAAW,MAAM,QAAQ,SAAS;EAC9C,IAAI,QAAQ,aAAa,MAAM,SAAS,SAAS;EACjD,IAAI,QAAQ,WAAW,MAAM,SAAS,SAAS;EAC/C,IAAI,QAAQ,aAAa,MAAM,SAAS,iBAAiB;EAEzD,IAAI,OAAO,KAAK,QAAQ,CAAC,UAAU,OAAO,KAAK,SAAS,CAAC,QACvD,YAAY;GACV,GAAG;GACH,KAAK;IAAE,GAAG,OAAO;IAAK,GAAG;IAAS;GAClC,MAAM;IAAE,GAAG,OAAO;IAAM,GAAG;IAAU;GACtC;;CAKL,IAAI,MAAM,MAAM,KAAK;CAGrB,MAAM,MAAM,cAAc,KAAK,SAAS;CAGxC,IAAI,gBAAgB,QAClB,MAAM,MAAM,kBAAkB,KAAK,gBAAgB,WAAW,SAAS;CAIzE,MAAM,MAAM,YAAY,KAAK,WAAW,SAAS;CAGjD,IAAI,QAAQ,iBAAiB,EAAE,MAAM,eAAe,KAAK,UAAU,IAAI;CAGvE,IAAI,QAAQ,mBAAmB,IAAI,OAAO,UAAU,KAAK,WAAW,YAAY,UAAU,IAAI,OAAO,kBACnG,MAAM,oBAAoB,KAAK,UAAU,IAAI,OAAO,iBAAiB;CAIvE,IAAI,QAAQ,YAAY,IAAI,UAAU,KAAK,QAAQ;EACjD,MAAM,gBAAgB,OAAO,UAAU,IAAI,WAAW,WAAW,UAAU,IAAI,SAAS,EAAE;EAC1F,MAAM,aAAa,KAAK,cAAc;;CAIxC,MAAM,gBAAgB,IAAI;CAG1B,MAAM,YAAY,IAAI;CAGtB,IAAI,QAAQ,mBAAmB,EAAE;EAC/B,MAAM,cAAc,UAAU,MAAM,YAAY;EAChD,MAAM,oBAAoB,KAAK,MAAM,QAAQ,YAAY,GAAG,cAAc,EAAE,CAAC;;CAI/E,IAAI,QAAQ,eAAe,IAAI,UAAU,KAAK,WAAW;EACvD,MAAM,mBAAmB,OAAO,UAAU,IAAI,cAAc,WAAW,UAAU,IAAI,YAAY,EAAE;EACnG,MAAM,gBAAgB,KAAK,iBAAiB;;CAI9C,IAAI,QAAQ,SAAS,IAAI,UAAU,KAAK,WAAW,OAAO,MAAM,UAAU,IAAI;CAG9E,IAAI,QAAQ,gBAAgB,EAAE,MAAM,cAAc,KAAK,UAAU,MAAM,WAAW;CAGlF,IAAI,QAAQ,UAAU,EAAE,MAAM,WAAW,KAAK,UAAU,QAAQ;CAGhE,IAAI,QAAQ,UAAU,IAAI,UAAU,KAAK,MAAM,MAAM,QAAQ,KAAK,UAAU,IAAI,KAAK;CAGrF,IAAI,QAAQ,WAAW,IAAI,UAAU,KAAK,SAAS,OAAO,KAAK,UAAU,IAAI,MAAM,CAAC,SAAS,GAAG;EAC9F,MAAM,EAAE,UAAU,cAAc,GAAG,gBAAgB,UAAU,IAAI;EACjE,MAAM,YAAY,KAAK,aAAc,gBAAgB,EAAE,CAAkD;;CAI3G,IAAI,QAAQ,WAAW,IAAI,UAAU,KAAK,OAAO;EAC/C,MAAM,eAAe,OAAO,UAAU,IAAI,UAAU,WAAW,UAAU,IAAI,QAAQ,EAAE;EACvF,MAAM,YAAY,KAAK,aAAa;;CAItC,IAAI,QAAQ,WAAW,EAAE,MAAM,YAAY,KAAK,UAAU,MAAM,eAAe;CAG/E,MAAM,UAAU,UAAU,SAAS,KAAK,QAAQ,GAAG;CACnD,IAAI,SAAS,UAAU,KAAK,EAAE,iBAAiB,SAAS,CAAC;CAGzD,IAAI,QAAQ,iBAAiB,EAAE,SAAS,eAAe,QAAQ,UAAU;CAGzE,MAAM,gBAAgB,QAAQ,SAAS,IAAI,CAAC,CAAC,UAAU,MAAM;CAC7D,IAAI,QAAQ,WAAW,IAAI,CAAC,iBAAiB,UAAU,MAAM,QAAQ;EACnE,MAAM,gBAAgB,OAAO,UAAU,KAAK,WAAW,WAAW,UAAU,KAAK,SAAS,EAAE;EAC5F,SAAS,MAAM,OAAO,QAAQ,cAAc;;CAI9C,IAAI,QAAQ,SAAS,IAAI,UAAU,MAAM,QAAQ;EAC/C,MAAM,gBAAgB,OAAO,UAAU,KAAK,WAAW,WAAW,UAAU,KAAK,SAAS,EAAE;EAC5F,SAAS,OAAO,QAAQ,cAAc;;CAKxC,IAAI,CAAC,SACH,SAAS,OAAO,QACd,qDACC,OAAO,cAAc,YAAY,MAAM,MACzC;CAGH,OAAO"}

package/dist/transformers/inlineCss.d.ts

@@ -0,0 +1,84 @@
+import { ChildNode } from "domhandler";
+import { Options } from "juice";
+
+//#region src/transformers/inlineCss.d.ts
+/**
+ * Options for the `inlineCss` transformer. Accepts every Juice option plus a
+ * handful of Maizzle-specific extras.
+ */
+interface InlineCssOptions extends Options {
+  /**
+   * Convert `0px`, `0em` etc. to `0` in inline styles.
+   *
+   * @default true
+   */
+  preferUnitlessValues?: boolean;
+  /**
+   * CSS selectors to preserve in `<style>` tags, even after inlining.
+   * Mapped to Juice's `preservedSelectors` option.
+   *
+   * @default []
+   */
+  safelist?: string[];
+  /**
+   * Additional CSS string to inline alongside `<style>` tag contents.
+   * Mapped to Juice's `extraCss` option.
+   */
+  customCSS?: string;
+  /**
+   * Duplicate CSS properties to HTML attributes.
+   * Mapped to Juice's static `styleToAttribute` property.
+   */
+  styleToAttribute?: Record<string, string>;
+  /**
+   * CSS properties to exclude from inlining.
+   * Mapped to Juice's static `excludedProperties` property.
+   */
+  excludedProperties?: string[];
+  /**
+   * Elements that can receive `width` HTML attributes.
+   * Mapped to Juice's static `widthElements` property.
+   *
+   * @default ['img', 'video']
+   */
+  widthElements?: string[];
+  /**
+   * Elements that can receive `height` HTML attributes.
+   * Mapped to Juice's static `heightElements` property.
+   *
+   * @default ['img', 'video']
+   */
+  heightElements?: string[];
+  /**
+   * Template language code blocks to preserve during inlining.
+   * Mapped to Juice's static `codeBlocks` property.
+   */
+  codeBlocks?: Record<string, {
+    start: string;
+    end: string;
+  }>;
+}
+/**
+ * Inline CSS from `<style>` tags into `style` attributes on matching elements.
+ *
+ * @param html    HTML string to transform.
+ * @param options Juice options plus Maizzle-specific extras.
+ * @returns       The transformed HTML string.
+ *
+ * @example
+ * import { inlineCss } from '@maizzle/framework'
+ *
+ * const out = inlineCss('<style>.red{color:red}</style><p class="red">x</p>', {
+ *   removeStyleTags: true,
+ * })
+ */
+declare function inlineCss(html: string, options?: InlineCssOptions): string;
+/**
+ * DOM-form of {@link inlineCss} used by the internal transformer pipeline.
+ * Takes a parsed DOM, returns a parsed DOM — avoids the redundant
+ * serialize/parse round-trips when chained with other transformers.
+ */
+declare function inlineCssDom(dom: ChildNode[], options?: InlineCssOptions): ChildNode[];
+//#endregion
+export { InlineCssOptions, inlineCss, inlineCssDom };
+//# sourceMappingURL=inlineCss.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inlineCss.d.ts","names":[],"sources":["../../src/transformers/inlineCss.ts"],"mappings":";;;;;;AASA;;UAAiB,gBAAA,SAAyB,OAAA;EAuBrB;;;;;EAjBnB,oBAAA;EAAA;;;;;;EAOA,QAAA;EA6BA;;;;EAxBA,SAAA;EA6BgD;;AAiBlD;;EAzCE,gBAAA,GAAmB,MAAA;EAyCiD;;;;EApCpE,kBAAA;EAoCoE;AAStE;;;;;EAtCE,aAAA;EAsCuF;;;;;;EA/BvF,cAAA;EA+BuF;;;;EA1BvF,UAAA,GAAa,MAAA;IAAiB,KAAA;IAAe,GAAA;EAAA;AAAA;;;;;;;;;;;;;;;iBAiB/B,SAAA,CAAU,IAAA,UAAc,OAAA,GAAS,gBAAA;;;;;;iBASjC,YAAA,CAAa,GAAA,EAAK,SAAA,IAAa,OAAA,GAAS,gBAAA,GAAwB,SAAA"}

package/dist/transformers/{inlineCSS.mjs → inlineCss.js}

@@ -1,23 +1,33 @@
-import { parse } from "../utils/ast/parser.mjs";
-import { walk } from "../utils/ast/walker.mjs";
-import { serialize } from "../utils/ast/serializer.mjs";
-import "../utils/ast/index.mjs";
+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 juice from "juice";
-
-//#region src/transformers/inlineCSS.ts
+//#region src/transformers/inlineCss.ts
 /**
-* Inline CSS transformer.
+* Inline CSS from `<style>` tags into `style` attributes on matching elements.
+*
+* @param html    HTML string to transform.
+* @param options Juice options plus Maizzle-specific extras.
+* @returns       The transformed HTML string.
 *
-* Inlines CSS from `<style>` tags into inline style attributes on HTML elements.
-* This is important for email client compatibility (especially Outlook on Windows).
+* @example
+* import { inlineCss } from '@maizzle/framework'
 *
-* Enabled when `css.inline` is set to `true` or an object with options.
-* All Juice options are supported and passed through directly.
+* const out = inlineCss('<style>.red{color:red}</style><p class="red">x</p>', {
+*   removeStyleTags: true,
+* })
 */
-function inlineCSS(dom, config = {}) {
-	const inline = config.inline;
-	if (!inline) return dom;
-	const { preferUnitlessValues = true, safelist, customCSS = "", styleToAttribute, excludedProperties, widthElements, heightElements, codeBlocks, ...juicePassthrough } = typeof inline === "object" ? inline : {};
+function inlineCss(html, options = {}) {
+	return serialize(inlineCssDom(parse(html), options));
+}
+/**
+* DOM-form of {@link inlineCss} used by the internal transformer pipeline.
+* Takes a parsed DOM, returns a parsed DOM — avoids the redundant
+* serialize/parse round-trips when chained with other transformers.
+*/
+function inlineCssDom(dom, options = {}) {
+	const { preferUnitlessValues = true, safelist, customCSS = "", styleToAttribute, excludedProperties, widthElements, heightElements, codeBlocks, ...juicePassthrough } = options;
 	juice.styleToAttribute = styleToAttribute ?? {};
 	juice.excludedProperties = ["--tw-shadow", ...excludedProperties ?? []];
 	juice.widthElements = (widthElements ?? ["img", "video"]).map((i) => i.toUpperCase());
@@ -75,7 +85,7 @@ function inlineCSS(dom, config = {}) {
 	});
 	return result;
 }
-
 //#endregion
-export { inlineCSS };
-//# sourceMappingURL=inlineCSS.mjs.map
+export { inlineCss, inlineCssDom };
+
+//# sourceMappingURL=inlineCss.js.map

package/dist/transformers/inlineCss.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inlineCss.js","names":[],"sources":["../../src/transformers/inlineCss.ts"],"sourcesContent":["import juice from 'juice'\nimport { walk, parse, serialize } from '../utils/ast/index.ts'\nimport type { ChildNode, Element } from 'domhandler'\nimport type { Options as JuiceOptions } from 'juice'\n\n/**\n * Options for the `inlineCss` transformer. Accepts every Juice option plus a\n * handful of Maizzle-specific extras.\n */\nexport interface InlineCssOptions extends JuiceOptions {\n  /**\n   * Convert `0px`, `0em` etc. to `0` in inline styles.\n   *\n   * @default true\n   */\n  preferUnitlessValues?: boolean\n  /**\n   * CSS selectors to preserve in `<style>` tags, even after inlining.\n   * Mapped to Juice's `preservedSelectors` option.\n   *\n   * @default []\n   */\n  safelist?: string[]\n  /**\n   * Additional CSS string to inline alongside `<style>` tag contents.\n   * Mapped to Juice's `extraCss` option.\n   */\n  customCSS?: string\n  /**\n   * Duplicate CSS properties to HTML attributes.\n   * Mapped to Juice's static `styleToAttribute` property.\n   */\n  styleToAttribute?: Record<string, string>\n  /**\n   * CSS properties to exclude from inlining.\n   * Mapped to Juice's static `excludedProperties` property.\n   */\n  excludedProperties?: string[]\n  /**\n   * Elements that can receive `width` HTML attributes.\n   * Mapped to Juice's static `widthElements` property.\n   *\n   * @default ['img', 'video']\n   */\n  widthElements?: string[]\n  /**\n   * Elements that can receive `height` HTML attributes.\n   * Mapped to Juice's static `heightElements` property.\n   *\n   * @default ['img', 'video']\n   */\n  heightElements?: string[]\n  /**\n   * Template language code blocks to preserve during inlining.\n   * Mapped to Juice's static `codeBlocks` property.\n   */\n  codeBlocks?: Record<string, { start: string; end: string }>\n}\n\n/**\n * Inline CSS from `<style>` tags into `style` attributes on matching elements.\n *\n * @param html    HTML string to transform.\n * @param options Juice options plus Maizzle-specific extras.\n * @returns       The transformed HTML string.\n *\n * @example\n * import { inlineCss } from '@maizzle/framework'\n *\n * const out = inlineCss('<style>.red{color:red}</style><p class=\"red\">x</p>', {\n *   removeStyleTags: true,\n * })\n */\nexport function inlineCss(html: string, options: InlineCssOptions = {}): string {\n  return serialize(inlineCssDom(parse(html), options))\n}\n\n/**\n * DOM-form of {@link inlineCss} used by the internal transformer pipeline.\n * Takes a parsed DOM, returns a parsed DOM — avoids the redundant\n * serialize/parse round-trips when chained with other transformers.\n */\nexport function inlineCssDom(dom: ChildNode[], options: InlineCssOptions = {}): ChildNode[] {\n  const {\n    preferUnitlessValues = true,\n    safelist,\n    customCSS = '',\n    styleToAttribute,\n    excludedProperties,\n    widthElements,\n    heightElements,\n    codeBlocks,\n    ...juicePassthrough\n  } = options\n\n  // Configure Juice static properties\n  juice.styleToAttribute = styleToAttribute ?? {}\n  juice.excludedProperties = ['--tw-shadow', ...(excludedProperties ?? [])]\n  juice.widthElements = (widthElements ?? ['img', 'video']).map(i => i.toUpperCase()) as unknown as HTMLElement[]\n  juice.heightElements = (heightElements ?? ['img', 'video']).map(i => i.toUpperCase()) as unknown as HTMLElement[]\n\n  // Add custom code blocks\n  if (codeBlocks && typeof codeBlocks === 'object') {\n    Object.entries(codeBlocks).forEach(([key, value]) => {\n      if (value.start && value.end) {\n        juice.codeBlocks[key] = value\n      }\n    })\n  }\n\n  // Handle style tags with embed attributes.\n  // We add a marker attribute that persists through the pipeline,\n  // then restore data-embed from it after Juice runs.\n  walk(dom, (node) => {\n    const el = node as Element\n    if (el.name === 'style' && el.attribs) {\n      // Sync data-embed ↔ embed. Use `in` so presence-only attrs\n      // (<style embed> → attribs.embed === '') still count.\n      if ('embed' in el.attribs && !('data-embed' in el.attribs)) {\n        el.attribs['data-embed'] = ''\n      }\n      if ('data-embed' in el.attribs && !('embed' in el.attribs)) {\n        el.attribs.embed = ''\n      }\n\n      // Add marker that persists through the pipeline\n      if ('data-embed' in el.attribs) {\n        el.attribs['data-maizzle-embed'] = ''\n      }\n    }\n  })\n\n  // Serialize for juice (juice requires a string)\n  const serialized = serialize(dom)\n\n  let inlinedHtml: string\n\n  try {\n    const juiceOptions: JuiceOptions = {\n      removeStyleTags: juicePassthrough.removeStyleTags ?? false,\n      removeInlinedSelectors: juicePassthrough.removeInlinedSelectors ?? true,\n      applyWidthAttributes: juicePassthrough.applyWidthAttributes ?? true,\n      applyHeightAttributes: juicePassthrough.applyHeightAttributes ?? true,\n      preservedSelectors: safelist ?? [],\n      ...customCSS ? { extraCss: customCSS } : {},\n      inlineDuplicateProperties: juicePassthrough.inlineDuplicateProperties ?? true,\n      ...juicePassthrough,\n    }\n\n    inlinedHtml = juice(serialized, juiceOptions)\n  } catch {\n    // If Juice fails, return the dom unchanged\n    return dom\n  }\n\n  // Post-process for preferUnitlessValues\n  const result = parse(inlinedHtml)\n\n  walk(result, (node) => {\n    const el = node as Element\n    if (el.attribs?.style) {\n      // Normalize style formatting: ensure spaces after : and ;\n      let style = el.attribs.style\n        .replace(/:\\s*/g, ': ')\n        .replace(/;\\s*/g, '; ')\n        .trimEnd()\n\n      // Ensure trailing semicolon\n      if (!style.endsWith(';')) {\n        style += ';'\n      }\n\n      if (preferUnitlessValues) {\n        style = style.replace(\n          /\\b0(px|rem|em|%|vh|vw|vmin|vmax|in|cm|mm|pt|pc|ex|ch)\\b/g,\n          '0'\n        )\n      }\n\n      el.attribs.style = style\n    }\n  })\n\n  /**\n   * Restore `embed` from our marker so the purge step can detect\n   * these tags and skip them. Drop `data-embed` (juice's name)\n   * since it's redundant once `embed` is back, and let purge\n   * strip `embed` itself at the end of its run.\n   */\n  walk(result, (node) => {\n    const el = node as Element\n    if (el.name === 'style' && el.attribs && 'data-maizzle-embed' in el.attribs) {\n      el.attribs.embed = ''\n      delete el.attribs['data-embed']\n      delete el.attribs['data-maizzle-embed']\n    }\n  })\n\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAyEA,SAAgB,UAAU,MAAc,UAA4B,EAAE,EAAU;CAC9E,OAAO,UAAU,aAAa,MAAM,KAAK,EAAE,QAAQ,CAAC;;;;;;;AAQtD,SAAgB,aAAa,KAAkB,UAA4B,EAAE,EAAe;CAC1F,MAAM,EACJ,uBAAuB,MACvB,UACA,YAAY,IACZ,kBACA,oBACA,eACA,gBACA,YACA,GAAG,qBACD;CAGJ,MAAM,mBAAmB,oBAAoB,EAAE;CAC/C,MAAM,qBAAqB,CAAC,eAAe,GAAI,sBAAsB,EAAE,CAAE;CACzE,MAAM,iBAAiB,iBAAiB,CAAC,OAAO,QAAQ,EAAE,KAAI,MAAK,EAAE,aAAa,CAAC;CACnF,MAAM,kBAAkB,kBAAkB,CAAC,OAAO,QAAQ,EAAE,KAAI,MAAK,EAAE,aAAa,CAAC;CAGrF,IAAI,cAAc,OAAO,eAAe,UACtC,OAAO,QAAQ,WAAW,CAAC,SAAS,CAAC,KAAK,WAAW;EACnD,IAAI,MAAM,SAAS,MAAM,KACvB,MAAM,WAAW,OAAO;GAE1B;CAMJ,KAAK,MAAM,SAAS;EAClB,MAAM,KAAK;EACX,IAAI,GAAG,SAAS,WAAW,GAAG,SAAS;GAGrC,IAAI,WAAW,GAAG,WAAW,EAAE,gBAAgB,GAAG,UAChD,GAAG,QAAQ,gBAAgB;GAE7B,IAAI,gBAAgB,GAAG,WAAW,EAAE,WAAW,GAAG,UAChD,GAAG,QAAQ,QAAQ;GAIrB,IAAI,gBAAgB,GAAG,SACrB,GAAG,QAAQ,wBAAwB;;GAGvC;CAGF,MAAM,aAAa,UAAU,IAAI;CAEjC,IAAI;CAEJ,IAAI;EAYF,cAAc,MAAM,YAAY;GAV9B,iBAAiB,iBAAiB,mBAAmB;GACrD,wBAAwB,iBAAiB,0BAA0B;GACnE,sBAAsB,iBAAiB,wBAAwB;GAC/D,uBAAuB,iBAAiB,yBAAyB;GACjE,oBAAoB,YAAY,EAAE;GAClC,GAAG,YAAY,EAAE,UAAU,WAAW,GAAG,EAAE;GAC3C,2BAA2B,iBAAiB,6BAA6B;GACzE,GAAG;GAGuC,CAAC;SACvC;EAEN,OAAO;;CAIT,MAAM,SAAS,MAAM,YAAY;CAEjC,KAAK,SAAS,SAAS;EACrB,MAAM,KAAK;EACX,IAAI,GAAG,SAAS,OAAO;GAErB,IAAI,QAAQ,GAAG,QAAQ,MACpB,QAAQ,SAAS,KAAK,CACtB,QAAQ,SAAS,KAAK,CACtB,SAAS;GAGZ,IAAI,CAAC,MAAM,SAAS,IAAI,EACtB,SAAS;GAGX,IAAI,sBACF,QAAQ,MAAM,QACZ,4DACA,IACD;GAGH,GAAG,QAAQ,QAAQ;;GAErB;;;;;;;CAQF,KAAK,SAAS,SAAS;EACrB,MAAM,KAAK;EACX,IAAI,GAAG,SAAS,WAAW,GAAG,WAAW,wBAAwB,GAAG,SAAS;GAC3E,GAAG,QAAQ,QAAQ;GACnB,OAAO,GAAG,QAAQ;GAClB,OAAO,GAAG,QAAQ;;GAEpB;CAEF,OAAO"}