@maizzle/framework 6.0.0-rc.9 → 6.0.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"entities.d.ts","names":[],"sources":["../../src/transformers/entities.ts"],"mappings":";;;;;;;AAsDA;;;;;;;;AAAoE;AASpE;;;;;;;;;;;iBATgB,QAAA,CAAS,IAAA,UAAc,MAAA,GAAQ,cAAqB;;;AASmB;;;iBAAvE,WAAA,CAAY,GAAA,EAAK,SAAA,IAAa,MAAA,GAAQ,cAAA,GAAwB,SAAA"}

package/dist/transformers/entities.js

@@ -0,0 +1,74 @@
+import { parse } from "../utils/ast/parser.js";
+import { walk } from "../utils/ast/walker.js";
+import { serialize } from "../utils/ast/serializer.js";
+import "../utils/ast/index.js";
+import { defu as defu$1 } from "defu";
+//#region src/transformers/entities.ts
+const DEFAULT_ENTITIES = {
+	"‍": "‍",
+	"‌": "‌",
+	"\xA0": " ",
+	"­": "­",
+	"​": "​",
+	" ": " ",
+	"": "",
+	"͏": "͏",
+	" ": " ",
+	"\u2028": "&LineSeparator;",
+	"\u2029": "&ParagraphSeparator;",
+	"·": "·",
+	"–": "–",
+	"—": "—",
+	"‘": "‘",
+	"’": "’",
+	"“": "“",
+	"”": "”",
+	"«": "«",
+	"»": "»",
+	"•": "•",
+	"‹": "‹",
+	"›": "›"
+};
+/**
+* Replace literal Unicode characters in text nodes with their HTML entity
+* equivalents (zero-width joiners, non-breaking spaces, smart quotes,
+* dashes, etc.) for better email-client rendering.
+*
+* @param html   HTML string to transform.
+* @param custom Extra entries merged on top of the built-in entity map, or
+*               `false` to disable the transform. Defaults to `true`
+*               (built-ins only).
+* @returns      The transformed HTML string.
+*
+* @example
+* import { entities } from '@maizzle/framework'
+*
+* // Defaults only
+* entities('hello world') // → 'hello world'
+*
+* // Add a custom mapping
+* entities('© Maizzle', { '©': '©' })
+*
+* // Disable the transform
+* entities('hello world', false)
+*/
+function entities(html, custom = true) {
+	return serialize(entitiesDom(parse(html), custom));
+}
+/**
+* DOM-form of {@link entities} used by the internal transformer pipeline.
+* Takes a parsed DOM, returns a parsed DOM — avoids redundant
+* serialize/parse round-trips when chained with other transformers.
+*/
+function entitiesDom(dom, custom = true) {
+	if (!custom) return dom;
+	const map = typeof custom === "object" ? defu$1(custom, DEFAULT_ENTITIES) : DEFAULT_ENTITIES;
+	walk(dom, (node) => {
+		if (node.type === "text") for (const [char, entity] of Object.entries(map)) node.data = node.data.split(char).join(entity);
+	});
+	return dom;
+}
+//#endregion
+export { entities, entitiesDom };
+
+//# sourceMappingURL=entities.js.map

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  '\\uFEFF': '&#65279;',\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,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;AACZ;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,SAAS,MAAc,SAAyB,MAAc;CAC5E,OAAO,UAAU,YAAY,MAAM,IAAI,GAAG,MAAM,CAAC;AACnD;;;;;;AAOA,SAAgB,YAAY,KAAkB,SAAyB,MAAmB;CACxF,IAAI,CAAC,QAAQ,OAAO;CAEpB,MAAM,MAAM,OAAO,WAAW,WAC1BA,OAAM,QAAkC,gBAAgB,IACxD;CAEJ,KAAK,MAAM,SAAS;EAClB,IAAI,KAAK,SAAS,QAChB,KAAK,MAAM,CAAC,MAAM,WAAW,OAAO,QAAQ,GAAG,GAC7C,KAAK,OAAO,KAAK,KAAK,MAAM,IAAI,CAAC,CAAC,KAAK,MAAM;CAGnD,CAAC;CAED,OAAO;AACT"}

