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

package/dist/transformers/removeAttributes.js

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

package/dist/transformers/removeAttributes.js.map

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

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

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

package/dist/transformers/replaceStrings.js.map

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

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

@@ -1,8 +1,7 @@
-import { walk } from "../utils/ast/walker.mjs";
-import "../utils/ast/index.mjs";
+import { walk } from "../utils/ast/walker.js";
+import "../utils/ast/index.js";
 import postcss from "postcss";
 import safeParser from "postcss-safe-parser";
-
 //#region src/transformers/safeClassNames.ts
 const DEFAULT_REPLACEMENTS = {
 	":": "-",
@@ -97,7 +96,7 @@ function safeClassNames(dom, config = {}) {
 	});
 	return dom;
 }
-
 //#endregion
 export { safeClassNames };
-//# sourceMappingURL=safeClassNames.mjs.map
+
+//# sourceMappingURL=safeClassNames.js.map

package/dist/transformers/safeClassNames.js.map

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

package/dist/transformers/shorthandCss.d.ts

@@ -0,0 +1,47 @@
+import { ChildNode } from "domhandler";
+
+//#region src/transformers/shorthandCss.d.ts
+/**
+ * Options for the `shorthandCss` transformer.
+ */
+interface ShorthandCssOptions {
+  /**
+   * Restrict the transform to a list of HTML tag names. Omit to apply to
+   * every element with a `style` attribute.
+   *
+   * @example ['td', 'div']
+   */
+  tags?: string[];
+}
+/**
+ * Rewrite longhand CSS inside inline `style` attributes with shorthand
+ * syntax. Works with margin, padding, and border when all sides are
+ * specified.
+ *
+ * For example:
+ * `margin-left: 2px; margin-right: 2px; margin-top: 4px; margin-bottom: 4px`
+ * becomes:
+ * `margin: 4px 2px`
+ *
+ * @param html    HTML string to transform.
+ * @param options Optional Maizzle options (`tags`).
+ * @returns       The transformed HTML string.
+ *
+ * @example
+ * import { shorthandCss } from '@maizzle/framework'
+ *
+ * const out = shorthandCss(
+ *   '<p style="margin-top: 4px; margin-right: 2px; margin-bottom: 4px; margin-left: 2px;">x</p>',
+ *   { tags: ['p'] },
+ * )
+ */
+declare function shorthandCss(html: string, options?: ShorthandCssOptions): string;
+/**
+ * DOM-form of {@link shorthandCss} 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 shorthandCssDom(dom: ChildNode[], options?: ShorthandCssOptions): ChildNode[];
+//#endregion
+export { ShorthandCssOptions, shorthandCss, shorthandCssDom };
+//# sourceMappingURL=shorthandCss.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shorthandCss.d.ts","names":[],"sources":["../../src/transformers/shorthandCss.ts"],"mappings":";;;;;AASA;UAAiB,mBAAA;;;;AAgCjB;;;EAzBE,IAAA;AAAA;;;;;AAkCF;;;;;;;;;;;;;;;;;;iBATgB,YAAA,CAAa,IAAA,UAAc,OAAA,GAAS,mBAAA;;;;;;iBASpC,eAAA,CAAgB,GAAA,EAAK,SAAA,IAAa,OAAA,GAAS,mBAAA,GAA2B,SAAA"}

package/dist/transformers/shorthandCss.js

@@ -0,0 +1,61 @@
+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 postcss from "postcss";
+import safeParser from "postcss-safe-parser";
+import mergeLonghand from "postcss-merge-longhand";
+//#region src/transformers/shorthandCss.ts
+/**
+* Rewrite longhand CSS inside inline `style` attributes with shorthand
+* syntax. Works with margin, padding, and border when all sides are
+* specified.
+*
+* For example:
+* `margin-left: 2px; margin-right: 2px; margin-top: 4px; margin-bottom: 4px`
+* becomes:
+* `margin: 4px 2px`
+*
+* @param html    HTML string to transform.
+* @param options Optional Maizzle options (`tags`).
+* @returns       The transformed HTML string.
+*
+* @example
+* import { shorthandCss } from '@maizzle/framework'
+*
+* const out = shorthandCss(
+*   '<p style="margin-top: 4px; margin-right: 2px; margin-bottom: 4px; margin-left: 2px;">x</p>',
+*   { tags: ['p'] },
+* )
+*/
+function shorthandCss(html, options = {}) {
+	return serialize(shorthandCssDom(parse(html), options));
+}
+/**
+* DOM-form of {@link shorthandCss} 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 shorthandCssDom(dom, options = {}) {
+	const allowedTags = options.tags ?? [];
+	const hasTagFilter = allowedTags.length > 0;
+	walk(dom, (node) => {
+		const el = node;
+		if (!el.attribs?.style) return;
+		if (hasTagFilter && !allowedTags.includes(el.name)) return;
+		const styleValue = el.attribs.style;
+		try {
+			const { css } = postcss().use(mergeLonghand).process(`div { ${styleValue} }`, { parser: safeParser });
+			const match = css.match(/div\s*\{\s*([^}]+)\s*\}/);
+			if (match && match[1]) {
+				const newStyle = match[1].trim();
+				if (newStyle !== styleValue) el.attribs.style = newStyle;
+			}
+		} catch {}
+	});
+	return dom;
+}
+//#endregion
+export { shorthandCss, shorthandCssDom };
+
+//# sourceMappingURL=shorthandCss.js.map

package/dist/transformers/shorthandCss.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shorthandCss.js","names":[],"sources":["../../src/transformers/shorthandCss.ts"],"sourcesContent":["import postcss from 'postcss'\nimport safeParser from 'postcss-safe-parser'\nimport mergeLonghand from 'postcss-merge-longhand'\nimport type { ChildNode, Element } from 'domhandler'\nimport { parse, serialize, walk } from '../utils/ast/index.ts'\n\n/**\n * Options for the `shorthandCss` transformer.\n */\nexport interface ShorthandCssOptions {\n  /**\n   * Restrict the transform to a list of HTML tag names. Omit to apply to\n   * every element with a `style` attribute.\n   *\n   * @example ['td', 'div']\n   */\n  tags?: string[]\n}\n\n/**\n * Rewrite longhand CSS inside inline `style` attributes with shorthand\n * syntax. Works with margin, padding, and border when all sides are\n * specified.\n *\n * For example:\n * `margin-left: 2px; margin-right: 2px; margin-top: 4px; margin-bottom: 4px`\n * becomes:\n * `margin: 4px 2px`\n *\n * @param html    HTML string to transform.\n * @param options Optional Maizzle options (`tags`).\n * @returns       The transformed HTML string.\n *\n * @example\n * import { shorthandCss } from '@maizzle/framework'\n *\n * const out = shorthandCss(\n *   '<p style=\"margin-top: 4px; margin-right: 2px; margin-bottom: 4px; margin-left: 2px;\">x</p>',\n *   { tags: ['p'] },\n * )\n */\nexport function shorthandCss(html: string, options: ShorthandCssOptions = {}): string {\n  return serialize(shorthandCssDom(parse(html), options))\n}\n\n/**\n * DOM-form of {@link shorthandCss} used by the internal transformer\n * pipeline. Takes a parsed DOM, returns a parsed DOM — avoids redundant\n * serialize/parse round-trips when chained with other transformers.\n */\nexport function shorthandCssDom(dom: ChildNode[], options: ShorthandCssOptions = {}): ChildNode[] {\n  const allowedTags = options.tags ?? []\n  const hasTagFilter = allowedTags.length > 0\n\n  walk(dom, (node) => {\n    const el = node as Element\n\n    // Skip if no attribs or no style\n    if (!el.attribs?.style) {\n      return\n    }\n\n    // Skip if tag filter is active and this tag is not allowed\n    if (hasTagFilter && !allowedTags.includes(el.name)) {\n      return\n    }\n\n    const styleValue = el.attribs.style\n\n    try {\n      // Process the style with postcss-merge-longhand\n      // Wrap in a dummy selector since postcss needs a rule\n      const { css } = postcss()\n        .use(mergeLonghand)\n        .process(`div { ${styleValue} }`, { parser: safeParser })\n\n      // Extract the content between the braces\n      const match = css.match(/div\\s*\\{\\s*([^}]+)\\s*\\}/)\n      if (match && match[1]) {\n        const newStyle = match[1].trim()\n        if (newStyle !== styleValue) {\n          el.attribs.style = newStyle\n        }\n      }\n    } catch {\n      // If processing fails, keep the original style\n    }\n  })\n\n  return dom\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,aAAa,MAAc,UAA+B,EAAE,EAAU;CACpF,OAAO,UAAU,gBAAgB,MAAM,KAAK,EAAE,QAAQ,CAAC;;;;;;;AAQzD,SAAgB,gBAAgB,KAAkB,UAA+B,EAAE,EAAe;CAChG,MAAM,cAAc,QAAQ,QAAQ,EAAE;CACtC,MAAM,eAAe,YAAY,SAAS;CAE1C,KAAK,MAAM,SAAS;EAClB,MAAM,KAAK;EAGX,IAAI,CAAC,GAAG,SAAS,OACf;EAIF,IAAI,gBAAgB,CAAC,YAAY,SAAS,GAAG,KAAK,EAChD;EAGF,MAAM,aAAa,GAAG,QAAQ;EAE9B,IAAI;GAGF,MAAM,EAAE,QAAQ,SAAS,CACtB,IAAI,cAAc,CAClB,QAAQ,SAAS,WAAW,KAAK,EAAE,QAAQ,YAAY,CAAC;GAG3D,MAAM,QAAQ,IAAI,MAAM,0BAA0B;GAClD,IAAI,SAAS,MAAM,IAAI;IACrB,MAAM,WAAW,MAAM,GAAG,MAAM;IAChC,IAAI,aAAa,YACf,GAAG,QAAQ,QAAQ;;UAGjB;GAGR;CAEF,OAAO"}

package/dist/transformers/sixHex.d.ts

@@ -1,16 +1,25 @@
-import { CssConfig } from "../types/config.js";
 import { ChildNode } from "domhandler";
 
 //#region src/transformers/sixHex.d.ts
 /**
- * Six-digit HEX transformer.
- *
- * Converts 3-digit HEX color codes to 6-digit in `bgcolor` and `color`
+ * Convert 3-digit HEX color codes to 6-digit in `bgcolor` and `color`
  * attributes, for better email client compatibility.
  *
- * Enabled by default via `css.sixHex`.
+ * @param html HTML string to transform.
+ * @returns    The transformed HTML string.
+ *
+ * @example
+ * import { sixHex } from '@maizzle/framework'
+ *
+ * const out = sixHex('<font color="#abc">x</font>')
+ */
+declare function sixHex(html: string): string;
+/**
+ * DOM-form of {@link sixHex} 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 sixHex(dom: ChildNode[], config?: CssConfig): ChildNode[];
+declare function sixHexDom(dom: ChildNode[]): ChildNode[];
 //#endregion
-export { sixHex };
+export { sixHex, sixHexDom };
 //# sourceMappingURL=sixHex.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sixHex.d.ts","names":[],"sources":["../../src/transformers/sixHex.ts"],"mappings":";;;;;;AAeA;;;;;;iBAAgB,MAAA,CAAO,GAAA,EAAK,SAAA,IAAa,MAAA,GAAQ,SAAA,GAAiB,SAAA"}
+{"version":3,"file":"sixHex.d.ts","names":[],"sources":["../../src/transformers/sixHex.ts"],"mappings":";;;;;AAkBA;;;;;AASA;;;;;iBATgB,MAAA,CAAO,IAAA;;;;;;iBASP,SAAA,CAAU,GAAA,EAAK,SAAA,KAAc,SAAA"}

package/dist/transformers/sixHex.js

@@ -0,0 +1,42 @@
+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 { conv } from "color-shorthand-hex-to-six-digit";
+//#region src/transformers/sixHex.ts
+const targets = new Set(["bgcolor", "color"]);
+/**
+* Convert 3-digit HEX color codes to 6-digit in `bgcolor` and `color`
+* attributes, for better email client compatibility.
+*
+* @param html HTML string to transform.
+* @returns    The transformed HTML string.
+*
+* @example
+* import { sixHex } from '@maizzle/framework'
+*
+* const out = sixHex('<font color="#abc">x</font>')
+*/
+function sixHex(html) {
+	return serialize(sixHexDom(parse(html)));
+}
+/**
+* DOM-form of {@link sixHex} 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 sixHexDom(dom) {
+	walk(dom, (node) => {
+		const el = node;
+		if (!el.attribs) return;
+		for (const attr of targets) {
+			const value = el.attribs[attr];
+			if (value) el.attribs[attr] = conv(value);
+		}
+	});
+	return dom;
+}
+//#endregion
+export { sixHex, sixHexDom };
+
+//# sourceMappingURL=sixHex.js.map

package/dist/transformers/sixHex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sixHex.js","names":[],"sources":["../../src/transformers/sixHex.ts"],"sourcesContent":["import { conv } from 'color-shorthand-hex-to-six-digit'\nimport type { ChildNode, Element } from 'domhandler'\nimport { parse, serialize, walk } from '../utils/ast/index.ts'\n\nconst targets = new Set(['bgcolor', 'color'])\n\n/**\n * Convert 3-digit HEX color codes to 6-digit in `bgcolor` and `color`\n * attributes, for better email client compatibility.\n *\n * @param html HTML string to transform.\n * @returns    The transformed HTML string.\n *\n * @example\n * import { sixHex } from '@maizzle/framework'\n *\n * const out = sixHex('<font color=\"#abc\">x</font>')\n */\nexport function sixHex(html: string): string {\n  return serialize(sixHexDom(parse(html)))\n}\n\n/**\n * DOM-form of {@link sixHex} 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 sixHexDom(dom: ChildNode[]): ChildNode[] {\n  walk(dom, (node) => {\n    const el = node as Element\n\n    if (!el.attribs) {\n      return\n    }\n\n    for (const attr of targets) {\n      const value = el.attribs[attr]\n\n      if (value) {\n        el.attribs[attr] = conv(value)\n      }\n    }\n  })\n\n  return dom\n}\n"],"mappings":";;;;;;AAIA,MAAM,UAAU,IAAI,IAAI,CAAC,WAAW,QAAQ,CAAC;;;;;;;;;;;;;AAc7C,SAAgB,OAAO,MAAsB;CAC3C,OAAO,UAAU,UAAU,MAAM,KAAK,CAAC,CAAC;;;;;;;AAQ1C,SAAgB,UAAU,KAA+B;CACvD,KAAK,MAAM,SAAS;EAClB,MAAM,KAAK;EAEX,IAAI,CAAC,GAAG,SACN;EAGF,KAAK,MAAM,QAAQ,SAAS;GAC1B,MAAM,QAAQ,GAAG,QAAQ;GAEzB,IAAI,OACF,GAAG,QAAQ,QAAQ,KAAK,MAAM;;GAGlC;CAEF,OAAO"}

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

@@ -1,8 +1,7 @@
-import { walk } from "../utils/ast/walker.mjs";
-import "../utils/ast/index.mjs";
-import { compileTailwindCss } from "../utils/compileTailwindCss.mjs";
+import { walk } from "../utils/ast/walker.js";
+import "../utils/ast/index.js";
+import { compileTailwindCss } from "../utils/compileTailwindCss.js";
 import { resolve } from "node:path";
-
 //#region src/transformers/tailwindComponent.ts
 const DEFAULT_SEED = "@import \"@maizzle/tailwindcss\";";
 const OPEN_RE = /^mz-tw:(\S+)$/;
@@ -87,7 +86,7 @@ function buildCssInput(configCss, classes) {
 	if (!classes.size) return seed;
 	return `${seed}\n@source inline("${[...classes].join(" ").replace(/"/g, "\\\"")}");`;
 }
-
 //#endregion
 export { tailwindComponent };
-//# sourceMappingURL=tailwindComponent.mjs.map
+
+//# sourceMappingURL=tailwindComponent.js.map

package/dist/transformers/tailwindComponent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tailwindComponent.js","names":[],"sources":["../../src/transformers/tailwindComponent.ts"],"sourcesContent":["import { resolve } from 'node:path'\nimport type { ChildNode, Element, Comment } from 'domhandler'\nimport { walk } from '../utils/ast/index.ts'\nimport { compileTailwindCss } from '../utils/compileTailwindCss.ts'\nimport type { TailwindBlock } from '../composables/renderContext.ts'\nimport type { MaizzleConfig } from '../types/config.ts'\n\nconst DEFAULT_SEED = '@import \"@maizzle/tailwindcss\";'\n\ninterface BlockMeta {\n  id: string\n  configCss?: string\n  nested: boolean\n  classes: Set<string>\n}\n\nconst OPEN_RE = /^mz-tw:(\\S+)$/\nconst CLOSE_RE = /^\\/mz-tw:(\\S+)$/\n\n/**\n * Compile Tailwind CSS for each top-level <Tailwind> block in the render\n * context. Nested <Tailwind> instances are flattened: their classes flow\n * up to the outermost block, their `#config` slot (if any) is ignored.\n * One <style> per outermost block is appended to <head>; marker comments\n * are stripped after.\n */\nexport async function tailwindComponent(\n  dom: ChildNode[],\n  blocks: TailwindBlock[],\n  config: MaizzleConfig,\n  filePath?: string,\n): Promise<ChildNode[]> {\n  if (!blocks.length) return dom\n\n  const map = new Map<string, BlockMeta>()\n  for (const b of blocks) {\n    map.set(b.id, { id: b.id, configCss: b.css, nested: false, classes: new Set() })\n  }\n\n  const stack: string[] = []\n  const markers: Comment[] = []\n\n  walk(dom, (node) => {\n    if (node.type === 'comment') {\n      const data = (node as Comment).data\n      const open = data.match(OPEN_RE)\n      const close = data.match(CLOSE_RE)\n      if (open) {\n        const id = open[1]\n        const meta = map.get(id)\n        if (meta && stack.length > 0) meta.nested = true\n        if (meta) stack.push(id)\n        markers.push(node as Comment)\n      } else if (close) {\n        const id = close[1]\n        if (stack[stack.length - 1] === id) stack.pop()\n        markers.push(node as Comment)\n      }\n      return\n    }\n\n    const el = node as Element\n    // Always assign to the OUTERMOST active marker (stack[0]) so nested\n    // <Tailwind> blocks merge their classes into the parent's scope.\n    if (el.attribs?.class && stack.length > 0) {\n      map.get(stack[0])!.classes.add(el.attribs.class)\n    }\n  })\n\n  const fromPath = filePath ?? resolve(process.cwd(), 'template.vue')\n\n  let head: Element | undefined\n  walk(dom, (n) => {\n    if (!head && (n as Element).name === 'head') head = n as Element\n  })\n\n  if (!head) {\n    throw new Error('`Tailwind` component requires `Head` component to be present in the template.')\n  }\n\n  // Compile + inject one <style raw> per outermost block. `raw` opts the\n  // existing tailwindcss transformer out of recompiling already-compiled CSS.\n  for (const meta of map.values()) {\n    if (meta.nested) continue\n\n    const cssInput = buildCssInput(meta.configCss, meta.classes)\n    const css = (await compileTailwindCss(cssInput, config, `${fromPath}?tw=${meta.id}`)).trim()\n    if (!css) continue\n\n    const styleNode: Element = {\n      type: 'tag',\n      name: 'style',\n      attribs: { raw: '' },\n      children: [],\n      parent: head,\n      prev: null,\n      next: null,\n    } as any\n\n    const textNode = {\n      type: 'text',\n      data: css,\n      parent: styleNode,\n      prev: null,\n      next: null,\n    } as any\n\n    styleNode.children = [textNode]\n    head.children.push(styleNode)\n  }\n\n  // Strip marker comments from their parents\n  for (const c of markers) {\n    const parent = c.parent as Element | null\n    if (!parent?.children) continue\n    const i = parent.children.indexOf(c)\n    if (i >= 0) parent.children.splice(i, 1)\n  }\n\n  return dom\n}\n\nfunction buildCssInput(configCss: string | undefined, classes: Set<string>): string {\n  const seed = configCss ?? DEFAULT_SEED\n\n  if (!classes.size) return seed\n\n  const inline = [...classes].join(' ').replace(/\"/g, '\\\\\"')\n  return `${seed}\\n@source inline(\"${inline}\");`\n}\n"],"mappings":";;;;;AAOA,MAAM,eAAe;AASrB,MAAM,UAAU;AAChB,MAAM,WAAW;;;;;;;;AASjB,eAAsB,kBACpB,KACA,QACA,QACA,UACsB;CACtB,IAAI,CAAC,OAAO,QAAQ,OAAO;CAE3B,MAAM,sBAAM,IAAI,KAAwB;CACxC,KAAK,MAAM,KAAK,QACd,IAAI,IAAI,EAAE,IAAI;EAAE,IAAI,EAAE;EAAI,WAAW,EAAE;EAAK,QAAQ;EAAO,yBAAS,IAAI,KAAK;EAAE,CAAC;CAGlF,MAAM,QAAkB,EAAE;CAC1B,MAAM,UAAqB,EAAE;CAE7B,KAAK,MAAM,SAAS;EAClB,IAAI,KAAK,SAAS,WAAW;GAC3B,MAAM,OAAQ,KAAiB;GAC/B,MAAM,OAAO,KAAK,MAAM,QAAQ;GAChC,MAAM,QAAQ,KAAK,MAAM,SAAS;GAClC,IAAI,MAAM;IACR,MAAM,KAAK,KAAK;IAChB,MAAM,OAAO,IAAI,IAAI,GAAG;IACxB,IAAI,QAAQ,MAAM,SAAS,GAAG,KAAK,SAAS;IAC5C,IAAI,MAAM,MAAM,KAAK,GAAG;IACxB,QAAQ,KAAK,KAAgB;UACxB,IAAI,OAAO;IAChB,MAAM,KAAK,MAAM;IACjB,IAAI,MAAM,MAAM,SAAS,OAAO,IAAI,MAAM,KAAK;IAC/C,QAAQ,KAAK,KAAgB;;GAE/B;;EAGF,MAAM,KAAK;EAGX,IAAI,GAAG,SAAS,SAAS,MAAM,SAAS,GACtC,IAAI,IAAI,MAAM,GAAG,CAAE,QAAQ,IAAI,GAAG,QAAQ,MAAM;GAElD;CAEF,MAAM,WAAW,YAAY,QAAQ,QAAQ,KAAK,EAAE,eAAe;CAEnE,IAAI;CACJ,KAAK,MAAM,MAAM;EACf,IAAI,CAAC,QAAS,EAAc,SAAS,QAAQ,OAAO;GACpD;CAEF,IAAI,CAAC,MACH,MAAM,IAAI,MAAM,gFAAgF;CAKlG,KAAK,MAAM,QAAQ,IAAI,QAAQ,EAAE;EAC/B,IAAI,KAAK,QAAQ;EAGjB,MAAM,OAAO,MAAM,mBADF,cAAc,KAAK,WAAW,KAAK,QACN,EAAE,QAAQ,GAAG,SAAS,MAAM,KAAK,KAAK,EAAE,MAAM;EAC5F,IAAI,CAAC,KAAK;EAEV,MAAM,YAAqB;GACzB,MAAM;GACN,MAAM;GACN,SAAS,EAAE,KAAK,IAAI;GACpB,UAAU,EAAE;GACZ,QAAQ;GACR,MAAM;GACN,MAAM;GACP;EAUD,UAAU,WAAW,CAAC;GAPpB,MAAM;GACN,MAAM;GACN,QAAQ;GACR,MAAM;GACN,MAAM;GAGsB,CAAC;EAC/B,KAAK,SAAS,KAAK,UAAU;;CAI/B,KAAK,MAAM,KAAK,SAAS;EACvB,MAAM,SAAS,EAAE;EACjB,IAAI,CAAC,QAAQ,UAAU;EACvB,MAAM,IAAI,OAAO,SAAS,QAAQ,EAAE;EACpC,IAAI,KAAK,GAAG,OAAO,SAAS,OAAO,GAAG,EAAE;;CAG1C,OAAO;;AAGT,SAAS,cAAc,WAA+B,SAA8B;CAClF,MAAM,OAAO,aAAa;CAE1B,IAAI,CAAC,QAAQ,MAAM,OAAO;CAG1B,OAAO,GAAG,KAAK,oBADA,CAAC,GAAG,QAAQ,CAAC,KAAK,IAAI,CAAC,QAAQ,MAAM,OACX,CAAC"}

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

@@ -1,9 +1,8 @@
-import { walk } from "../utils/ast/walker.mjs";
-import "../utils/ast/index.mjs";
-import { compileTailwindCss } from "../utils/compileTailwindCss.mjs";
-import { decodeStyleEntities } from "../utils/decodeStyleEntities.mjs";
+import { walk } from "../utils/ast/walker.js";
+import "../utils/ast/index.js";
+import { compileTailwindCss } from "../utils/compileTailwindCss.js";
+import { decodeStyleEntities } from "../utils/decodeStyleEntities.js";
 import { dirname, relative, resolve } from "node:path";
-
 //#region src/transformers/tailwindcss.ts
 /**
 * Check if CSS content uses Tailwind features that require source scanning.
@@ -92,7 +91,7 @@ async function tailwindcss(dom, config, filePath) {
 	}
 	return dom;
 }
-
 //#endregion
 export { tailwindcss };
-//# sourceMappingURL=tailwindcss.mjs.map
+
+//# sourceMappingURL=tailwindcss.js.map

package/dist/transformers/tailwindcss.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tailwindcss.js","names":[],"sources":["../../src/transformers/tailwindcss.ts"],"sourcesContent":["import { resolve, dirname, relative } from 'node:path'\nimport type { ChildNode, Element } from 'domhandler'\nimport { walk } from '../utils/ast/index.ts'\nimport { decodeStyleEntities } from '../utils/decodeStyleEntities.ts'\nimport { compileTailwindCss } from '../utils/compileTailwindCss.ts'\nimport type { MaizzleConfig } from '../types/config.ts'\n\n/**\n * Check if CSS content uses Tailwind features that require source scanning.\n *\n * Only CSS that imports Tailwind (or @maizzle/tailwindcss) needs @source\n * directives. Plain CSS without Tailwind imports doesn't need scanning\n * and would pass through @source directives unconsumed.\n */\nfunction usesTailwind(css: string): boolean {\n  return /((@import|@reference)\\s+[\"'](tailwindcss|@maizzle\\/tailwindcss)|@tailwind\\s)/.test(css)\n}\n\n/**\n * Build @source directives for Tailwind CSS scanning.\n *\n * Configures two types of sources:\n * 1. Exclusions for output dir and user-configured paths\n * 2. Inline source with all class attribute values from the rendered DOM,\n *    capturing classes from all components (built-in + user), dynamic\n *    expressions, and the template itself — Tailwind's scanner handles\n *    the actual class extraction from these raw values\n */\nfunction buildSourceDirectives(dom: ChildNode[], config: MaizzleConfig, fromDir: string): string {\n  const directives: string[] = []\n\n  // Exclude output dir and user-configured paths\n  const excludePaths = [\n    resolve(config.output?.path ?? 'dist'),\n    ...(config.css?.exclude ?? []).map(p => resolve(p)),\n  ]\n\n  for (const p of excludePaths) {\n    directives.push(`@source not \"${relative(fromDir, resolve(p))}\";`)\n  }\n\n  // Inline source: collect all class attribute values from the rendered DOM.\n  // After Vue SSR, the DOM contains every class from every component\n  // (built-in framework components, user components, dynamic bindings).\n  // We pass these raw values to Tailwind's scanner via @source inline().\n  const classes: string[] = []\n  walk(dom, (n) => {\n    const cls = (n as Element).attribs?.class\n    if (cls) classes.push(cls)\n  })\n\n  if (classes.length) {\n    directives.push(`@source inline(\"${classes.join(' ')}\");`)\n  }\n\n  return directives.join('\\n')\n}\n\n/**\n * Tailwind CSS transformer.\n *\n * Compiles CSS inside <style> tags in the DOM using\n * @tailwindcss/postcss, then lowers modern CSS syntax with lightningcss.\n *\n * Configures Tailwind sources to scan:\n * - Rendered class attributes (via `@source inline`) for all classes from all components\n * - User project files (via Tailwind's auto-detection from base/from path)\n *\n * User `@source` and `@source not directives` in style tags are preserved.\n * Source directives are only added to style tags that import Tailwind.\n *\n * Runs as the first transformer in the pipeline so that subsequent\n * transformers (inliner, purge, etc.) work with fully compiled CSS.\n */\nexport async function tailwindcss(dom: ChildNode[], config: MaizzleConfig, filePath?: string): Promise<ChildNode[]> {\n  const styleTags: { node: Element; cssContent: string }[] = []\n\n  walk(dom, (node) => {\n    if ((node as Element).name !== 'style') return\n\n    const el = node as Element\n    const attrs = el.attribs || {}\n\n    // `raw` opts out of compilation entirely (marker is consumed here).\n    // `embed`/`data-embed` only signal \"preserve tag after inlining\" — they\n    // still need to go through compile so Tailwind/@apply resolves.\n    if ('raw' in attrs) {\n      delete el.attribs.raw\n      return\n    }\n\n    // Get text content from children and decode HTML entities\n    const rawContent = el.children\n      .filter(child => child.type === 'text')\n      .map(child => (child as any).data)\n      .join('')\n\n    if (!rawContent.trim()) return\n\n    styleTags.push({ node: el, cssContent: decodeStyleEntities(rawContent) })\n  })\n\n  if (!styleTags.length) return dom\n\n  const fromPath = filePath ?? resolve(process.cwd(), 'template.vue')\n  const fromDir = dirname(fromPath)\n\n  // Only compute source directives if at least one style tag uses Tailwind\n  const hasTailwindStyles = styleTags.some(({ cssContent }) => usesTailwind(cssContent))\n  const sourceDirectives = hasTailwindStyles\n    ? buildSourceDirectives(dom, config, fromDir)\n    : ''\n\n  for (let i = 0; i < styleTags.length; i++) {\n    const { node, cssContent } = styleTags[i]\n\n    // Only add source directives to style tags that import Tailwind —\n    // plain CSS doesn't need them and @tailwindcss/postcss would leave\n    // the directives unconsumed in the output\n    const fullCss = usesTailwind(cssContent)\n      ? `${cssContent}\\n${sourceDirectives}`\n      : cssContent\n\n    try {\n      const optimized = await compileTailwindCss(fullCss, config, `${fromPath}?style=${i}`)\n\n      // Replace the style tag's children with the compiled CSS\n      node.children = [{\n        type: 'text',\n        data: optimized,\n        parent: node,\n      } as any]\n    } catch {\n      // If CSS processing fails, still replace with decoded content\n      // so HTML entities don't break the CSS\n      node.children = [{\n        type: 'text',\n        data: cssContent,\n        parent: node,\n      } as any]\n    }\n  }\n\n  return dom\n}\n"],"mappings":";;;;;;;;;;;;;AAcA,SAAS,aAAa,KAAsB;CAC1C,OAAO,+EAA+E,KAAK,IAAI;;;;;;;;;;;;AAajG,SAAS,sBAAsB,KAAkB,QAAuB,SAAyB;CAC/F,MAAM,aAAuB,EAAE;CAG/B,MAAM,eAAe,CACnB,QAAQ,OAAO,QAAQ,QAAQ,OAAO,EACtC,IAAI,OAAO,KAAK,WAAW,EAAE,EAAE,KAAI,MAAK,QAAQ,EAAE,CAAC,CACpD;CAED,KAAK,MAAM,KAAK,cACd,WAAW,KAAK,gBAAgB,SAAS,SAAS,QAAQ,EAAE,CAAC,CAAC,IAAI;CAOpE,MAAM,UAAoB,EAAE;CAC5B,KAAK,MAAM,MAAM;EACf,MAAM,MAAO,EAAc,SAAS;EACpC,IAAI,KAAK,QAAQ,KAAK,IAAI;GAC1B;CAEF,IAAI,QAAQ,QACV,WAAW,KAAK,mBAAmB,QAAQ,KAAK,IAAI,CAAC,KAAK;CAG5D,OAAO,WAAW,KAAK,KAAK;;;;;;;;;;;;;;;;;;AAmB9B,eAAsB,YAAY,KAAkB,QAAuB,UAAyC;CAClH,MAAM,YAAqD,EAAE;CAE7D,KAAK,MAAM,SAAS;EAClB,IAAK,KAAiB,SAAS,SAAS;EAExC,MAAM,KAAK;EAMX,IAAI,UALU,GAAG,WAAW,EAAE,GAKV;GAClB,OAAO,GAAG,QAAQ;GAClB;;EAIF,MAAM,aAAa,GAAG,SACnB,QAAO,UAAS,MAAM,SAAS,OAAO,CACtC,KAAI,UAAU,MAAc,KAAK,CACjC,KAAK,GAAG;EAEX,IAAI,CAAC,WAAW,MAAM,EAAE;EAExB,UAAU,KAAK;GAAE,MAAM;GAAI,YAAY,oBAAoB,WAAW;GAAE,CAAC;GACzE;CAEF,IAAI,CAAC,UAAU,QAAQ,OAAO;CAE9B,MAAM,WAAW,YAAY,QAAQ,QAAQ,KAAK,EAAE,eAAe;CACnE,MAAM,UAAU,QAAQ,SAAS;CAIjC,MAAM,mBADoB,UAAU,MAAM,EAAE,iBAAiB,aAAa,WAAW,CAC3C,GACtC,sBAAsB,KAAK,QAAQ,QAAQ,GAC3C;CAEJ,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;EACzC,MAAM,EAAE,MAAM,eAAe,UAAU;EAKvC,MAAM,UAAU,aAAa,WAAW,GACpC,GAAG,WAAW,IAAI,qBAClB;EAEJ,IAAI;GAIF,KAAK,WAAW,CAAC;IACf,MAAM;IACN,MAAM,MALgB,mBAAmB,SAAS,QAAQ,GAAG,SAAS,SAAS,IAAI;IAMnF,QAAQ;IACT,CAAQ;UACH;GAGN,KAAK,WAAW,CAAC;IACf,MAAM;IACN,MAAM;IACN,QAAQ;IACT,CAAQ;;;CAIb,OAAO"}

package/dist/transformers/urlQuery.d.ts

@@ -1,24 +1,36 @@
-import { UrlConfig } from "../types/config.js";
+import { UrlQueryOptions } from "../types/config.js";
 import { ChildNode } from "domhandler";
 
 //#region src/transformers/urlQuery.d.ts
 /**
- * URL query transformer.
+ * Append query parameters to URLs found in matching attributes/elements.
  *
- * Appends query parameters to URLs found in specified attributes of
- * specified HTML tags.
+ * @param html    HTML string to transform.
+ * @param params  Query parameters to append (e.g. `{ utm_source: 'newsletter' }`).
+ * @param options Behaviour overrides — `tags` (CSS selectors, default `['a']`),
+ *                `attributes` (default `['src', 'href', 'poster', 'srcset', 'background']`),
+ *                `strict` (default `true`, only rewrites absolute URLs),
+ *                `qs` (forwarded to `query-string`, default `{ encode: false }`).
+ * @returns       The transformed HTML string.
  *
- * Reads config from the `config.url` object in `MaizzleConfig` (pass
- * `config.url` directly when calling as a standalone transformer).
- * The `_options` key inside `query` controls behaviour:
- * - `tags`       — CSS selectors for elements to process. Default: `['a']`
- * - `attributes` — attribute names to process. Default: `['src', 'href', 'poster', 'srcset', 'background']`
- * - `strict`     — only append to absolute URLs. Default: `true`
- * - `qs`         — options forwarded to query-string. Default: `{ encode: false }`
+ * @example
+ * import { urlQuery } from '@maizzle/framework'
  *
- * All non-`_options` keys inside `query` are treated as URL parameters to append.
+ * const out = urlQuery(
+ *   '<a href="https://example.com">x</a>',
+ *   { utm_source: 'newsletter' },
+ * )
+ *
+ * // Restrict to specific tags / attributes:
+ * urlQuery(html, { ref: 'email' }, { tags: ['a', 'img'], attributes: ['href', 'src'] })
+ */
+declare function urlQuery(html: string, params?: Record<string, unknown>, options?: UrlQueryOptions): string;
+/**
+ * DOM-form of {@link urlQuery} 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 urlQuery(dom: ChildNode[], config?: UrlConfig): ChildNode[];
+declare function urlQueryDom(dom: ChildNode[], params?: Record<string, unknown>, options?: UrlQueryOptions): ChildNode[];
 //#endregion
-export { urlQuery };
+export { urlQuery, urlQueryDom };
 //# sourceMappingURL=urlQuery.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"urlQuery.d.ts","names":[],"sources":["../../src/transformers/urlQuery.ts"],"mappings":";;;;;;AA0CA;;;;;;;;;;;;;;iBAAgB,QAAA,CAAS,GAAA,EAAK,SAAA,IAAa,MAAA,GAAQ,SAAA,GAAiB,SAAA"}
+{"version":3,"file":"urlQuery.d.ts","names":[],"sources":["../../src/transformers/urlQuery.ts"],"mappings":";;;;;;AAiDA;;;;;;;;;;;AAaA;;;;;;;;;iBAbgB,QAAA,CACd,IAAA,UACA,MAAA,GAAQ,MAAA,mBACR,OAAA,GAAS,eAAA;;;;;;iBAUK,WAAA,CACd,GAAA,EAAK,SAAA,IACL,MAAA,GAAQ,MAAA,mBACR,OAAA,GAAS,eAAA,GACR,SAAA"}

package/dist/transformers/urlQuery.js

@@ -0,0 +1,77 @@
+import { parse } from "../utils/ast/parser.js";
+import { serialize } from "../utils/ast/serializer.js";
+import "../utils/ast/index.js";
+import { isAbsoluteUrl } from "../utils/url.js";
+import queryString from "query-string";
+import { selectAll } from "css-select";
+//#region src/transformers/urlQuery.ts
+const DEFAULT_ATTRIBUTES = [
+	"src",
+	"href",
+	"poster",
+	"srcset",
+	"background"
+];
+const DEFAULT_TAGS = ["a"];
+/**
+* Append query parameters to a URL string using query-string.
+*/
+function appendParams(url, params, qsOptions, strict) {
+	if (strict && !isAbsoluteUrl(url)) return url;
+	return queryString.stringifyUrl({
+		url,
+		query: params
+	}, qsOptions);
+}
+/**
+* Append query parameters to URLs found in matching attributes/elements.
+*
+* @param html    HTML string to transform.
+* @param params  Query parameters to append (e.g. `{ utm_source: 'newsletter' }`).
+* @param options Behaviour overrides — `tags` (CSS selectors, default `['a']`),
+*                `attributes` (default `['src', 'href', 'poster', 'srcset', 'background']`),
+*                `strict` (default `true`, only rewrites absolute URLs),
+*                `qs` (forwarded to `query-string`, default `{ encode: false }`).
+* @returns       The transformed HTML string.
+*
+* @example
+* import { urlQuery } from '@maizzle/framework'
+*
+* const out = urlQuery(
+*   '<a href="https://example.com">x</a>',
+*   { utm_source: 'newsletter' },
+* )
+*
+* // Restrict to specific tags / attributes:
+* urlQuery(html, { ref: 'email' }, { tags: ['a', 'img'], attributes: ['href', 'src'] })
+*/
+function urlQuery(html, params = {}, options = {}) {
+	return serialize(urlQueryDom(parse(html), params, options));
+}
+/**
+* DOM-form of {@link urlQuery} 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 urlQueryDom(dom, params = {}, options = {}) {
+	if (!params || Object.keys(params).length === 0) return dom;
+	const tags = options.tags ?? DEFAULT_TAGS;
+	const attributes = options.attributes ?? DEFAULT_ATTRIBUTES;
+	const strict = options.strict ?? true;
+	const qsOptions = {
+		encode: false,
+		...options.qs ?? {}
+	};
+	const elements = selectAll(tags.join(", "), dom);
+	for (const el of elements) for (const attr of attributes) {
+		const value = el.attribs[attr];
+		if (!value) continue;
+		const updated = appendParams(value, params, qsOptions, strict);
+		if (updated !== value) el.attribs[attr] = updated;
+	}
+	return dom;
+}
+//#endregion
+export { urlQuery, urlQueryDom };
+
+//# sourceMappingURL=urlQuery.js.map

package/dist/transformers/urlQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"urlQuery.js","names":[],"sources":["../../src/transformers/urlQuery.ts"],"sourcesContent":["import queryString from 'query-string'\nimport { selectAll } from 'css-select'\nimport type { ChildNode, Element } from 'domhandler'\nimport { parse, serialize } from '../utils/ast/index.ts'\nimport { isAbsoluteUrl } from '../utils/url.ts'\nimport type { UrlQueryOptions } from '../types/config.ts'\n\nconst DEFAULT_ATTRIBUTES = ['src', 'href', 'poster', 'srcset', 'background']\nconst DEFAULT_TAGS = ['a']\n\n/**\n * Append query parameters to a URL string using query-string.\n */\nfunction appendParams(\n  url: string,\n  params: Record<string, unknown>,\n  qsOptions: queryString.StringifyOptions,\n  strict: boolean,\n): string {\n  if (strict && !isAbsoluteUrl(url)) return url\n\n  return queryString.stringifyUrl(\n    { url, query: params as queryString.StringifiableRecord },\n    qsOptions,\n  )\n}\n\n/**\n * Append query parameters to URLs found in matching attributes/elements.\n *\n * @param html    HTML string to transform.\n * @param params  Query parameters to append (e.g. `{ utm_source: 'newsletter' }`).\n * @param options Behaviour overrides — `tags` (CSS selectors, default `['a']`),\n *                `attributes` (default `['src', 'href', 'poster', 'srcset', 'background']`),\n *                `strict` (default `true`, only rewrites absolute URLs),\n *                `qs` (forwarded to `query-string`, default `{ encode: false }`).\n * @returns       The transformed HTML string.\n *\n * @example\n * import { urlQuery } from '@maizzle/framework'\n *\n * const out = urlQuery(\n *   '<a href=\"https://example.com\">x</a>',\n *   { utm_source: 'newsletter' },\n * )\n *\n * // Restrict to specific tags / attributes:\n * urlQuery(html, { ref: 'email' }, { tags: ['a', 'img'], attributes: ['href', 'src'] })\n */\nexport function urlQuery(\n  html: string,\n  params: Record<string, unknown> = {},\n  options: UrlQueryOptions = {},\n): string {\n  return serialize(urlQueryDom(parse(html), params, options))\n}\n\n/**\n * DOM-form of {@link urlQuery} 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 urlQueryDom(\n  dom: ChildNode[],\n  params: Record<string, unknown> = {},\n  options: UrlQueryOptions = {},\n): ChildNode[] {\n  if (!params || Object.keys(params).length === 0) return dom\n\n  const tags = options.tags ?? DEFAULT_TAGS\n  const attributes = options.attributes ?? DEFAULT_ATTRIBUTES\n  const strict = options.strict ?? true\n  const qsOptions: queryString.StringifyOptions = { encode: false, ...((options.qs ?? {}) as queryString.StringifyOptions) }\n\n  // Use css-select to find all elements matching any of the tag selectors\n  const selector = tags.join(', ')\n  const elements = selectAll(selector, dom) as Element[]\n\n  for (const el of elements) {\n    for (const attr of attributes) {\n      const value = el.attribs[attr]\n      if (!value) continue\n\n      const updated = appendParams(value, params, qsOptions, strict)\n      if (updated !== value) {\n        el.attribs[attr] = updated\n      }\n    }\n  }\n\n  return dom\n}\n"],"mappings":";;;;;;;AAOA,MAAM,qBAAqB;CAAC;CAAO;CAAQ;CAAU;CAAU;CAAa;AAC5E,MAAM,eAAe,CAAC,IAAI;;;;AAK1B,SAAS,aACP,KACA,QACA,WACA,QACQ;CACR,IAAI,UAAU,CAAC,cAAc,IAAI,EAAE,OAAO;CAE1C,OAAO,YAAY,aACjB;EAAE;EAAK,OAAO;EAA2C,EACzD,UACD;;;;;;;;;;;;;;;;;;;;;;;;AAyBH,SAAgB,SACd,MACA,SAAkC,EAAE,EACpC,UAA2B,EAAE,EACrB;CACR,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,QAAQ,QAAQ,CAAC;;;;;;;AAQ7D,SAAgB,YACd,KACA,SAAkC,EAAE,EACpC,UAA2B,EAAE,EAChB;CACb,IAAI,CAAC,UAAU,OAAO,KAAK,OAAO,CAAC,WAAW,GAAG,OAAO;CAExD,MAAM,OAAO,QAAQ,QAAQ;CAC7B,MAAM,aAAa,QAAQ,cAAc;CACzC,MAAM,SAAS,QAAQ,UAAU;CACjC,MAAM,YAA0C;EAAE,QAAQ;EAAO,GAAK,QAAQ,MAAM,EAAE;EAAoC;CAI1H,MAAM,WAAW,UADA,KAAK,KAAK,KACQ,EAAE,IAAI;CAEzC,KAAK,MAAM,MAAM,UACf,KAAK,MAAM,QAAQ,YAAY;EAC7B,MAAM,QAAQ,GAAG,QAAQ;EACzB,IAAI,CAAC,OAAO;EAEZ,MAAM,UAAU,aAAa,OAAO,QAAQ,WAAW,OAAO;EAC9D,IAAI,YAAY,OACd,GAAG,QAAQ,QAAQ;;CAKzB,OAAO"}