@maizzle/framework 6.0.0-rc.8 → 6.0.0

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

@@ -1,10 +1,12 @@
-import { RemoveValue } from "../plugins/postcss/removeDeclarations.mjs";
-import { Options } from "juice";
-import * as oxfmt from "oxfmt";
-import * as shiki from "shiki";
-import { Options as Options$1 } from "unplugin-vue-markdown/types";
+import { RemoveValue } from "../plugins/postcss/removeDeclarations.js";
+import { TemplateInfo } from "../events/index.js";
+import { Directive, Plugin } from "vue";
+import { InlineConfig } from "vite";
+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.
@@ -93,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.
@@ -184,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.
    *
@@ -219,6 +209,14 @@ interface CssConfig {
   shorthand?: boolean | {
     tags?: string[];
   };
+  /**
+   * Convert 3-digit HEX colors to 6-digit in `bgcolor` and `color` attributes.
+   *
+   * Some email clients don't support shorthand HEX like `#fff`.
+   *
+   * @default true
+   */
+  sixHex?: boolean;
   /**
    * Remove specific CSS declarations by selector.
    *
@@ -231,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: {
@@ -244,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: {
@@ -254,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-/ },
+   *     ],
    *   }
    * }
    */
@@ -271,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.
@@ -311,24 +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.
+   *
+   * 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.
@@ -375,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?: {
     /**
@@ -398,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?: {
@@ -449,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.
    *
@@ -493,25 +693,55 @@ interface MaizzleConfig {
   url?: UrlConfig;
   /** HTML post-processing settings (attributes, formatting, minification). */
   html?: HtmlConfig;
+  /**
+   * Vite configuration options passed to the internal Vite SSR server.
+   *
+   * 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: {
+   *   plugins: [myPlugin()],
+   * }
+   */
+  vite?: InlineConfig;
+  /**
+   * Vue app customization options.
+   *
+   * Register plugins, directives, or global properties on the
+   * internal Vue app instance used for SSR rendering.
+   *
+   * @example
+   * vue: {
+   *   // 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 },
+   * }
+   */
+  vue?: VueConfig;
   /** Called before any templates are processed. */
   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. */
@@ -522,5 +752,5 @@ interface MaizzleConfig {
   [key: string]: any;
 }
 //#endregion
-export { AttributesConfig, CssConfig, EntitiesConfig, FilterFunction, FiltersConfig, HtmlConfig, MaizzleConfig, MarkdownConfig, PostcssConfig, UrlConfig, UrlQuery, UrlQueryOptions };
-//# 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"}

package/dist/utils/ast/serializer.js

@@ -0,0 +1,46 @@
+import render from "dom-serializer";
+//#region src/utils/ast/serializer.ts
+const RAW_TEXT_ELEMENTS = new Set(["script", "style"]);
+/**
+* Re-encode `<` and `>` in text nodes before serialization.
+*
+* The parser decodes entities like `&lt;` into raw `<` in text nodes. With
+* `encodeEntities: false` (needed so other transformers can emit entity
+* strings such as `&nbsp;` verbatim), the serializer would write those raw
+* `<` characters as-is, turning escaped text (e.g. a Vue `{{ html }}`
+* interpolation containing `<p>...</p>`) into real DOM downstream.
+*
+* `&` is intentionally not re-encoded: the `entities` transformer writes
+* literal entity strings (`&nbsp;`, `&mdash;`) directly into text-node data
+* and relies on the serializer leaving them alone.
+*
+* Skip `<script>` / `<style>` — their children are raw-text containers, and
+* CSS/JS legitimately contains `<` and `>`.
+*/
+function encodeTextNodes(dom, inRawText = false) {
+	for (const node of dom) {
+		if (node.type === "text") {
+			if (!inRawText) {
+				const text = node;
+				text.data = text.data.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+			}
+			continue;
+		}
+		if ("children" in node && node.children?.length) {
+			const el = node;
+			const nextRaw = inRawText || RAW_TEXT_ELEMENTS.has(el.name);
+			encodeTextNodes(el.children, nextRaw);
+		}
+	}
+}
+function serialize(dom, options) {
+	encodeTextNodes(dom);
+	return render(dom, {
+		encodeEntities: false,
+		...options
+	});
+}
+//#endregion
+export { serialize };
+
+//# sourceMappingURL=serializer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.js","names":[],"sources":["../../../src/utils/ast/serializer.ts"],"sourcesContent":["import render from 'dom-serializer'\nimport type { ChildNode, Element, Text } from 'domhandler'\nimport type { DomSerializerOptions } from 'dom-serializer'\n\nconst RAW_TEXT_ELEMENTS = new Set(['script', 'style'])\n\n/**\n * Re-encode `<` and `>` in text nodes before serialization.\n *\n * The parser decodes entities like `&lt;` into raw `<` in text nodes. With\n * `encodeEntities: false` (needed so other transformers can emit entity\n * strings such as `&nbsp;` verbatim), the serializer would write those raw\n * `<` characters as-is, turning escaped text (e.g. a Vue `{{ html }}`\n * interpolation containing `<p>...</p>`) into real DOM downstream.\n *\n * `&` is intentionally not re-encoded: the `entities` transformer writes\n * literal entity strings (`&nbsp;`, `&mdash;`) directly into text-node data\n * and relies on the serializer leaving them alone.\n *\n * Skip `<script>` / `<style>` — their children are raw-text containers, and\n * CSS/JS legitimately contains `<` and `>`.\n */\nfunction encodeTextNodes(dom: ChildNode[], inRawText = false): void {\n  for (const node of dom) {\n    if (node.type === 'text') {\n      if (!inRawText) {\n        const text = node as Text\n        text.data = text.data\n          .replace(/</g, '&lt;')\n          .replace(/>/g, '&gt;')\n      }\n      continue\n    }\n\n    if ('children' in node && (node as Element).children?.length) {\n      const el = node as Element\n      const nextRaw = inRawText || RAW_TEXT_ELEMENTS.has(el.name)\n      encodeTextNodes(el.children as ChildNode[], nextRaw)\n    }\n  }\n}\n\nexport function serialize(dom: ChildNode[], options?: DomSerializerOptions): string {\n  encodeTextNodes(dom)\n  return render(dom, { encodeEntities: false, ...options })\n}\n"],"mappings":";;AAIA,MAAM,oBAAoB,IAAI,IAAI,CAAC,UAAU,OAAO,CAAC;;;;;;;;;;;;;;;;;AAkBrD,SAAS,gBAAgB,KAAkB,YAAY,OAAa;CAClE,KAAK,MAAM,QAAQ,KAAK;EACtB,IAAI,KAAK,SAAS,QAAQ;GACxB,IAAI,CAAC,WAAW;IACd,MAAM,OAAO;IACb,KAAK,OAAO,KAAK,KACd,QAAQ,MAAM,MAAM,CAAC,CACrB,QAAQ,MAAM,MAAM;GACzB;GACA;EACF;EAEA,IAAI,cAAc,QAAS,KAAiB,UAAU,QAAQ;GAC5D,MAAM,KAAK;GACX,MAAM,UAAU,aAAa,kBAAkB,IAAI,GAAG,IAAI;GAC1D,gBAAgB,GAAG,UAAyB,OAAO;EACrD;CACF;AACF;AAEA,SAAgB,UAAU,KAAkB,SAAwC;CAClF,gBAAgB,GAAG;CACnB,OAAO,OAAO,KAAK;EAAE,gBAAgB;EAAO,GAAG;CAAQ,CAAC;AAC1D"}

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

@@ -4,4 +4,4 @@ import { ChildNode } from "domhandler";
 declare function walk(ast: ChildNode[], callback: (node: ChildNode) => void): void;
 //#endregion
 export { walk };
-//# sourceMappingURL=walker.d.mts.map
+//# sourceMappingURL=walker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"walker.d.ts","names":[],"sources":["../../../src/utils/ast/walker.ts"],"mappings":";;;iBAEgB,IAAA,CAAK,GAAA,EAAK,SAAA,IAAa,QAAA,GAAW,IAAA,EAAM,SAAS"}

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

@@ -6,7 +6,7 @@ function walk(ast, callback) {
 	}
 	for (const node of ast) traverse(node);
 }
-
 //#endregion
 export { walk };
-//# sourceMappingURL=walker.mjs.map
+
+//# sourceMappingURL=walker.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"walker.js","names":[],"sources":["../../../src/utils/ast/walker.ts"],"sourcesContent":["import type { ChildNode } from 'domhandler'\n\nexport function walk(ast: ChildNode[], callback: (node: ChildNode) => void): void {\n  function traverse(node: ChildNode) {\n    callback(node)\n\n    if ('children' in node && node.children && node.children.length > 0) {\n      for (const child of node.children) {\n        traverse(child)\n      }\n    }\n  }\n\n  for (const node of ast) {\n    traverse(node)\n  }\n}\n"],"mappings":";AAEA,SAAgB,KAAK,KAAkB,UAA2C;CAChF,SAAS,SAAS,MAAiB;EACjC,SAAS,IAAI;EAEb,IAAI,cAAc,QAAQ,KAAK,YAAY,KAAK,SAAS,SAAS,GAChE,KAAK,MAAM,SAAS,KAAK,UACvB,SAAS,KAAK;CAGpB;CAEA,KAAK,MAAM,QAAQ,KACjB,SAAS,IAAI;AAEjB"}

package/dist/utils/cloneConfig.d.ts

@@ -0,0 +1,13 @@
+//#region src/utils/cloneConfig.d.ts
+/**
+ * Deep-clone plain objects so per-template config mutations stay isolated.
+ *
+ * Arrays, functions, and class instances (Date, RegExp, Vite plugins, …) pass
+ * through by reference — only nested plain-object props are copied, which is
+ * what `beforeRender` mutations (`config.url.base`, `config.css.inline`, …)
+ * touch. Sharing arrays by reference matches the parallel worker's merge.
+ */
+declare function cloneConfig<T>(value: T): T;
+//#endregion
+export { cloneConfig };
+//# sourceMappingURL=cloneConfig.d.ts.map

package/dist/utils/cloneConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloneConfig.d.ts","names":[],"sources":["../../src/utils/cloneConfig.ts"],"mappings":";;AAQA;;;;;;;iBAAgB,WAAA,IAAe,KAAA,EAAO,CAAA,GAAI,CAAC"}

package/dist/utils/cloneConfig.js

@@ -0,0 +1,21 @@
+//#region src/utils/cloneConfig.ts
+/**
+* Deep-clone plain objects so per-template config mutations stay isolated.
+*
+* Arrays, functions, and class instances (Date, RegExp, Vite plugins, …) pass
+* through by reference — only nested plain-object props are copied, which is
+* what `beforeRender` mutations (`config.url.base`, `config.css.inline`, …)
+* touch. Sharing arrays by reference matches the parallel worker's merge.
+*/
+function cloneConfig(value) {
+	if (value === null || typeof value !== "object") return value;
+	if (Array.isArray(value)) return value;
+	if (Object.getPrototypeOf(value) !== Object.prototype) return value;
+	const out = {};
+	for (const key of Object.keys(value)) out[key] = cloneConfig(value[key]);
+	return out;
+}
+//#endregion
+export { cloneConfig };
+
+//# sourceMappingURL=cloneConfig.js.map

package/dist/utils/cloneConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloneConfig.js","names":[],"sources":["../../src/utils/cloneConfig.ts"],"sourcesContent":["/**\n * Deep-clone plain objects so per-template config mutations stay isolated.\n *\n * Arrays, functions, and class instances (Date, RegExp, Vite plugins, …) pass\n * through by reference — only nested plain-object props are copied, which is\n * what `beforeRender` mutations (`config.url.base`, `config.css.inline`, …)\n * touch. Sharing arrays by reference matches the parallel worker's merge.\n */\nexport function cloneConfig<T>(value: T): T {\n  if (value === null || typeof value !== 'object') return value\n  if (Array.isArray(value)) return value\n  if (Object.getPrototypeOf(value) !== Object.prototype) return value\n\n  const out: Record<string, unknown> = {}\n  for (const key of Object.keys(value as object)) {\n    out[key] = cloneConfig((value as Record<string, unknown>)[key])\n  }\n\n  return out as T\n}\n"],"mappings":";;;;;;;;;AAQA,SAAgB,YAAe,OAAa;CAC1C,IAAI,UAAU,QAAQ,OAAO,UAAU,UAAU,OAAO;CACxD,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO;CACjC,IAAI,OAAO,eAAe,KAAK,MAAM,OAAO,WAAW,OAAO;CAE9D,MAAM,MAA+B,CAAC;CACtC,KAAK,MAAM,OAAO,OAAO,KAAK,KAAe,GAC3C,IAAI,OAAO,YAAa,MAAkC,IAAI;CAGhE,OAAO;AACT"}