package/dist/transformers/filters/{defaults.d.mts → defaults.d.ts}

@@ -3,4 +3,4 @@ type FilterFunction = (str: string, value: string) => string;
 declare const defaults: Record<string, FilterFunction>;
 //#endregion
 export { FilterFunction, defaults };
-//# sourceMappingURL=defaults.d.mts.map
+//# sourceMappingURL=defaults.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","names":[],"sources":["../../../src/transformers/filters/defaults.ts"],"mappings":";KAAY,cAAA,IAAkB,GAAA,UAAa,KAAa;AAAA,cAgB3C,QAAA,EAAU,MAAM,SAAS,cAAA"}

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":";AAEA,MAAM,YAAoC;CACxC,MAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;CACL,KAAK;AACP;AAEA,MAAM,cAAc;AAEpB,SAAS,WAAW,KAAqB;CACvC,OAAO,IAAI,QAAQ,cAAa,OAAM,UAAU,GAAG;AACrD;AAEA,MAAa,WAA2C;CACtD,SAAS,KAAK,UAAU,MAAM;CAC9B,UAAU,KAAK,UAAU,QAAQ;CACjC,YAAW,QAAO,IAAI,YAAY;CAClC,YAAW,QAAO,IAAI,YAAY;CAClC,aAAY,QAAO,IAAI,OAAO,CAAC,CAAC,CAAC,YAAY,IAAI,IAAI,MAAM,CAAC;CAC5D,OAAM,QAAO,OAAO,KAAK,KAAK,OAAO,WAAW,GAAG,CAAC,CAAC;CACrD,QAAO,QAAO,OAAO,KAAK,MAAM,OAAO,WAAW,GAAG,CAAC,CAAC;CACvD,QAAO,QAAO,OAAO,KAAK,MAAM,OAAO,WAAW,GAAG,CAAC,CAAC;CACvD,SAAQ,QAAO,WAAW,GAAG;CAC7B,gBAAe,QAAO;EAUpB,OAAO,WATS,IACb,QAAQ,UAAU,GAAG,CAAC,CACtB,QAAQ,SAAS,GAAG,CAAC,CACrB,QAAQ,SAAS,GAAG,CAAC,CACrB,QAAQ,UAAU,IAAG,CAAC,CACtB,QAAQ,WAAW,IAAG,CAAC,CACvB,QAAQ,UAAU,GAAG,CAAC,CACtB,QAAQ,WAAW,GAEE,CAAC;CAC3B;CACA,SAAQ,QAAO,IAAI,UAAU;CAC7B,SAAQ,QAAO,IAAI,QAAQ;CAC3B,OAAM,QAAO,IAAI,KAAK;CACtB,QAAQ,KAAK,UAAU,OAAO,OAAO,WAAW,GAAG,IAAI,OAAO,WAAW,KAAK,CAAC;CAC/E,OAAO,KAAK,UAAU,OAAO,OAAO,WAAW,GAAG,IAAI,OAAO,WAAW,KAAK,CAAC;CAC9E,WAAW,KAAK,UAAU,OAAO,OAAO,WAAW,GAAG,IAAI,OAAO,WAAW,KAAK,CAAC;CAClF,QAAQ,KAAK,UAAU,OAAO,OAAO,WAAW,GAAG,IAAI,OAAO,WAAW,KAAK,CAAC;CAC/E,cAAc,KAAK,UAAU,OAAO,OAAO,WAAW,GAAG,IAAI,OAAO,WAAW,KAAK,CAAC;CACrF,SAAS,KAAK,UAAU,OAAO,OAAO,WAAW,GAAG,IAAI,OAAO,WAAW,KAAK,CAAC;CAChF,SAAS,KAAK,UAAU,OAAO,OAAO,WAAW,GAAG,IAAI,OAAO,WAAW,KAAK,CAAC;CAChF,kBAAiB,QAAO,IAAI,QAAQ,OAAO,MAAM;CACjD,mBAAkB,QAAO,IAAI,QAAQ,OAAO,EAAE;CAC9C,SAAS,KAAK,UAAU,IAAI,MAAM,KAAK,CAAC,CAAC,KAAK,EAAE;CAChD,iBAAiB,KAAK,UAAU;EAC9B,MAAM,IAAI,IAAI,QAAQ,KAAK;EAC3B,OAAO,MAAM,KAAK,MAAM,IAAI,MAAM,GAAG,CAAC,IAAI,IAAI,MAAM,IAAI,MAAM,MAAM;CACtE;CACA,UAAU,KAAK,UAAU;EACvB,MAAM,CAAC,SAAS,IAAI,cAAc,MAAM,MAAM,MAAM,GAAG;EACvD,OAAO,IAAI,MAAM,MAAM,CAAC,CAAC,KAAK,WAAW;CAC3C;CACA,kBAAkB,KAAK,UAAU;EAC/B,MAAM,CAAC,SAAS,IAAI,cAAc,MAAM,MAAM,MAAM,GAAG;EACvD,MAAM,IAAI,IAAI,QAAQ,MAAM;EAC5B,OAAO,MAAM,KAAK,MAAM,IAAI,MAAM,GAAG,CAAC,IAAI,cAAc,IAAI,MAAM,IAAI,OAAO,MAAM;CACrF;CACA,OAAM,QAAO,OAAO,IAAI,MAAM;CAC9B,QAAQ,KAAK,UAAU;EACrB,MAAM,OAAO,MAAM,MAAM,GAAG,CAAC,CAAC,KAAI,MAAK,OAAO,SAAS,EAAE,KAAK,GAAG,EAAE,CAAC;EACpE,OAAO,IAAI,MAAM,KAAK,IAAI,KAAK,EAAE;CACnC;CACA,WAAW,KAAK,UAAU;EACxB,MAAM,aAAa,MAAM,QAAQ,GAAG;EACpC,MAAM,SAAS,OAAO,SAAS,eAAe,KAAK,QAAQ,MAAM,MAAM,GAAG,UAAU,GAAG,EAAE;EACzF,MAAM,WAAW,eAAe,KAAK,QAAQ,MAAM,MAAM,aAAa,CAAC;EAEvE,IAAI,IAAI,UAAU,QAAQ,OAAO;EAEjC,OAAO,IAAI,MAAM,GAAG,MAAM,IAAI;CAChC;CACA,mBAAmB,KAAK,UAAU;EAChC,MAAM,aAAa,MAAM,QAAQ,GAAG;EACpC,MAAM,QAAQ,OAAO,SAAS,eAAe,KAAK,QAAQ,MAAM,MAAM,GAAG,UAAU,GAAG,EAAE;EACxF,MAAM,WAAW,eAAe,KAAK,QAAQ,MAAM,MAAM,aAAa,CAAC;EACvE,MAAM,QAAQ,IAAI,MAAM,KAAK,CAAC,CAAC,OAAO,OAAO;EAE7C,IAAI,MAAM,UAAU,OAAO,OAAO;EAElC,OAAO,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,KAAK,GAAG,IAAI;CAC3C;CACA,eAAc,QAAO,mBAAmB,IAAI,QAAQ,OAAO,GAAG,CAAC;CAC/D,eAAc,QAAO,mBAAmB,GAAG;AAC7C"}

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

