@maizzle/framework 6.1.3 → 6.1.5

package/dist/transformers/shorthandCss.d.ts

@@ -3,7 +3,7 @@ import { ChildNode } from "domhandler";
 /**
  * Options for the `shorthandCss` transformer.
  */
-interface ShorthandCssOptions {
+export interface ShorthandCssOptions {
   /**
    * Restrict the transform to a list of HTML tag names. Omit to apply to
    * every element with a `style` attribute.
@@ -12,13 +12,12 @@ interface ShorthandCssOptions {
    */
   tags?: string[];
 }
-declare function shorthandCss(html: string, options?: ShorthandCssOptions): string;
+export 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[];
+export 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

@@ -1 +1 @@
-{"version":3,"file":"shorthandCss.d.ts","names":[],"sources":["../../src/transformers/shorthandCss.ts"],"mappings":";;;;;UASiB;;;;;;;EAOf;;iBAwEc,aAAa,cAAc,UAAS;;;;;;iBASpC,gBAAgB,KAAK,aAAa,UAAS,sBAA2B"}
+{"version":3,"file":"shorthandCss.d.ts","names":[],"sources":["../../src/transformers/shorthandCss.ts"],"mappings":";;;;;iBASiB;;;;;;;EAOf;;wBAwEc,aAAa,cAAc,UAAS;;;;;;wBASpC,gBAAgB,KAAK,aAAa,UAAS,sBAA2B"}

package/dist/transformers/sixHex.d.ts

@@ -12,13 +12,12 @@ import { ChildNode } from "domhandler";
  *
  * const out = sixHex('<font color="#abc">x</font>')
  */
-declare function sixHex(html: string): string;
+export 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 sixHexDom(dom: ChildNode[]): ChildNode[];
+export declare function sixHexDom(dom: ChildNode[]): ChildNode[];
 //#endregion
-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":";;;;;;;;;;;;;;iBAkBgB,OAAO;;;;;;iBASP,UAAU,KAAK,cAAc"}
+{"version":3,"file":"sixHex.d.ts","names":[],"sources":["../../src/transformers/sixHex.ts"],"mappings":";;;;;;;;;;;;;;wBAkBgB,OAAO;;;;;;wBASP,UAAU,KAAK,cAAc"}

package/dist/transformers/tailwindComponent.d.ts

@@ -9,7 +9,6 @@ import { ChildNode } from "domhandler";
  * One <style> per outermost block is appended to <head>; marker comments
  * are stripped after.
  */
-declare function tailwindComponent(dom: ChildNode[], blocks: TailwindBlock[], config: MaizzleConfig, filePath?: string, sourceFiles?: string[]): Promise<ChildNode[]>;
+export declare function tailwindComponent(dom: ChildNode[], blocks: TailwindBlock[], config: MaizzleConfig, filePath?: string, sourceFiles?: string[]): Promise<ChildNode[]>;
 //#endregion
-export { tailwindComponent };
 //# sourceMappingURL=tailwindComponent.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tailwindComponent.d.ts","names":[],"sources":["../../src/transformers/tailwindComponent.ts"],"mappings":";;;;;;;;;;;iBA2BsB,kBACpB,KAAK,aACL,QAAQ,iBACR,QAAQ,eACR,mBACA,yBACC,QAAQ"}
+{"version":3,"file":"tailwindComponent.d.ts","names":[],"sources":["../../src/transformers/tailwindComponent.ts"],"mappings":";;;;;;;;;;;wBA2BsB,kBACpB,KAAK,aACL,QAAQ,iBACR,QAAQ,eACR,mBACA,yBACC,QAAQ"}

package/dist/transformers/tailwindcss.d.ts

@@ -6,7 +6,7 @@ import { ChildNode } from "domhandler";
  * is off and only our explicit `@source` directives apply. Skips
  * imports that already carry a `source(...)` modifier.
  */
-declare function rewriteImportsSourceNone(css: string): string;
+export declare function rewriteImportsSourceNone(css: string): string;
 /**
  * Tailwind CSS transformer.
  *
@@ -24,7 +24,6 @@ declare function rewriteImportsSourceNone(css: string): string;
  * Runs as the first transformer in the pipeline so that subsequent
  * transformers (inliner, purge, etc.) work with fully compiled CSS.
  */
-declare function tailwindcss(dom: ChildNode[], config: MaizzleConfig, filePath?: string, sourceFiles?: string[]): Promise<ChildNode[]>;
+export declare function tailwindcss(dom: ChildNode[], config: MaizzleConfig, filePath?: string, sourceFiles?: string[]): Promise<ChildNode[]>;
 //#endregion
-export { rewriteImportsSourceNone, tailwindcss };
 //# sourceMappingURL=tailwindcss.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tailwindcss.d.ts","names":[],"sources":["../../src/transformers/tailwindcss.ts"],"mappings":";;;;;;;;iBAgKgB,yBAAyB;;;;;;;;;;;;;;;;;;iBAwBnB,YAAY,KAAK,aAAa,QAAQ,eAAe,mBAAmB,yBAAyB,QAAQ"}
+{"version":3,"file":"tailwindcss.d.ts","names":[],"sources":["../../src/transformers/tailwindcss.ts"],"mappings":";;;;;;;;wBAgKgB,yBAAyB;;;;;;;;;;;;;;;;;;wBAwBnB,YAAY,KAAK,aAAa,QAAQ,eAAe,mBAAmB,yBAAyB,QAAQ"}

package/dist/transformers/urlQuery.d.ts

@@ -23,13 +23,12 @@ import { ChildNode } from "domhandler";
  * // 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;
+export 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[];
+export 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

@@ -1 +1 @@
-{"version":3,"file":"urlQuery.d.ts","names":[],"sources":["../../src/transformers/urlQuery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;iBAiDgB,SACd,cACA,SAAQ,yBACR,UAAS;;;;;;iBAUK,YACd,KAAK,aACL,SAAQ,yBACR,UAAS,kBACR"}
+{"version":3,"file":"urlQuery.d.ts","names":[],"sources":["../../src/transformers/urlQuery.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;wBAiDgB,SACd,cACA,SAAQ,yBACR,UAAS;;;;;;wBAUK,YACd,KAAK,aACL,SAAQ,yBACR,UAAS,kBACR"}

package/dist/types/config.d.ts

@@ -6,7 +6,7 @@ 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 {
+export interface UrlQueryOptions {
   /**
    * CSS selectors for elements to process.
    *
@@ -32,10 +32,10 @@ interface UrlQueryOptions {
    */
   qs?: Record<string, unknown>;
 }
-type UrlQuery = Record<string, unknown> & {
+export type UrlQuery = Record<string, unknown> & {
   _options?: UrlQueryOptions;
 };
-interface UrlConfig {
+export interface UrlConfig {
   /**
    * Append query parameters to URLs in your HTML.
    *
@@ -71,7 +71,7 @@ interface UrlConfig {
     inlineCss?: boolean;
   };
 }
-interface CssConfig {
+export interface CssConfig {
   /**
    * Base directory for Tailwind CSS `@source` resolution.
    *
@@ -257,7 +257,7 @@ interface CssConfig {
    */
   exclude?: string[];
 }
-interface AttributesConfig {
+export interface AttributesConfig {
   /**
    * Add attributes to HTML elements.
    *
@@ -302,14 +302,14 @@ interface AttributesConfig {
     value?: string | RegExp;
   }>;
 }
-type EntitiesConfig = boolean | Record<string, string>;
+export 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 {
+export 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';
+export interface ChecksConfig {
   /**
    * Client families to check against. Defaults to the four majors:
    * Gmail, Apple Mail, Outlook, Yahoo. Pass `'all'` to check every client
@@ -325,7 +325,7 @@ interface ChecksConfig {
    */
   level?: 'error' | 'warning' | 'lint';
 }
-interface PostcssConfig {
+export interface PostcssConfig {
   /**
    * Selector prefixes to strip from compiled CSS.
    *
@@ -349,7 +349,7 @@ interface PostcssConfig {
    */
   removeAtRules?: string[];
 }
-interface HtmlConfig {
+export interface HtmlConfig {
   /** Configure HTML attribute transformations. */
   attributes?: AttributesConfig;
   /**
@@ -376,9 +376,9 @@ interface HtmlConfig {
    */
   minify?: boolean | Partial<import('html-crush').Opts>;
 }
-type FilterFunction = (str: string, value: string) => string;
-type FiltersConfig = false | Record<string, FilterFunction>;
-interface MarkdownConfig extends Options {
+export type FilterFunction = (str: string, value: string) => string;
+export type FiltersConfig = false | Record<string, FilterFunction>;
+export interface MarkdownConfig extends Options {
   /**
    * The shiki theme to use for syntax highlighting in Markdown fenced code blocks.
    *
@@ -386,7 +386,7 @@ interface MarkdownConfig extends Options {
    */
   shikiTheme?: import('shiki').BundledTheme;
 }
-interface VueConfig {
+export interface VueConfig {
   /**
    * Vue plugins to register on the app instance before rendering.
    *
@@ -434,7 +434,7 @@ interface VueConfig {
  * column width math, link inlining) always run; they're driven by markup
  * or framework state, not user opt-in.
  */
-interface TransformerToggles {
+export interface TransformerToggles {
   safeSelectors?: boolean;
   attributeToStyle?: boolean;
   inlineCss?: boolean;
@@ -457,7 +457,7 @@ interface TransformerToggles {
  * Control where plaintext files are written, what extension they use,
  * and the options forwarded to `string-strip-html`.
  */
-interface PlaintextConfig {
+export interface PlaintextConfig {
   /**
    * Output directory for plaintext files. When omitted, files are written
    * next to their HTML counterpart in `build.output.path`.
@@ -486,7 +486,7 @@ interface PlaintextConfig {
  * `pathPrefix: false`, intermediate subfolders are dropped from the
  * resolved name (useful for icon sets organized by category).
  */
-type ComponentSource = string | {
+export type ComponentSource = string | {
   /** Directory to scan, resolved relative to `cwd`. */
   path: string;
   /**
@@ -504,7 +504,7 @@ type ComponentSource = string | {
    */
   pathPrefix?: boolean;
 };
-interface MaizzleConfig {
+export interface MaizzleConfig {
   /**
    * Root directory for the Maizzle email project.
    *
@@ -822,5 +822,4 @@ interface MaizzleConfig {
   [key: string]: any;
 }
 //#endregion
-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

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","names":[],"sources":["../../src/types/config.ts"],"mappings":";;;;;;;KAKK,eAAe,YAAY,kBAAkB;UAGjC;;;;;;EAMf;;;;;;EAMA;;;;;;EAMA;;;;;;EAMA,KAAK;;KAGK,WAAW;EACrB,WAAW;;UAGI;;;;;;;;;;;;EAYf,QAAQ;;;;;;;;;;;EAWR;;IAEE;;IAEA,kBAAkB,eAAe;;IAEjC,aAAa;;IAEb;;IAEA;;;UAIa;;;;;;EAMf;;;;;;;;;;;EAWA;;;;;;;;EAQA,kBAAkB;;;;;;;;;;;;;;EAclB,mBAAmB;;;;;;;IAOjB;;;;;;IAMA;;;;;;;IAOA;;;;;;;;;;;;IAYA,mBAAmB;;;;;;;IAOnB;;;;;;;IAOA;;;;;;;IAOA;;;;;;;IAOA,aAAa;MAAiB;MAAe;;;;;;IAK7C;;;;;;;;;;;;;;EAcF;;;;;;IAME,4CAA4C,WAAW;;;;;;;;;EASzD;;;;;;EAMA,iBAAiB;;;;;;;;EAQjB;IAAwB;;;;;;;;;EAQxB;;;;;;;;;;;EAWA,qBAAqB,eA3BJ;;;;;;;;;;;;;EAwCjB;;UAGe;;;;;;;;;;;;;;;;;;EAkBf,cAAc,uBAAuB;;;;;;;;;;;;;;;;;;;;;;EAsBrC,SAAS;IAAiB;IAAc,iBAAiB;;;KAG/C,2BAA2B;;;;;;KAO3B;UAOK;;;;;;EAMf,UAAU;;;;;;;;EAQV;;UAGe;;;;;;;;;;;EAWf;;;;;;;;;;;EAWA;;UAGe;;EAEf,aAAa;;;;;;;;EAQb,iBAAiB;;;;;;EAMjB,mCAAmC;;;;;;;;;EASnC,mBAAmB,6BAA6B;;KAGtC,kBAAkB,aAAa;KAC/B,wBAAwB,eAAe;UAElC,uBAAuB;;;;;;EAMtC,6BAA6B;;UAGd;;;;;;;;;EASf,UAAU,kBAAkB;;EAE5B,aAAa,eAAe;;EAE5B,mBAAmB;;;;;;;;;;;;;;;EAenB,0BAA0B,mBAAmB,cAAc;;;;;;;;;;;;;;;;;;;;UAqB5C;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;UASe;;;;;EAKf;;;;;;EAMA;;;;;;EAMA,UAAU,oCAAoC;;;;;;;;;;;;KAapC;;EAIR;;;;;EAKA;;;;;;;;;EASA;;UAGa;;;;;;;;;;;;;;;EAef;;EAEA,WAAW;;;;;;;;EAQX;;EAEA;;;;;;IAME;;;;;;;;;;;IAWA;;;;;;;;;;;;;;;;;;;EAmBF;IAAuB;IAAkB;;;EAEzC;;;;;;IAME;;;;;;IAMA;;;EAGF;;;;;;;;;;;;;;;;;;;;IAoBE,SAAS,kBAAkB;;;EAG7B;;;;;;IAME;;;;;;;;;;;;;;;IAeA;;;;;;;;;;;IAWA;;;;;;;;;;;;;;;;;;;;IAoBA;;MAEE;;MAEA;;MAEA;;MAEA,YAAY;;;;;;;;;;;;;;;IAed,iBAAiB;;;EAGnB,MAAM;;;;;;;;;;;;;;;EAeN,sBAAsB;;EAEtB,UAAU;;;;;;;;;;;;EAYV,4BAA4B;;;;;;;;;EAS5B,iBAAiB;;;;;;;;;;;;EAYjB,UAAU;;EAEV,MAAM;;EAEN,OAAO;;;;;;;;;;;;;;;;;;;;;;EAsBP,OAAO;;;;;;;;;;;;;;;;EAgBP,MAAM;;;;;;;;;;;;EAYN,QAAQ;;EAKR,gBAAgB;IAAU,QAAQ;eAA2B;;EAE7D,gBAAgB;IAAU,QAAQ;IAAe,UAAU;wBAAmC;;EAE9F,eAAe;IAAU,QAAQ;IAAe,UAAU;IAAc;wBAAmC;;EAE3G,kBAAkB;IAAU,QAAQ;IAAe,UAAU;IAAc;wBAAmC;;EAE9G,cAAc;IAAU;IAAiB,QAAQ;eAA2B;GAG3E"}
+{"version":3,"file":"config.d.ts","names":[],"sources":["../../src/types/config.ts"],"mappings":";;;;;;;KAKK,eAAe,YAAY,kBAAkB;iBAGjC;;;;;;EAMf;;;;;;EAMA;;;;;;EAMA;;;;;;EAMA,KAAK;;YAGK,WAAW;EACrB,WAAW;;iBAGI;;;;;;;;;;;;EAYf,QAAQ;;;;;;;;;;;EAWR;;IAEE;;IAEA,kBAAkB,eAAe;;IAEjC,aAAa;;IAEb;;IAEA;;;iBAIa;;;;;;EAMf;;;;;;;;;;;EAWA;;;;;;;;EAQA,kBAAkB;;;;;;;;;;;;;;EAclB,mBAAmB;;;;;;;IAOjB;;;;;;IAMA;;;;;;;IAOA;;;;;;;;;;;;IAYA,mBAAmB;;;;;;;IAOnB;;;;;;;IAOA;;;;;;;IAOA;;;;;;;IAOA,aAAa;MAAiB;MAAe;;;;;;IAK7C;;;;;;;;;;;;;;EAcF;;;;;;IAME,4CAA4C,WAAW;;;;;;;;;EASzD;;;;;;EAMA,iBAAiB;;;;;;;;EAQjB;IAAwB;;;;;;;;;EAQxB;;;;;;;;;;;EAWA,qBAAqB,eA3BJ;;;;;;;;;;;;;EAwCjB;;iBAGe;;;;;;;;;;;;;;;;;;EAkBf,cAAc,uBAAuB;;;;;;;;;;;;;;;;;;;;;;EAsBrC,SAAS;IAAiB;IAAc,iBAAiB;;;YAG/C,2BAA2B;;;;;;YAO3B;iBAOK;;;;;;EAMf,UAAU;;;;;;;;EAQV;;iBAGe;;;;;;;;;;;EAWf;;;;;;;;;;;EAWA;;iBAGe;;EAEf,aAAa;;;;;;;;EAQb,iBAAiB;;;;;;EAMjB,mCAAmC;;;;;;;;;EASnC,mBAAmB,6BAA6B;;YAGtC,kBAAkB,aAAa;YAC/B,wBAAwB,eAAe;iBAElC,uBAAuB;;;;;;EAMtC,6BAA6B;;iBAGd;;;;;;;;;EASf,UAAU,kBAAkB;;EAE5B,aAAa,eAAe;;EAE5B,mBAAmB;;;;;;;;;;;;;;;EAenB,0BAA0B,mBAAmB,cAAc;;;;;;;;;;;;;;;;;;;;iBAqB5C;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;iBASe;;;;;EAKf;;;;;;EAMA;;;;;;EAMA,UAAU,oCAAoC;;;;;;;;;;;;YAapC;;EAIR;;;;;EAKA;;;;;;;;;EASA;;iBAGa;;;;;;;;;;;;;;;EAef;;EAEA,WAAW;;;;;;;;EAQX;;EAEA;;;;;;IAME;;;;;;;;;;;IAWA;;;;;;;;;;;;;;;;;;;EAmBF;IAAuB;IAAkB;;;EAEzC;;;;;;IAME;;;;;;IAMA;;;EAGF;;;;;;;;;;;;;;;;;;;;IAoBE,SAAS,kBAAkB;;;EAG7B;;;;;;IAME;;;;;;;;;;;;;;;IAeA;;;;;;;;;;;IAWA;;;;;;;;;;;;;;;;;;;;IAoBA;;MAEE;;MAEA;;MAEA;;MAEA,YAAY;;;;;;;;;;;;;;;IAed,iBAAiB;;;EAGnB,MAAM;;;;;;;;;;;;;;;EAeN,sBAAsB;;EAEtB,UAAU;;;;;;;;;;;;EAYV,4BAA4B;;;;;;;;;EAS5B,iBAAiB;;;;;;;;;;;;EAYjB,UAAU;;EAEV,MAAM;;EAEN,OAAO;;;;;;;;;;;;;;;;;;;;;;EAsBP,OAAO;;;;;;;;;;;;;;;;EAgBP,MAAM;;;;;;;;;;;;EAYN,QAAQ;;EAKR,gBAAgB;IAAU,QAAQ;eAA2B;;EAE7D,gBAAgB;IAAU,QAAQ;IAAe,UAAU;wBAAmC;;EAE9F,eAAe;IAAU,QAAQ;IAAe,UAAU;IAAc;wBAAmC;;EAE3G,kBAAkB;IAAU,QAAQ;IAAe,UAAU;IAAc;wBAAmC;;EAE9G,cAAc;IAAU;IAAiB,QAAQ;eAA2B;GAG3E"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","names":[],"sources":["../../../src/utils/ast/parser.ts"],"mappings":";;iBAIgB,MAAM,cAAc,UAAS,oBAAyB"}
+{"version":3,"file":"parser.d.ts","names":[],"sources":["../../../src/utils/ast/parser.ts"],"mappings":";;wBAIgB,MAAM,cAAc,UAAS,oBAAyB"}

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

@@ -1,7 +1,6 @@
 import { ChildNode } from "domhandler";
 import { DomSerializerOptions } from "dom-serializer";
 //#region src/utils/ast/serializer.d.ts
-declare function serialize(dom: ChildNode[], options?: DomSerializerOptions): string;
+export declare function serialize(dom: ChildNode[], options?: DomSerializerOptions): string;
 //#endregion
-export { serialize };
 //# sourceMappingURL=serializer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"serializer.d.ts","names":[],"sources":["../../../src/utils/ast/serializer.ts"],"mappings":";;;iBA0CgB,UAAU,KAAK,aAAa,UAAU"}
+{"version":3,"file":"serializer.d.ts","names":[],"sources":["../../../src/utils/ast/serializer.ts"],"mappings":";;;wBA0CgB,UAAU,KAAK,aAAa,UAAU"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"walker.d.ts","names":[],"sources":["../../../src/utils/ast/walker.ts"],"mappings":";;iBAEgB,KAAK,KAAK,aAAa,WAAW,MAAM"}
+{"version":3,"file":"walker.d.ts","names":[],"sources":["../../../src/utils/ast/walker.ts"],"mappings":";;wBAEgB,KAAK,KAAK,aAAa,WAAW,MAAM"}

package/dist/utils/cloneConfig.d.ts

@@ -7,7 +7,6 @@
  * 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;
+export declare function cloneConfig<T>(value: T): T;
 //#endregion
-export { cloneConfig };
 //# sourceMappingURL=cloneConfig.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cloneConfig.d.ts","names":[],"sources":["../../src/utils/cloneConfig.ts"],"mappings":";;;;;;;;;iBAQgB,YAAY,GAAG,OAAO,IAAI"}
+{"version":3,"file":"cloneConfig.d.ts","names":[],"sources":["../../src/utils/cloneConfig.ts"],"mappings":";;;;;;;;;wBAQgB,YAAY,GAAG,OAAO,IAAI"}

package/dist/utils/compileTailwindCss.d.ts

@@ -2,15 +2,14 @@ import { MaizzleConfig } from "../types/config.js";
 import { GradientCombo } from "../plugins/postcss/flattenGradients.js";
 import postcss from "postcss";
 //#region src/utils/compileTailwindCss.d.ts
-declare function createTailwindProcessor(config: MaizzleConfig, gradientCombos?: GradientCombo[]): postcss.Processor;
-declare function lowerCssSyntax(css: string): string;
-declare function optimizeTailwindCss(css: string, config: MaizzleConfig): Promise<string>;
+export declare function createTailwindProcessor(config: MaizzleConfig, gradientCombos?: GradientCombo[]): postcss.Processor;
+export declare function lowerCssSyntax(css: string): string;
+export declare function optimizeTailwindCss(css: string, config: MaizzleConfig): Promise<string>;
 /**
  * Compile a Tailwind CSS source string into final email-safe CSS:
  * runs @tailwindcss/postcss, lowers modern syntax via lightningcss,
  * then applies cleanup + media-query merging.
  */
-declare function compileTailwindCss(cssInput: string, config: MaizzleConfig, from: string, gradientCombos?: GradientCombo[]): Promise<string>;
+export declare function compileTailwindCss(cssInput: string, config: MaizzleConfig, from: string, gradientCombos?: GradientCombo[]): Promise<string>;
 //#endregion
-export { compileTailwindCss, createTailwindProcessor, lowerCssSyntax, optimizeTailwindCss };
 //# sourceMappingURL=compileTailwindCss.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"compileTailwindCss.d.ts","names":[],"sources":["../../src/utils/compileTailwindCss.ts"],"mappings":";;;;iBAcgB,wBAAwB,QAAQ,eAAe,iBAAgB,kBAAoB,QAAA;iBAkBnF,eAAe;iBAWT,oBAAoB,aAAa,QAAQ,gBAAgB;;;;;;iBAgBzD,mBACpB,kBACA,QAAQ,eACR,cACA,iBAAgB,kBACf"}
+{"version":3,"file":"compileTailwindCss.d.ts","names":[],"sources":["../../src/utils/compileTailwindCss.ts"],"mappings":";;;;wBAcgB,wBAAwB,QAAQ,eAAe,iBAAgB,kBAAoB,QAAA;wBAkBnF,eAAe;wBAWT,oBAAoB,aAAa,QAAQ,gBAAgB;;;;;;wBAgBzD,mBACpB,kBACA,QAAQ,eACR,cACA,iBAAgB,kBACf"}

package/dist/utils/componentSources.d.ts

@@ -5,7 +5,7 @@ import { ComponentSource } from "../types/config.js";
  * resolved and `path` is made absolute. Always carries the same shape
  * regardless of which user-facing form produced it.
  */
-interface NormalizedComponentSource {
+export interface NormalizedComponentSource {
   /** Absolute directory path. */
   path: string;
   /**
@@ -23,8 +23,8 @@ interface NormalizedComponentSource {
  * Normalize a user-supplied `components.source` value into an array
  * of absolute, fully-defaulted entries.
  */
-declare function normalizeComponentSources(sources: ComponentSource | ComponentSource[] | undefined, cwd: string): NormalizedComponentSource[];
-interface ComponentNameOptions {
+export declare function normalizeComponentSources(sources: ComponentSource | ComponentSource[] | undefined, cwd: string): NormalizedComponentSource[];
+export interface ComponentNameOptions {
   /** Absolute path to the component file. */
   filePath: string;
   /** Absolute path to the dir root the component was discovered under. */
@@ -43,7 +43,6 @@ interface ComponentNameOptions {
  * Used both at render time (to register a custom resolver) and at lint
  * time (so the linter can follow component graph correctly).
  */
-declare function componentNameFromPath(opts: ComponentNameOptions): string;
+export declare function componentNameFromPath(opts: ComponentNameOptions): string;
 //#endregion
-export { ComponentNameOptions, NormalizedComponentSource, componentNameFromPath, normalizeComponentSources };
 //# sourceMappingURL=componentSources.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"componentSources.d.ts","names":[],"sources":["../../src/utils/componentSources.ts"],"mappings":";;;;;;;UAQiB;;EAEf;;;;;;;;EAQA;;EAEA;;;;;;iBAOc,0BACd,SAAS,kBAAkB,+BAC3B,cACC;UAqBc;;EAEf;;EAEA;;EAEA;;EAEA;;;;;;;;;;;iBAYc,sBAAsB,MAAM"}
+{"version":3,"file":"componentSources.d.ts","names":[],"sources":["../../src/utils/componentSources.ts"],"mappings":";;;;;;;iBAQiB;;EAEf;;;;;;;;EAQA;;EAEA;;;;;;wBAOc,0BACd,SAAS,kBAAkB,+BAC3B,cACC;iBAqBc;;EAEf;;EAEA;;EAEA;;EAEA;;;;;;;;;;;wBAYc,sBAAsB,MAAM"}

package/dist/utils/cssBox.d.ts

@@ -1,12 +1,12 @@
 import { Root } from "postcss";
 //#region src/utils/cssBox.d.ts
-declare const NO_BORDER_STYLES: Set<string>;
+export declare const NO_BORDER_STYLES: Set<string>;
 /**
  * Parse a length token into px. Handles `Npx`, `Nrem`, `Nem`, `Npt`, and
  * unitless N (treated as px). Returns null for percentages, calc(),
  * keywords, or anything that doesn't reduce to a concrete length.
  */
-declare function lengthToPx(value: string): number | null;
+export declare function lengthToPx(value: string): number | null;
 /**
  * Expand a 1-4 token CSS shorthand (T R B L) into a left/right pair:
  *   1: all sides
@@ -14,7 +14,7 @@ declare function lengthToPx(value: string): number | null;
  *   3: T RL B
  *   4: T R B L
  */
-declare function shorthandSides(value: string): {
+export declare function shorthandSides(value: string): {
   left?: string;
   right?: string;
 };
@@ -22,20 +22,19 @@ declare function shorthandSides(value: string): {
  * Read horizontal padding (left + right) px from a parsed style root.
  * Percentages are skipped since they'd need a known container width.
  */
-declare function horizontalPaddingPx(root: Root): number;
+export declare function horizontalPaddingPx(root: Root): number;
 /**
  * Extract a px length from a CSS border shorthand (e.g. `1px solid red` → 1).
  * Returns null when the value indicates no border (`none` or `hidden`).
  * Defaults to 3px (CSS `medium`) when a visible style is set but no
  * explicit width token is present in the shorthand value.
  */
-declare function shorthandBorderWidthPx(value: string): number | null;
+export declare function shorthandBorderWidthPx(value: string): number | null;
 /**
  * Read horizontal border widths (left + right) px from a parsed style root.
  * Per-side `border-style: none|hidden` overrides count as zero
  * contribution. Returns total px or 0 when nothing resolves.
  */
-declare function horizontalBorderPx(root: Root): number;
+export declare function horizontalBorderPx(root: Root): number;
 //#endregion
-export { NO_BORDER_STYLES, horizontalBorderPx, horizontalPaddingPx, lengthToPx, shorthandBorderWidthPx, shorthandSides };
 //# sourceMappingURL=cssBox.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cssBox.d.ts","names":[],"sources":["../../src/utils/cssBox.ts"],"mappings":";;cAEa,kBAAgB;;;;;;iBAOb,WAAW;;;;;;;;iBAeX,eAAe;EAAkB;EAAe;;;;;;iBAehD,oBAAoB,MAAM;;;;;;;iBA8B1B,uBAAuB;;;;;;iBAevB,mBAAmB,MAAM"}
+{"version":3,"file":"cssBox.d.ts","names":[],"sources":["../../src/utils/cssBox.ts"],"mappings":";;qBAEa,kBAAgB;;;;;;wBAOb,WAAW;;;;;;;;wBAeX,eAAe;EAAkB;EAAe;;;;;;wBAehD,oBAAoB,MAAM;;;;;;;wBA8B1B,uBAAuB;;;;;;wBAevB,mBAAmB,MAAM"}

package/dist/utils/decodeStyleEntities.d.ts

@@ -9,7 +9,6 @@
  * `&` is decoded last so previously-decoded entities are not
  * re-processed.
  */
-declare function decodeStyleEntities(s: string): string;
+export declare function decodeStyleEntities(s: string): string;
 //#endregion
-export { decodeStyleEntities };
 //# sourceMappingURL=decodeStyleEntities.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"decodeStyleEntities.d.ts","names":[],"sources":["../../src/utils/decodeStyleEntities.ts"],"mappings":";;;;;;;;;;;iBAUgB,oBAAoB"}
+{"version":3,"file":"decodeStyleEntities.d.ts","names":[],"sources":["../../src/utils/decodeStyleEntities.ts"],"mappings":";;;;;;;;;;;wBAUgB,oBAAoB"}

package/dist/utils/detect.d.ts

@@ -1,5 +1,4 @@
 //#region src/utils/detect.d.ts
-declare function isLaravel(cwd?: string): boolean;
+export declare function isLaravel(cwd?: string): boolean;
 //#endregion
-export { isLaravel };
 //# sourceMappingURL=detect.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"detect.d.ts","names":[],"sources":["../../src/utils/detect.ts"],"mappings":";iBAGgB,UAAU"}
+{"version":3,"file":"detect.d.ts","names":[],"sources":["../../src/utils/detect.ts"],"mappings":";wBAGgB,UAAU"}

package/dist/utils/output-markers.d.ts

@@ -5,8 +5,8 @@
  * can route their slot content to one output and remove it
  * entirely from the other.
  */
-declare const PLAINTEXT_ONLY_ATTR = "data-maizzle-plaintext-only";
-declare const HTML_ONLY_ATTR = "data-maizzle-html-only";
+export declare const PLAINTEXT_ONLY_ATTR = "data-maizzle-plaintext-only";
+export declare const HTML_ONLY_ATTR = "data-maizzle-html-only";
 /**
  * Strip output markers for the HTML output: drop plaintext-only
  * subtrees entirely, unwrap html-only wrappers (keep children).
@@ -15,7 +15,7 @@ declare const HTML_ONLY_ATTR = "data-maizzle-html-only";
  * the post-transformer formatting (prettify, XHTML self-closing
  * slashes, etc.) survives intact for the typical case.
  */
-declare function stripForHtml(html: string): string;
+export declare function stripForHtml(html: string): string;
 /**
  * Strip output markers for the plaintext source: drop html-only
  * subtrees entirely, unwrap plaintext-only wrappers (keep children).
@@ -23,7 +23,6 @@ declare function stripForHtml(html: string): string;
  * The result is fed to `createPlaintext`, which then strips all
  * remaining tags via `string-strip-html`.
  */
-declare function stripForPlaintext(html: string): string;
+export declare function stripForPlaintext(html: string): string;
 //#endregion
-export { HTML_ONLY_ATTR, PLAINTEXT_ONLY_ATTR, stripForHtml, stripForPlaintext };
 //# sourceMappingURL=output-markers.d.ts.map

package/dist/utils/output-markers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"output-markers.d.ts","names":[],"sources":["../../src/utils/output-markers.ts"],"mappings":";;;;;;;cASa;cACA;;;;;;;;;iBA+CG,aAAa;;;;;;;;iBAgBb,kBAAkB"}
+{"version":3,"file":"output-markers.d.ts","names":[],"sources":["../../src/utils/output-markers.ts"],"mappings":";;;;;;;qBASa;qBACA;;;;;;;;;wBA+CG,aAAa;;;;;;;;wBAgBb,kBAAkB"}

package/dist/utils/staticPaths.d.ts

@@ -0,0 +1,5 @@
+//#region src/utils/staticPaths.d.ts
+/** Absolute static (non-glob) prefix of a source pattern, used as the strip base. */
+export declare function staticBase(pattern: string): string;
+//#endregion
+//# sourceMappingURL=staticPaths.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"staticPaths.d.ts","names":[],"sources":["../../src/utils/staticPaths.ts"],"mappings":";;wBAGgB,WAAW"}

package/dist/utils/staticPaths.js

@@ -0,0 +1,11 @@
+import { dirname, resolve } from "node:path";
+//#region src/utils/staticPaths.ts
+/** Absolute static (non-glob) prefix of a source pattern, used as the strip base. */
+function staticBase(pattern) {
+	const staticPart = pattern.split(/[*{?[]/)[0];
+	return resolve(/[/\\]$/.test(staticPart) ? staticPart : dirname(staticPart));
+}
+//#endregion
+export { staticBase };
+
+//# sourceMappingURL=staticPaths.js.map

package/dist/utils/staticPaths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"staticPaths.js","names":[],"sources":["../../src/utils/staticPaths.ts"],"sourcesContent":["import { dirname, resolve } from 'node:path'\n\n/** Absolute static (non-glob) prefix of a source pattern, used as the strip base. */\nexport function staticBase(pattern: string): string {\n  const staticPart = pattern.split(/[*{?[]/)[0]\n  // Treat both separators as trailing: resolved patterns use '\\' on Windows.\n  return resolve(/[/\\\\]$/.test(staticPart) ? staticPart : dirname(staticPart))\n}\n"],"mappings":";;;AAGA,SAAgB,WAAW,SAAyB;CAClD,MAAM,aAAa,QAAQ,MAAM,QAAQ,CAAC,CAAC;CAE3C,OAAO,QAAQ,SAAS,KAAK,UAAU,IAAI,aAAa,QAAQ,UAAU,CAAC;AAC7E"}

package/dist/utils/url.d.ts

@@ -1,8 +1,7 @@
 //#region src/utils/url.d.ts
-declare const defaultTags: Record<string, string[]>;
-declare const urlAttributes: string[];
-declare function isAbsoluteUrl(url: string): boolean;
-declare function processSrcset(srcset: string, baseUrl: string): string;
+export declare const defaultTags: Record<string, string[]>;
+export declare const urlAttributes: string[];
+export declare function isAbsoluteUrl(url: string): boolean;
+export declare function processSrcset(srcset: string, baseUrl: string): string;
 //#endregion
-export { defaultTags, isAbsoluteUrl, processSrcset, urlAttributes };
 //# sourceMappingURL=url.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"url.d.ts","names":[],"sources":["../../src/utils/url.ts"],"mappings":";cAEa,aAAa;cAcb;iBAEG,cAAc;iBAMd,cAAc,gBAAgB"}
+{"version":3,"file":"url.d.ts","names":[],"sources":["../../src/utils/url.ts"],"mappings":";qBAEa,aAAa;qBAcb;wBAEG,cAAc;wBAMd,cAAc,gBAAgB"}

package/dist/utils/watchPaths.d.ts

@@ -10,7 +10,7 @@
  * as-is — it treats a lone negated pattern as "everything except", which
  * under `some()` would make the predicate true for almost every file.
  */
-declare function createWatchedFileMatcher(patterns: string[], cwd: string): (file: string) => boolean;
+export declare function createWatchedFileMatcher(patterns: string[], cwd: string): (file: string) => boolean;
 /**
  * Derive the directories the dev server watcher must cover explicitly now
  * that its Vite root is the dev UI directory, not the project cwd: the
@@ -26,7 +26,7 @@ declare function createWatchedFileMatcher(patterns: string[], cwd: string): (fil
  * it. Content patterns cannot hit that fallback — they arrive from
  * `resolveConfig` already resolved against the (absolute) root.
  */
-declare function deriveWatchRoots(options: {
+export declare function deriveWatchRoots(options: {
   content: string[];
   componentDirs: string[];
   root?: string;
@@ -34,5 +34,4 @@ declare function deriveWatchRoots(options: {
   cwd: string;
 }): string[];
 //#endregion
-export { createWatchedFileMatcher, deriveWatchRoots };
 //# sourceMappingURL=watchPaths.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"watchPaths.d.ts","names":[],"sources":["../../src/utils/watchPaths.ts"],"mappings":";;;;;;;;;;;;iBAagB,yBAAyB,oBAAoB,eAInD;;;;;;;;;;;;;;;;iBAqBM,iBAAiB;EAC/B;EACA;EACA;EACA;EACA"}
+{"version":3,"file":"watchPaths.d.ts","names":[],"sources":["../../src/utils/watchPaths.ts"],"mappings":";;;;;;;;;;;;wBAagB,yBAAyB,oBAAoB,eAInD;;;;;;;;;;;;;;;;wBAqBM,iBAAiB;EAC/B;EACA;EACA;EACA;EACA"}

package/node_modules/tinyexec/dist/main.d.mts

@@ -1,6 +1,5 @@
 import { ChildProcess, SpawnOptions, SpawnSyncOptions } from "node:child_process";
 import { Readable } from "node:stream";
-
 //#region src/normalize.d.ts
 interface NormalizedSpawnCommand {
   command: string;
@@ -19,8 +18,9 @@ declare function normalizeSpawnCommand(command: string, args?: readonly string[]
 declare class NonZeroExitError extends Error {
   readonly result: CommonOutputApi;
   readonly output?: Output | undefined;
-  get exitCode(): number | undefined;
-  constructor(result: CommonOutputApi, output?: Output | undefined);
+  readonly exitCode: number;
+  get signalCode(): string | null;
+  constructor(result: CommonOutputApi, output?: Output | undefined, command?: string, args?: readonly string[]);
 }
 //#endregion
 //#region src/main.d.ts
@@ -35,6 +35,7 @@ interface CommonOutputApi {
   get pid(): number | undefined;
   get killed(): boolean;
   get exitCode(): number | undefined;
+  get signalCode(): string | null;
 }
 interface OutputApi extends AsyncIterable<string>, CommonOutputApi {
   process: ChildProcess | undefined;
@@ -74,6 +75,7 @@ declare class ExecProcess implements Result {
   get process(): ChildProcess | undefined;
   get pid(): number | undefined;
   get exitCode(): number | undefined;
+  get signalCode(): string | null;
   constructor(command: string, args?: readonly string[], options?: Partial<Options>);
   kill(signal?: KillSignal): boolean;
   get aborted(): boolean;