@maizzle/framework 6.0.0-rc.9 → 6.0.1

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 'pathe'\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  /**\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\n   * bindings). We pass these raw values to Tailwind's\n   * scanner via @source inline().\n   */\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    /**\n     * `raw` opts out of compilation entirely (marker is consumed here).\n     * `embed`/`data-embed` only signal \"preserve tag after inlining\"\n     * — they still need to go through compile so Tailwind/@apply\n     * resolves.\n     */\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    /**\n     * Only add source directives to style tags that import Tailwind —\n     * plain CSS doesn't need them and @tailwindcss/postcss would\n     * leave the directives unconsumed in the output.\n     */\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      /**\n       * If CSS processing fails, still replace with decoded content\n       * so HTML entities don't break the CSS.\n       */\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,GAAG;AAChG;;;;;;;;;;;AAYA,SAAS,sBAAsB,KAAkB,QAAuB,SAAyB;CAC/F,MAAM,aAAuB,CAAC;CAG9B,MAAM,eAAe,CACnB,QAAQ,OAAO,QAAQ,QAAQ,MAAM,GACrC,IAAI,OAAO,KAAK,WAAW,CAAC,EAAA,CAAG,KAAI,MAAK,QAAQ,CAAC,CAAC,CACpD;CAEA,KAAK,MAAM,KAAK,cACd,WAAW,KAAK,gBAAgB,SAAS,SAAS,QAAQ,CAAC,CAAC,EAAE,GAAG;;;;;;;;CAUnE,MAAM,UAAoB,CAAC;CAC3B,KAAK,MAAM,MAAM;EACf,MAAM,MAAO,EAAc,SAAS;EACpC,IAAI,KAAK,QAAQ,KAAK,GAAG;CAC3B,CAAC;CAED,IAAI,QAAQ,QACV,WAAW,KAAK,mBAAmB,QAAQ,KAAK,GAAG,EAAE,IAAI;CAG3D,OAAO,WAAW,KAAK,IAAI;AAC7B;;;;;;;;;;;;;;;;;AAkBA,eAAsB,YAAY,KAAkB,QAAuB,UAAyC;CAClH,MAAM,YAAqD,CAAC;CAE5D,KAAK,MAAM,SAAS;EAClB,IAAK,KAAiB,SAAS,SAAS;EAExC,MAAM,KAAK;;;;;;;EASX,IAAI,SARU,GAAG,SAQG;GAClB,OAAO,GAAG,QAAQ;GAClB;EACF;EAGA,MAAM,aAAa,GAAG,SACnB,QAAO,UAAS,MAAM,SAAS,MAAM,CAAC,CACtC,KAAI,UAAU,MAAc,IAAI,CAAC,CACjC,KAAK,EAAE;EAEV,IAAI,CAAC,WAAW,KAAK,GAAG;EAExB,UAAU,KAAK;GAAE,MAAM;GAAI,YAAY,oBAAoB,UAAU;EAAE,CAAC;CAC1E,CAAC;CAED,IAAI,CAAC,UAAU,QAAQ,OAAO;CAE9B,MAAM,WAAW,YAAY,QAAQ,QAAQ,IAAI,GAAG,cAAc;CAClE,MAAM,UAAU,QAAQ,QAAQ;CAIhC,MAAM,mBADoB,UAAU,MAAM,EAAE,iBAAiB,aAAa,UAAU,CAC3C,IACrC,sBAAsB,KAAK,QAAQ,OAAO,IAC1C;CAEJ,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;EACzC,MAAM,EAAE,MAAM,eAAe,UAAU;;;;;;EAOvC,MAAM,UAAU,aAAa,UAAU,IACnC,GAAG,WAAW,IAAI,qBAClB;EAEJ,IAAI;GAIF,KAAK,WAAW,CAAC;IACf,MAAM;IACN,MAAM,MALgB,mBAAmB,SAAS,QAAQ,GAAG,SAAS,SAAS,GAAG;IAMlF,QAAQ;GACV,CAAQ;EACV,QAAQ;;;;;GAKN,KAAK,WAAW,CAAC;IACf,MAAM;IACN,MAAM;IACN,QAAQ;GACV,CAAQ;EACV;CACF;CAEA,OAAO;AACT"}