@@ -0,0 +1,43 @@
+import { FilterFunction } from "./defaults.js";
+import { ChildNode } from "domhandler";
+
+//#region src/transformers/filters/index.d.ts
+type FiltersConfig = false | Record<string, (str: string, value: string) => string>;
+/**
+ * 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)
+ */
+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 filtersDom(dom: ChildNode[], custom?: FiltersConfig): ChildNode[];
+//#endregion
+export { type FilterFunction, FiltersConfig, filters, filtersDom };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/transformers/filters/index.ts"],"mappings":";;;;KAMY,aAAA,WAAwB,MAAM,UAAU,GAAA,UAAa,KAAA;;AAAjE;;;;;;;;AAA8E;AA2C9E;;;;;;;;AAAgE;AAShE;;;;;;;;;iBATgB,OAAA,CAAQ,IAAA,UAAc,MAAA,GAAQ,aAAkB;;;;;AASmB;iBAAnE,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,MAAM,GAAG;EAChC,IAAI,cAAc,QAAQ,KAAK,UAAU,QACvC,aAAa,KAAK,UAAyB,QAAQ;EAGrD,SAAS,IAAI;CACf;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,QAAQ,MAAc,SAAwB,CAAC,GAAW;CACxE,OAAO,UAAU,WAAW,MAAM,IAAI,GAAG,MAAM,CAAC;AAClD;;;;;;AAOA,SAAgB,WAAW,KAAkB,SAAwB,CAAC,GAAgB;CACpF,IAAI,WAAW,OAAO,OAAO;CAE7B,MAAM,aAAa;EAAE,GAAG;EAAU,GAAG;CAAO;CAC5C,MAAM,cAAc,IAAI,IAAI,OAAO,KAAK,UAAU,CAAC;CAEnD,aAAa,MAAM,SAAS;EAC1B,MAAM,KAAK;EAEX,IAAI,CAAC,GAAG,SAAS;EAGjB,MAAM,UAAkD,CAAC;EAEzD,KAAK,MAAM,QAAQ,OAAO,KAAK,GAAG,OAAO,GACvC,IAAI,YAAY,IAAI,IAAI,GACtB,QAAQ,KAAK;GAAE,MAAM;GAAM,OAAO,GAAG,QAAQ;EAAM,CAAC;EAIxD,IAAI,QAAQ,WAAW,GAAG;EAG1B,IAAI,UAAU,UAAU,GAAG,QAAuB;EAGlD,KAAK,MAAM,EAAE,MAAM,WAAW,SAAS;GACrC,UAAU,WAAW,KAAK,CAAC,SAAS,KAAK;GACzC,OAAO,GAAG,QAAQ;EACpB;EAGA,IAAI,YAAY,IACd,GAAG,WAAW,CAAC;OACV,IAAI,YAAY,KAAK,OAAO,GAAG;GAEpC,MAAM,cAAc,MAAM,OAAO;GAEjC,KAAK,MAAM,SAAS,aAClB,MAAM,SAAS;GAGjB,GAAG,WAAW;EAChB,OAAO;GAEL,MAAM,WAAW,IAAI,KAAK,OAAO;GACjC,SAAS,SAAS;GAClB,GAAG,WAAW,CAAC,QAAQ;EACzB;CACF,CAAC;CAED,OAAO;AACT"}

package/dist/transformers/format.d.ts

@@ -0,0 +1,22 @@
+import { FormatOptions, FormatOptions as FormatOptions$1 } from "oxfmt";
+
+//#region src/transformers/format.d.ts
+/**
+ * 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 })
+ */
+declare function format(html: string, options?: FormatOptions$1): Promise<string>;
+//#endregion
+export { type FormatOptions, format };
+//# sourceMappingURL=format.d.ts.map

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

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

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;AAC9B;;;;;;;;;;;;;;;;AAiBA,eAAsB,OAAO,MAAc,UAAyB,CAAC,GAAoB;CAGvF,QAAO,MADcA,SAAM,cAAc,MAD1BC,OAAM,SAAS,eACsB,CAAC,EAAA,CACvC;AAChB"}

package/dist/transformers/imgWidth.d.ts

@@ -0,0 +1,20 @@
+import { ChildNode } from "domhandler";
+
+//#region src/transformers/imgWidth.d.ts
+/**
+ * Backfill the `width` attribute on `<Img>`-emitted images that were left
+ * without an explicit width. Runs after `columnWidth`, so every
+ * Container/Section/Column ancestor already carries a resolved pixel
+ * width in its inline style.
+ *
+ * For each marked `<img>`, walk up the ancestor chain accumulating
+ * horizontal padding+border, stopping at the nearest ancestor with a
+ * resolvable pixel width. The image width is that source minus the
+ * accumulated inset (so padding on wrappers narrows the image to its
+ * content box). When no pixel width is found anywhere, the marker is
+ * dropped and the image stays fluid.
+ */
+declare function imgWidthDom(dom: ChildNode[]): ChildNode[];
+//#endregion
+export { imgWidthDom };
+//# sourceMappingURL=imgWidth.d.ts.map

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

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

package/dist/transformers/imgWidth.js