package/dist/transformers/urlQuery.d.ts

@@ -0,0 +1,36 @@
+import { UrlQueryOptions } from "../types/config.js";
+import { ChildNode } from "domhandler";
+
+//#region src/transformers/urlQuery.d.ts
+/**
+ * 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'] })
+ */
+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 urlQueryDom(dom: ChildNode[], params?: Record<string, unknown>, options?: UrlQueryOptions): ChildNode[];
+//#endregion
+export { urlQuery, urlQueryDom };
+//# sourceMappingURL=urlQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"urlQuery.d.ts","names":[],"sources":["../../src/transformers/urlQuery.ts"],"mappings":";;;;;;AAiDA;;;;;;;;;;AAG+B;AAU/B;;;;;;;;;iBAbgB,QAAA,CACd,IAAA,UACA,MAAA,GAAQ,MAAA,mBACR,OAAA,GAAS,eAAoB;;;;;;iBAUf,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;AAAY;AAC3E,MAAM,eAAe,CAAC,GAAG;;;;AAKzB,SAAS,aACP,KACA,QACA,WACA,QACQ;CACR,IAAI,UAAU,CAAC,cAAc,GAAG,GAAG,OAAO;CAE1C,OAAO,YAAY,aACjB;EAAE;EAAK,OAAO;CAA0C,GACxD,SACF;AACF;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,SACd,MACA,SAAkC,CAAC,GACnC,UAA2B,CAAC,GACpB;CACR,OAAO,UAAU,YAAY,MAAM,IAAI,GAAG,QAAQ,OAAO,CAAC;AAC5D;;;;;;AAOA,SAAgB,YACd,KACA,SAAkC,CAAC,GACnC,UAA2B,CAAC,GACf;CACb,IAAI,CAAC,UAAU,OAAO,KAAK,MAAM,CAAC,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,CAAC;CAAoC;CAIzH,MAAM,WAAW,UADA,KAAK,KAAK,IACO,GAAG,GAAG;CAExC,KAAK,MAAM,MAAM,UACf,KAAK,MAAM,QAAQ,YAAY;EAC7B,MAAM,QAAQ,GAAG,QAAQ;EACzB,IAAI,CAAC,OAAO;EAEZ,MAAM,UAAU,aAAa,OAAO,QAAQ,WAAW,MAAM;EAC7D,IAAI,YAAY,OACd,GAAG,QAAQ,QAAQ;CAEvB;CAGF,OAAO;AACT"}

package/dist/types/{config.d.mts → config.d.ts}

@@ -1,12 +1,12 @@
-import { RemoveValue } from "../plugins/postcss/removeDeclarations.mjs";
+import { RemoveValue } from "../plugins/postcss/removeDeclarations.js";
+import { TemplateInfo } from "../events/index.js";
 import { Directive, Plugin } from "vue";
-import { Options } from "juice";
-import * as oxfmt from "oxfmt";
 import { InlineConfig } from "vite";
-import * as shiki from "shiki";
-import { Options as Options$1 } from "unplugin-vue-markdown/types";
+import juice from "juice";
+import { Options } from "unplugin-vue-markdown/types";
 
 //#region src/types/config.d.ts