@@ -0,0 +1,76 @@
+import { walk } from "../utils/ast/walker.js";
+import "../utils/ast/index.js";
+import { horizontalBorderPx, horizontalPaddingPx, lengthToPx } from "../utils/cssBox.js";
+import safeParser from "postcss-safe-parser";
+//#region src/transformers/imgWidth.ts
+const MARKER = "data-maizzle-img-width";
+function firstDeclValue(root, prop) {
+	let found;
+	root.walkDecls(prop, (d) => {
+		found = d.value;
+		return false;
+	});
+	return found;
+}
+/**
+* Resolve an element's own pixel width from its inlined style (`max-width`
+* then `width`) or, failing that, its `width` attribute. Percentages and
+* other non-pixel lengths return null — the caller leaves the image fluid.
+*/
+function pixelWidthOf(el, root) {
+	if (root) {
+		const fromStyle = firstDeclValue(root, "max-width") ?? "";
+		const styleMax = fromStyle ? lengthToPx(fromStyle) : null;
+		if (styleMax != null) return styleMax;
+		const w = firstDeclValue(root, "width");
+		const styleWidth = w ? lengthToPx(w) : null;
+		if (styleWidth != null) return styleWidth;
+	}
+	const attrWidth = el.attribs?.width;
+	return attrWidth ? lengthToPx(attrWidth) : null;
+}
+/**
+* Backfill the `width` attribute on `<Img>`-emitted images that were left
+* without an explicit width. Runs after `columnWidth`, so every
+* Container/Section/Column ancestor already carries a resolved pixel
+* width in its inline style.
+*
+* For each marked `<img>`, walk up the ancestor chain accumulating
+* horizontal padding+border, stopping at the nearest ancestor with a
+* resolvable pixel width. The image width is that source minus the
+* accumulated inset (so padding on wrappers narrows the image to its
+* content box). When no pixel width is found anywhere, the marker is
+* dropped and the image stays fluid.
+*/
+function imgWidthDom(dom) {
+	const targets = [];
+	walk(dom, (node) => {
+		const el = node;
+		if (el.attribs && MARKER in el.attribs) targets.push(el);
+	});
+	for (const img of targets) {
+		let cur = img.parent;
+		let insetPx = 0;
+		let resolvedPx = null;
+		while (cur) {
+			const el = cur;
+			if (el.attribs) {
+				const root = el.attribs.style ? safeParser(el.attribs.style) : null;
+				if (root) insetPx += horizontalPaddingPx(root) + horizontalBorderPx(root);
+				const px = pixelWidthOf(el, root);
+				if (px != null) {
+					resolvedPx = px;
+					break;
+				}
+			}
+			cur = cur.parent ?? null;
+		}
+		if (resolvedPx != null) img.attribs.width = String(Math.max(0, Math.round(resolvedPx - insetPx)));
+		delete img.attribs[MARKER];
+	}
+	return dom;
+}
+//#endregion
+export { imgWidthDom };
+
+//# sourceMappingURL=imgWidth.js.map

package/dist/transformers/imgWidth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"imgWidth.js","names":[],"sources":["../../src/transformers/imgWidth.ts"],"sourcesContent":["import safeParser from 'postcss-safe-parser'\nimport type { Root } from 'postcss'\nimport { walk } from '../utils/ast/index.ts'\nimport { horizontalBorderPx, horizontalPaddingPx, lengthToPx } from '../utils/cssBox.ts'\nimport type { ChildNode, Element, ParentNode } from 'domhandler'\n\nconst MARKER = 'data-maizzle-img-width'\n\nfunction firstDeclValue(root: Root, prop: string): string | undefined {\n  let found: string | undefined\n  root.walkDecls(prop, (d) => {\n    found = d.value\n    return false\n  })\n  return found\n}\n\n/**\n * Resolve an element's own pixel width from its inlined style (`max-width`\n * then `width`) or, failing that, its `width` attribute. Percentages and\n * other non-pixel lengths return null — the caller leaves the image fluid.\n */\nfunction pixelWidthOf(el: Element, root: Root | null): number | null {\n  if (root) {\n    const fromStyle = (firstDeclValue(root, 'max-width') ?? '')\n    const styleMax = fromStyle ? lengthToPx(fromStyle) : null\n    if (styleMax != null) return styleMax\n    const w = firstDeclValue(root, 'width')\n    const styleWidth = w ? lengthToPx(w) : null\n    if (styleWidth != null) return styleWidth\n  }\n  const attrWidth = el.attribs?.width\n  return attrWidth ? lengthToPx(attrWidth) : null\n}\n\n/**\n * Backfill the `width` attribute on `<Img>`-emitted images that were left\n * without an explicit width. Runs after `columnWidth`, so every\n * Container/Section/Column ancestor already carries a resolved pixel\n * width in its inline style.\n *\n * For each marked `<img>`, walk up the ancestor chain accumulating\n * horizontal padding+border, stopping at the nearest ancestor with a\n * resolvable pixel width. The image width is that source minus the\n * accumulated inset (so padding on wrappers narrows the image to its\n * content box). When no pixel width is found anywhere, the marker is\n * dropped and the image stays fluid.\n */\nexport function imgWidthDom(dom: ChildNode[]): ChildNode[] {\n  const targets: Element[] = []\n\n  walk(dom, (node) => {\n    const el = node as Element\n    if (el.attribs && MARKER in el.attribs) targets.push(el)\n  })\n\n  for (const img of targets) {\n    let cur: ParentNode | null = img.parent\n    let insetPx = 0\n    let resolvedPx: number | null = null\n\n    while (cur) {\n      const el = cur as Element\n      if (el.attribs) {\n        const root = el.attribs.style ? safeParser(el.attribs.style) : null\n        if (root) insetPx += horizontalPaddingPx(root) + horizontalBorderPx(root)\n\n        const px = pixelWidthOf(el, root)\n        if (px != null) {\n          resolvedPx = px\n          break\n        }\n      }\n      cur = (cur as any).parent ?? null\n    }\n\n    if (resolvedPx != null) {\n      img.attribs.width = String(Math.max(0, Math.round(resolvedPx - insetPx)))\n    }\n\n    delete img.attribs[MARKER]\n  }\n\n  return dom\n}\n"],"mappings":";;;;;AAMA,MAAM,SAAS;AAEf,SAAS,eAAe,MAAY,MAAkC;CACpE,IAAI;CACJ,KAAK,UAAU,OAAO,MAAM;EAC1B,QAAQ,EAAE;EACV,OAAO;CACT,CAAC;CACD,OAAO;AACT;;;;;;AAOA,SAAS,aAAa,IAAa,MAAkC;CACnE,IAAI,MAAM;EACR,MAAM,YAAa,eAAe,MAAM,WAAW,KAAK;EACxD,MAAM,WAAW,YAAY,WAAW,SAAS,IAAI;EACrD,IAAI,YAAY,MAAM,OAAO;EAC7B,MAAM,IAAI,eAAe,MAAM,OAAO;EACtC,MAAM,aAAa,IAAI,WAAW,CAAC,IAAI;EACvC,IAAI,cAAc,MAAM,OAAO;CACjC;CACA,MAAM,YAAY,GAAG,SAAS;CAC9B,OAAO,YAAY,WAAW,SAAS,IAAI;AAC7C;;;;;;;;;;;;;;AAeA,SAAgB,YAAY,KAA+B;CACzD,MAAM,UAAqB,CAAC;CAE5B,KAAK,MAAM,SAAS;EAClB,MAAM,KAAK;EACX,IAAI,GAAG,WAAW,UAAU,GAAG,SAAS,QAAQ,KAAK,EAAE;CACzD,CAAC;CAED,KAAK,MAAM,OAAO,SAAS;EACzB,IAAI,MAAyB,IAAI;EACjC,IAAI,UAAU;EACd,IAAI,aAA4B;EAEhC,OAAO,KAAK;GACV,MAAM,KAAK;GACX,IAAI,GAAG,SAAS;IACd,MAAM,OAAO,GAAG,QAAQ,QAAQ,WAAW,GAAG,QAAQ,KAAK,IAAI;IAC/D,IAAI,MAAM,WAAW,oBAAoB,IAAI,IAAI,mBAAmB,IAAI;IAExE,MAAM,KAAK,aAAa,IAAI,IAAI;IAChC,IAAI,MAAM,MAAM;KACd,aAAa;KACb;IACF;GACF;GACA,MAAO,IAAY,UAAU;EAC/B;EAEA,IAAI,cAAc,MAChB,IAAI,QAAQ,QAAQ,OAAO,KAAK,IAAI,GAAG,KAAK,MAAM,aAAa,OAAO,CAAC,CAAC;EAG1E,OAAO,IAAI,QAAQ;CACrB;CAEA,OAAO;AACT"}

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