+type JuiceOptions = NonNullable<Parameters<typeof juice>[1]>;
 interface UrlQueryOptions {
   /**
    * CSS selectors for elements to process.
@@ -95,7 +95,7 @@ interface CssConfig {
    *   }
    * }
    */
-  inline?: boolean | Options & {
+  inline?: boolean | JuiceOptions & {
     /**
      * Convert HTML attributes like `width`, `height`, `bgcolor`, and `valign`
      * to inline CSS styles. Set to `true` for all, or pass an array of attribute names.
@@ -186,25 +186,13 @@ interface CssConfig {
     sort?: 'mobile-first' | 'desktop-first' | ((a: string, b: string) => number);
   };
   /**
-   * Convert unitless CSS values to their unitless equivalents.
+   * Strip units from zero values in inlined styles.
    *
-   * For example, `line-height: 24px` with a `16px` font becomes `line-height: 1.5`.
+   * For example, `padding: 0px 16px` becomes `padding: 0 16px`.
    *
    * @default true
    */
   preferUnitless?: boolean;
-  /**
-   * Resolve CSS `calc()` expressions to static values where possible.
-   *
-   * @default true
-   */
-  resolveCalc?: boolean;
-  /**
-   * Resolve CSS custom properties (`var()`) to their computed values.
-   *
-   * @default true
-   */
-  resolveProps?: boolean;
   /**
    * Replace unsafe CSS class names with email-safe equivalents.
    *
@@ -241,7 +229,11 @@ interface CssConfig {
    */
   removeDeclarations?: Record<string, RemoveValue>;
   /**
-   * File paths to exclude from CSS processing.
+   * Glob patterns or paths excluded from Tailwind's `@source` scanner.
+   *
+   * Tailwind won't generate utilities for classes used in these files.
+   * Useful for ignoring AMP variants or any templates whose classes
+   * shouldn't end up in the output CSS.
    *
    * @example
    * css: {
@@ -254,6 +246,10 @@ interface AttributesConfig {
   /**
    * Add attributes to HTML elements.
    *
+   * Set the whole map to `false` to disable auto-add. Set a selector
+   * entry to `false` to skip that selector. Set an individual attribute
+   * to `false` to skip just that attribute while keeping the rest.
+   *
    * @example
    * html: {
    *   attributes: {
@@ -264,14 +260,25 @@ interface AttributesConfig {
    *   }
    * }
    */
-  add?: false | Record<string, Record<string, string | boolean | number>>;
+  add?: false | Record<string, false | Record<string, false | string | boolean | number>>;
   /**
-   * Remove attributes from HTML elements by name or name-value pair.
+   * Remove attributes from HTML elements.
+   *
+   * Empty `style` and `class` attributes are always stripped, regardless
+   * of config. Entries added here are appended to those defaults.
+   *
+   * - String — remove when the attribute's value is empty.
+   * - `{ name, value: 'literal' }` — remove when the value matches exactly.
+   * - `{ name, value: /regex/ }` — remove when the value matches the regex.
    *
    * @example
    * html: {
    *   attributes: {
-   *     remove: ['data-test', { name: 'class', value: /^js-/ }],
+   *     remove: [
+   *       'data-foo',
+   *       { name: 'role', value: 'none' },
+   *       { name: 'class', value: /^js-/ },
+   *     ],
    *   }
    * }
    */
@@ -281,6 +288,28 @@ interface AttributesConfig {
   }>;
 }
 type EntitiesConfig = boolean | Record<string, string>;
+/**
+ * caniemail.com client family slugs. Maintained manually from
+ * https://www.caniemail.com/api/data.json — update this list when caniemail
+ * adds new clients.
+ */
+type CaniemailClient = 'gmail' | 'outlook' | 'yahoo' | 'apple-mail' | 'aol' | 'thunderbird' | 'microsoft' | 'samsung-email' | 'sfr' | 'orange' | 'protonmail' | 'hey' | 'mail-ru' | 'fastmail' | 'laposte' | 't-online-de' | 'free-fr' | 'gmx' | 'web-de' | 'ionos-1and1' | 'rainloop' | 'wp-pl';
+interface ChecksConfig {
+  /**
+   * Client families to check against. Defaults to the four majors:
+   * Gmail, Apple Mail, Outlook, Yahoo. Pass `'all'` to check every client
+   * in the caniemail dataset.
+   */
+  clients?: CaniemailClient[] | 'all';
+  /**
+   * Filter which severities are reported. Omit to show everything.
+   *
+   * - `'error'` — only errors (unsupported features, hard lint errors)
+   * - `'warning'` — only warnings (partial / unknown support, lint warnings)
+   * - `'lint'` — only lint items (both severities, no compat items)
+   */
+  level?: 'error' | 'warning' | 'lint';
+}
 interface PostcssConfig {
   /**
    * Selector prefixes to strip from compiled CSS.
@@ -321,32 +350,129 @@ interface HtmlConfig {
    *
    * Set to `true` to enable with defaults, or pass options.
    */
-  format?: boolean | oxfmt.FormatOptions;
+  format?: boolean | import('oxfmt').FormatOptions;
   /**
    * Minify the HTML output.
    *
-   * Set to `true` to enable with defaults, or pass options.
+   * Set to `true` to enable with defaults, or pass `html-crush`
+   * options to customize.
+   *
+   * @see https://codsen.com/os/html-crush
    */
-  minify?: boolean | Record<string, unknown>;
+  minify?: boolean | Partial<import('html-crush').Opts>;
 }
 type FilterFunction = (str: string, value: string) => string;
 type FiltersConfig = false | Record<string, FilterFunction>;
-interface MarkdownConfig extends Options$1 {
+interface MarkdownConfig extends Options {
   /**
    * The shiki theme to use for syntax highlighting in Markdown fenced code blocks.
    *
    * @default 'github-light'
    */
-  shikiTheme?: shiki.BundledTheme;
+  shikiTheme?: import('shiki').BundledTheme;
 }
 interface VueConfig {
-  /** Vue plugins to register on the app instance before rendering. */
-  plugins?: Plugin[];
+  /**
+   * Vue plugins to register on the app instance before rendering.
+   *
+   * Pass a factory (`() => Plugin[]`) for stateful plugins like vue-i18n
+   * or Pinia to get a fresh instance per render — otherwise state leaks
+   * across templates (e.g. one template setting `locale.value = 'fr'`
+   * affects the next render).
+   */
+  plugins?: Plugin[] | (() => Plugin[]);
   /** Custom Vue directives to register globally. */
   directives?: Record<string, Directive>;
   /** Properties added to `app.config.globalProperties`, available in all templates. */
   globalProperties?: Record<string, unknown>;
 }
+/**
+ * Per-transformer toggle map for `useTransformers`.
+ *
+ * - `false` skips the listed transformer.
+ * - `true` force-enables it for this run (only meaningful for boolean-driven
+ *   transformers: inlineCss, purgeCss, prettify, minify, shorthandCss,
+ *   sixHex, safeSelectors, entities). Layers on the matching
+ *   `css.*` / `html.*` config slice.
+ * - missing keys keep their default behavior.
+ *
+ * Data-driven transformers (filters, baseURL, urlQuery, addAttributes,
+ * removeAttributes, replaceStrings, attributeToStyle) require actual
+ * config values — a bare `true` is a no-op for them.
+ *
+ * Transformers without a toggle (Tailwind, MSO placeholder resolution,
+ * column width math, link inlining) always run; they're driven by markup
+ * or framework state, not user opt-in.
+ */
+interface TransformerToggles {
+  safeSelectors?: boolean;
+  attributeToStyle?: boolean;
+  inlineCss?: boolean;
+  removeAttributes?: boolean;
+  shorthandCss?: boolean;
+  sixHex?: boolean;
+  addAttributes?: boolean;
+  filters?: boolean;
+  baseURL?: boolean;
+  urlQuery?: boolean;
+  purgeCss?: boolean;
+  entities?: boolean;
+  replaceStrings?: boolean;
+  prettify?: boolean;
+  minify?: boolean;
+}
+/**
+ * Plaintext generation options.
+ *
+ * Control where plaintext files are written, what extension they use,
+ * and the options forwarded to `string-strip-html`.
+ */
+interface PlaintextConfig {
+  /**
+   * Output directory for plaintext files. When omitted, files are written
+   * next to their HTML counterpart in `build.output.path`.
+   */
+  destination?: string;
+  /**
+   * File extension for plaintext files (without the leading dot).
+   *
+   * @default 'txt'
+   */
+  extension?: string;
+  /**
+   * Options forwarded to `string-strip-html`.
+   *
+   * @see https://codsen.com/os/string-strip-html
+   */
+  options?: Partial<import('string-strip-html').Opts>;
+}
+/**
+ * Source directory entry for component auto-import.
+ *
+ * String → folder name becomes a namespace prefix automatically
+ * (e.g. `widgets/Button.vue` → `<WidgetsButton />`).
+ *
+ * Object → custom prefix overrides the folder-derived name. With
+ * `pathPrefix: false`, intermediate subfolders are dropped from the
+ * resolved name (useful for icon sets organized by category).
+ */
+type ComponentSource = string | {
+  /** Directory to scan, resolved relative to `cwd`. */path: string;
+  /**
+   * Custom prefix prepended to every resolved component name.
+   * Empty string disables the auto folder-name prefix.
+   */
+  prefix?: string;
+  /**
+   * Include intermediate subfolder names in the resolved component
+   * name. Defaults to `true`.
+   *
+   * @example
+   * // pathPrefix: true  → icons/social/twitter.vue → <IconSocialTwitter />
+   * // pathPrefix: false → icons/social/twitter.vue → <IconTwitter />
+   */
+  pathPrefix?: boolean;
+};
 interface MaizzleConfig {
   /**
    * Root directory for the Maizzle email project.
@@ -393,6 +519,27 @@ interface MaizzleConfig {
      */
     extension?: string;
   };
+  /**
+   * Build templates in parallel across worker threads.
+   *
+   * - omitted (default): parallel when there are more than 50 templates
+   * - `true`: always parallel, using min(CPU count − 1, 8) workers
+   * - `false`: always sequential
+   * - `{ workers, threshold }`: parallel when the template count exceeds
+   *   `threshold` (default 50), using `workers` threads (default
+   *   min(CPU count − 1, 8)). Set `threshold: 0` to always parallelize.
+   *
+   * Note: more workers is not faster — each runs a full renderer, so ~8 is the
+   * sweet spot and over-provisioning slows builds down.
+   *
+   * Only applies to file-based configs (the CLI / a config path); an inline
+   * config object always builds sequentially. SFC-registered `afterBuild`
+   * handlers can't run in a worker — use the config `afterBuild` hook instead.
+   */
+  parallel?: boolean | {
+    workers?: number;
+    threshold?: number;
+  };
   /** Static file copying configuration. */
   static?: {
     /**
@@ -416,12 +563,20 @@ interface MaizzleConfig {
      * Resolved relative to `cwd` (not `root`), so paths outside the
      * email root directory work as expected.
      *
+     * String entries use the folder name as a namespace prefix
+     * automatically (e.g. `widgets/Button.vue` → `<WidgetsButton />`).
+     * Object entries override that with a custom prefix.
+     *
      * @example
      * components: {
-     *   source: ['resources/js/components/email'],
+     *   source: [
+     *     'resources/js/components/email',
+     *     { path: 'src/widgets', prefix: 'W' },
+     *     { path: 'src/icons', prefix: 'Icon', pathPrefix: false },
+     *   ],
      * }
      */
-    source?: string | string[];
+    source?: ComponentSource | ComponentSource[];
   };
   /** Dev server configuration. */
   server?: {
@@ -467,25 +622,52 @@ interface MaizzleConfig {
       subject?: string; /** Nodemailer transport options (SMTP, SES, etc.). Omit to use Ethereal. */
       transport?: Record<string, unknown>;
     };
+    /**
+     * Configure or disable the Checks tab in the dev UI.
+     *
+     * Set to `false` to disable checks entirely (the tab is hidden).
+     *
+     * @example
+     * server: {
+     *   checks: {
+     *     clients: ['gmail', 'outlook', 'apple-mail'],
+     *     level: 'error',
+     *   }
+     * }
+     */
+    checks?: false | ChecksConfig;
   };
   /** Tailwind CSS and email CSS optimization settings. */
   css?: CssConfig;
   /**
    * Generate a plaintext version of the email.
    *
-   * Set to `true` to enable, or pass a string path or options object.
+   * Set to `true` to enable with defaults, or pass an object to configure
+   * destination directory, file extension, and `string-strip-html` options.
    *
    * @default false
+   * @example
+   * plaintext: {
+   *   destination: 'build_production/plaintext',
+   *   extension: 'txt',
+   *   options: { ignoreTags: ['br'] },
+   * }
    */
-  plaintext?: boolean | string | Record<string, unknown>;
+  plaintext?: boolean | PlaintextConfig;
   /** PostCSS processing options. */
   postcss?: PostcssConfig;
   /**
    * Enable the transformer pipeline (CSS inlining, purging, shorthand, etc).
    *
+   * Pass `false` to skip the entire pipeline. Pass an object to opt out of
+   * specific transformers while keeping the rest active — only keys set
+   * to `false` are skipped.
+   *
    * @default true
+   * @example
+   * useTransformers: { inlineCss: false, minify: false }
    */
-  useTransformers?: boolean;
+  useTransformers?: boolean | TransformerToggles;
   /**
    * Replace strings in the final HTML output.
    *
@@ -514,9 +696,10 @@ interface MaizzleConfig {
   /**
    * Vite configuration options passed to the internal Vite SSR server.
    *
-   * Use this to add custom Vite plugins or other Vite options.
-   * If a `vite.config.{ts,js}` file exists in the project root, it takes
-   * precedence and this option is used as a fallback.
+   * Use this to add custom Vite plugins or other Vite options. The internal
+   * SSR server never loads a project `vite.config.{ts,js}` (it runs with
+   * `configFile: false`), so pass anything it needs here. These options are
+   * merged underneath Maizzle's required settings, which take precedence.
    *
    * @example
    * vite: {
@@ -532,7 +715,9 @@ interface MaizzleConfig {
    *
    * @example
    * vue: {
-   *   plugins: [createI18n({ locale: 'en', messages })],
+   *   // Use a factory for stateful plugins (vue-i18n, Pinia, vue-router)
+   *   // so each render gets a fresh instance.
+   *   plugins: () => [createI18n({ locale: 'en', messages })],
    *   directives: { focus: vFocus },
    *   globalProperties: { $format: dateFormat },
    * }
@@ -542,21 +727,21 @@ interface MaizzleConfig {
   beforeCreate?: (params: {
     config: MaizzleConfig;
   }) => void | Promise<void>;
-  /** Called before each template is rendered. Return a string to replace the template source. */
+  /** Called before each template is rendered. Return a string to replace `template.source`. */
   beforeRender?: (params: {
     config: MaizzleConfig;
-    template: string;
+    template: TemplateInfo;
   }) => string | void | Promise<string | void>;
   /** Called after each template is rendered but before transformers run. Return a string to replace the output HTML. */
   afterRender?: (params: {
     config: MaizzleConfig;
-    template: string;
+    template: TemplateInfo;
     html: string;
   }) => string | void | Promise<string | void>;
   /** Called after transformers have run on each template. Return a string to replace the output HTML. */
   afterTransform?: (params: {
     config: MaizzleConfig;
-    template: string;
+    template: TemplateInfo;
     html: string;
   }) => string | void | Promise<string | void>;
   /** Called after all templates have been built. */
@@ -567,5 +752,5 @@ interface MaizzleConfig {
   [key: string]: any;
 }
 //#endregion
-export { AttributesConfig, CssConfig, EntitiesConfig, FilterFunction, FiltersConfig, HtmlConfig, MaizzleConfig, MarkdownConfig, PostcssConfig, UrlConfig, UrlQuery, UrlQueryOptions, VueConfig };
-//# sourceMappingURL=config.d.mts.map
+export { AttributesConfig, CaniemailClient, ChecksConfig, ComponentSource, CssConfig, EntitiesConfig, FilterFunction, FiltersConfig, HtmlConfig, MaizzleConfig, MarkdownConfig, PlaintextConfig, PostcssConfig, TransformerToggles, UrlConfig, UrlQuery, UrlQueryOptions, VueConfig };
+//# sourceMappingURL=config.d.ts.map

package/dist/types/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","names":[],"sources":["../../src/types/config.ts"],"mappings":"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"}

package/dist/types/config.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+import { AttributesConfig, CaniemailClient, ChecksConfig, ComponentSource, CssConfig, EntitiesConfig, FilterFunction, FiltersConfig, HtmlConfig, MaizzleConfig, MarkdownConfig, PlaintextConfig, PostcssConfig, TransformerToggles, UrlConfig, UrlQuery, UrlQueryOptions } from "./config.js";
+export type { AttributesConfig, CaniemailClient, ChecksConfig, ComponentSource, CssConfig, EntitiesConfig, FilterFunction, FiltersConfig, HtmlConfig, MaizzleConfig, MarkdownConfig, PlaintextConfig, PostcssConfig, TransformerToggles, UrlConfig, UrlQuery, UrlQueryOptions };

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/ast/index.d.ts

@@ -0,0 +1,4 @@
+import { parse } from "./parser.js";
+import { walk } from "./walker.js";
+import { serialize } from "./serializer.js";
+export { parse, serialize, walk };

package/dist/utils/ast/index.js

@@ -0,0 +1,4 @@
+import { parse } from "./parser.js";
+import { walk } from "./walker.js";
+import { serialize } from "./serializer.js";
+export { parse, serialize, walk };

package/dist/utils/ast/{parser.d.mts → parser.d.ts}

@@ -4,4 +4,4 @@ import { ChildNode, DomHandlerOptions } from "domhandler";
 declare function parse(html: string, options?: DomHandlerOptions): ChildNode[];
 //#endregion
 export { parse };
-//# sourceMappingURL=parser.d.mts.map
+//# sourceMappingURL=parser.d.ts.map

package/dist/utils/ast/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","names":[],"sources":["../../../src/utils/ast/parser.ts"],"mappings":";;;iBAIgB,KAAA,CAAM,IAAA,UAAc,OAAA,GAAS,iBAAA,GAAyB,SAAS"}

package/dist/utils/ast/{parser.mjs → parser.js}

@@ -1,6 +1,5 @@
 import { Parser } from "htmlparser2";
 import { DomHandler } from "domhandler";
-
 //#region src/utils/ast/parser.ts
 function parse(html, options = {}) {
 	const handler = new DomHandler();
@@ -9,7 +8,7 @@ function parse(html, options = {}) {
 	parser.end();
 	return handler.dom;
 }
-
 //#endregion
 export { parse };
-//# sourceMappingURL=parser.mjs.map
+
+//# sourceMappingURL=parser.js.map

package/dist/utils/ast/parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.js","names":[],"sources":["../../../src/utils/ast/parser.ts"],"sourcesContent":["import { Parser } from 'htmlparser2'\nimport { DomHandler } from 'domhandler'\nimport type { ChildNode, DomHandlerOptions } from 'domhandler'\n\nexport function parse(html: string, options: DomHandlerOptions = {}): ChildNode[] {\n  const handler = new DomHandler()\n  const parser = new Parser(handler, options)\n  parser.write(html)\n  parser.end()\n  return handler.dom\n}\n"],"mappings":";;;AAIA,SAAgB,MAAM,MAAc,UAA6B,CAAC,GAAgB;CAChF,MAAM,UAAU,IAAI,WAAW;CAC/B,MAAM,SAAS,IAAI,OAAO,SAAS,OAAO;CAC1C,OAAO,MAAM,IAAI;CACjB,OAAO,IAAI;CACX,OAAO,QAAQ;AACjB"}

package/dist/utils/ast/{serializer.d.mts → serializer.d.ts}

@@ -5,4 +5,4 @@ import { DomSerializerOptions } from "dom-serializer";
 declare function serialize(dom: ChildNode[], options?: DomSerializerOptions): string;
 //#endregion
 export { serialize };
-//# sourceMappingURL=serializer.d.mts.map
+//# sourceMappingURL=serializer.d.ts.map

package/dist/utils/ast/serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.ts","names":[],"sources":["../../../src/utils/ast/serializer.ts"],"mappings":";;;;iBA0CgB,SAAA,CAAU,GAAA,EAAK,SAAA,IAAa,OAAA,GAAU,oBAAoB"}