@@ -1,4 +1,5 @@
-import { MaizzleConfig } from "../types/config.mjs";
+import { MaizzleConfig } from "../types/config.js";
+import { TailwindBlock } from "../composables/renderContext.js";
 
 //#region src/transformers/index.d.ts
 /**
@@ -31,7 +32,7 @@ import { MaizzleConfig } from "../types/config.mjs";
  * 15. Prettify
  * 16. Minify
  */
-declare function runTransformers(html: string, config: MaizzleConfig, filePath?: string, doctype?: string): Promise<string>;
+declare function runTransformers(html: string, config: MaizzleConfig, filePath?: string, doctype?: string, tailwindBlocks?: TailwindBlock[]): Promise<string>;
 //#endregion
 export { runTransformers };
-//# sourceMappingURL=index.d.mts.map
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/transformers/index.ts"],"mappings":";;;;;;AAwDA;;;;;;;;;;;;;;;;;AAMU;;;;;;;;;;;iBANY,eAAA,CACpB,IAAA,UACA,MAAA,EAAQ,aAAA,EACR,QAAA,WACA,OAAA,WACA,cAAA,GAAiB,aAAA,KAChB,OAAA"}

package/dist/transformers/index.js

@@ -0,0 +1,163 @@
+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 { safeSelectorsDom } from "./safeSelectors.js";
+import { attributeToStyleDom } from "./attributeToStyle.js";
+import { inlineCssDom } from "./inlineCss.js";
+import { msoPlaceholders } from "./msoPlaceholders.js";
+import { columnWidth } from "./columnWidth.js";
+import { imgWidthDom } from "./imgWidth.js";
+import { removeAttributesDom } from "./removeAttributes.js";
+import { shorthandCssDom } from "./shorthandCss.js";
+import { sixHexDom } from "./sixHex.js";
+import { addAttributesDom } 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 { minifyCodeInline } from "./minifyCodeInline.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) {
+	/**
+	* Per-transformer skip map — only honored when useTransformers is an object.
+	* Whole-pipeline opt-out (`useTransformers === false`) is handled upstream
+	* in build.ts / render so we never reach this function in that case.
+	*
+	* A toggle set to `true` *force-enables* its transformer for this run
+	* by layering on the matching config slice (e.g. `prettify: true`
+	* sets `html.format = true`). This only applies to transformers
+	* whose enable flag is a plain boolean — data-driven ones
+	* (filters, baseURL, urlQuery, etc.) need actual config
+	* values, so a bare `true` for those is a no-op.
+	*/
+	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.safeSelectors === 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("safeSelectors")) dom = safeSelectorsDom(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);
+	dom = imgWidthDom(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 = addAttributesDom(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);
+	}
+	/**
+	* Strip self-closing slashes for HTML5 doctypes, but preserve content
+	* inside MSO conditional comments (XML-ish, case/syntax sensitive).
+	* MUST run BEFORE minifyCodeInline: at this point, CodeInline's
+	* shiki output is still marker-encoded (§MZLT§/§MZGT§), so any
+	* ` />` in the highlighted source code (e.g. a Vue self-close
+	* tag) hasn't materialized yet and can't be mistakenly
+	* stripped from inside a `<code>` element.
+	*/
+	if (!isXhtml) result = result.replace(/<!--\[if [^\]]*\]>[\s\S]*?<!\[endif\]-->|( \/>)/g, (match, selfClose) => selfClose ? ">" : match);
+	/**
+	* 16.5. Strip whitespace inside `data-minify-inline` markers (CodeInline's
+	* Shiki output, etc.). Runs after format/minify so it cleans up the
+	* pretty-printer's indentation between sibling tags.
+	*/
+	result = minifyCodeInline(result);
+	return result;
+}
+//#endregion
+export { runTransformers };
+
+//# sourceMappingURL=index.js.map