@maizzle/framework 6.1.4 → 6.1.6

package/dist/server/ui/pages/Preview.vue

@@ -888,8 +888,8 @@ const stripeBg = {
             <div class="w-1 h-12 rounded-full bg-gray-300 dark:bg-gray-600 group-hover:bg-gray-400 group-active:bg-gray-500 dark:group-hover:bg-gray-500 dark:group-active:bg-gray-400 transition-colors" />
           </div>
           <!-- Iframe -->
-          <div ref="wrapperEl" class="absolute inset-0 min-[430px]:inset-5 border border-gray-200 dark:border-gray-800">
-            <ScrollArea class="h-full w-full bg-white dark:bg-gray-950">
+          <div ref="wrapperEl" class="absolute inset-0 min-[430px]:inset-5 ring-1 ring-gray-200 dark:ring-gray-800">
+            <ScrollArea class="h-full w-full bg-white dark:bg-gray-950 [&_[data-slot=scroll-area-thumb]]:bg-black/40 [&_[data-slot=scroll-area-thumb]]:shadow-[0_0_0_1px_rgba(255,255,255,0.5)]">
               <iframe
                 ref="iframeEl"
                 :srcdoc="srcdoc"

package/dist/tests/render/_helpers.d.ts

@@ -1,6 +1,5 @@
 //#region src/tests/render/_helpers.d.ts
-declare function createTempProject(): string;
-declare function writeSfc(dir: string, path: string, content: string): void;
+export declare function createTempProject(): string;
+export declare function writeSfc(dir: string, path: string, content: string): void;
 //#endregion
-export { createTempProject, writeSfc };
 //# sourceMappingURL=_helpers.d.ts.map

package/dist/tests/render/_helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_helpers.d.ts","names":[],"sources":["../../../src/tests/render/_helpers.ts"],"mappings":";iBAIgB;iBAKA,SAAS,aAAa,cAAc"}
+{"version":3,"file":"_helpers.d.ts","names":[],"sources":["../../../src/tests/render/_helpers.ts"],"mappings":";wBAIgB;wBAKA,SAAS,aAAa,cAAc"}

package/dist/transformers/addAttributes.d.ts

@@ -29,13 +29,12 @@ import { ChildNode } from "domhandler";
  *   },
  * })
  */
-declare function addAttributes(html: string, config?: AttributesConfig): string;
+export declare function addAttributes(html: string, config?: AttributesConfig): string;
 /**
  * DOM-form of {@link addAttributes} 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 addAttributesDom(dom: ChildNode[], config?: AttributesConfig): ChildNode[];
+export declare function addAttributesDom(dom: ChildNode[], config?: AttributesConfig): ChildNode[];
 //#endregion
-export { addAttributes, addAttributesDom };
 //# sourceMappingURL=addAttributes.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"addAttributes.d.ts","names":[],"sources":["../../src/transformers/addAttributes.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+CgB,cAAc,cAAc,SAAQ;;;;;;iBASpC,iBAAiB,KAAK,aAAa,SAAQ,mBAAwB"}
+{"version":3,"file":"addAttributes.d.ts","names":[],"sources":["../../src/transformers/addAttributes.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+CgB,cAAc,cAAc,SAAQ;;;;;;wBASpC,iBAAiB,KAAK,aAAa,SAAQ,mBAAwB"}

package/dist/transformers/attributeToStyle.d.ts

@@ -25,13 +25,12 @@ import { ChildNode } from "domhandler";
  * // Restrict to specific attributes:
  * const limited = attributeToStyle(html, ['width', 'height'])
  */
-declare function attributeToStyle(html: string, attributes?: boolean | string[]): string;
+export declare function attributeToStyle(html: string, attributes?: boolean | string[]): string;
 /**
  * DOM-form of {@link attributeToStyle} 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 attributeToStyleDom(dom: ChildNode[], attributes?: boolean | string[]): ChildNode[];
+export declare function attributeToStyleDom(dom: ChildNode[], attributes?: boolean | string[]): ChildNode[];
 //#endregion
-export { attributeToStyle, attributeToStyleDom };
 //# sourceMappingURL=attributeToStyle.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"attributeToStyle.d.ts","names":[],"sources":["../../src/transformers/attributeToStyle.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCgB,iBAAiB,cAAc;;;;;;iBAS/B,oBAAoB,KAAK,aAAa,kCAAwC"}
+{"version":3,"file":"attributeToStyle.d.ts","names":[],"sources":["../../src/transformers/attributeToStyle.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiCgB,iBAAiB,cAAc;;;;;;wBAS/B,oBAAoB,KAAK,aAAa,kCAAwC"}

package/dist/transformers/base.d.ts

@@ -3,7 +3,7 @@ import { ChildNode } from "domhandler";
 /**
  * Options for the `base` transformer.
  */
-interface BaseUrlOptions {
+export interface BaseUrlOptions {
   /** Base URL to prepend to relative links. */
   url?: string;
   /**
@@ -58,13 +58,12 @@ interface BaseUrlOptions {
  *   inlineCss: false,
  * })
  */
-declare function base(html: string, options: string | BaseUrlOptions): string;
+export declare function base(html: string, options: string | BaseUrlOptions): string;
 /**
  * DOM-form of {@link base} 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 baseDom(dom: ChildNode[], options: string | BaseUrlOptions | undefined | null | false): ChildNode[];
+export declare function baseDom(dom: ChildNode[], options: string | BaseUrlOptions | undefined | null | false): ChildNode[];
 //#endregion
-export { BaseUrlOptions, base, baseDom };
 //# sourceMappingURL=base.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","names":[],"sources":["../../src/transformers/base.ts"],"mappings":";;;;;UAUiB;;EAEf;;;;;;;;;;EAUA,kBAAkB,eAAe;;;;;EAKjC,aAAa;;;;;;EAMb;;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkIc,KAAK,cAAc,kBAAkB;;;;;;iBASrC,QAAQ,KAAK,aAAa,kBAAkB,4CAA4C"}
+{"version":3,"file":"base.d.ts","names":[],"sources":["../../src/transformers/base.ts"],"mappings":";;;;;iBAUiB;;EAEf;;;;;;;;;;EAUA,kBAAkB,eAAe;;;;;EAKjC,aAAa;;;;;;EAMb;;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;;;;;;wBAkIc,KAAK,cAAc,kBAAkB;;;;;;wBASrC,QAAQ,KAAK,aAAa,kBAAkB,4CAA4C"}

package/dist/transformers/columnWidth.d.ts

@@ -24,7 +24,6 @@ import { ChildNode } from "domhandler";
  * rows cascade. All `data-maizzle-cw*` and `data-maizzle-oh-*` are
  * stripped at the end of the second walk pass.
  */
-declare function columnWidth(dom: ChildNode[]): ChildNode[];
+export declare function columnWidth(dom: ChildNode[]): ChildNode[];
 //#endregion
-export { columnWidth };
 //# sourceMappingURL=columnWidth.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"columnWidth.d.ts","names":[],"sources":["../../src/transformers/columnWidth.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;iBAqKgB,YAAY,KAAK,cAAc"}
+{"version":3,"file":"columnWidth.d.ts","names":[],"sources":["../../src/transformers/columnWidth.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;wBAqKgB,YAAY,KAAK,cAAc"}

package/dist/transformers/entities.d.ts

@@ -5,7 +5,7 @@ import { ChildNode } from "domhandler";
 /**
  * Node types {@link entitiesDom} encodes. Both default to `true`.
  */
-interface EntitiesScope {
+export interface EntitiesScope {
   /** Encode entities in text nodes */
   text?: boolean;
   /**
@@ -40,13 +40,12 @@ interface EntitiesScope {
  * // Disable the transform
  * entities('hello world', false)
  */
-declare function entities(html: string, custom?: EntitiesConfig, scope?: EntitiesScope): string;
+export declare function entities(html: string, custom?: EntitiesConfig, scope?: EntitiesScope): string;
 /**
  * DOM-form of {@link entities} used by the internal transformer pipeline.
  * Takes a parsed DOM, returns a parsed DOM — avoids redundant
  * serialize/parse round-trips when chained with other transformers.
  */
-declare function entitiesDom(dom: ChildNode[], custom?: EntitiesConfig, scope?: EntitiesScope): ChildNode[];
+export declare function entitiesDom(dom: ChildNode[], custom?: EntitiesConfig, scope?: EntitiesScope): ChildNode[];
 //#endregion
-export { EntitiesScope, entities, entitiesDom };
 //# sourceMappingURL=entities.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"entities.d.ts","names":[],"sources":["../../src/transformers/entities.ts"],"mappings":";;;;;;;UAkCiB;;EAEf;;;;;;;;EAQA;;;;;;;;;;;;;;;;;;;;;;;;;iBA0Bc,SAAS,cAAc,SAAQ,gBAAuB,QAAO;;;;;;iBAS7D,YAAY,KAAK,aAAa,SAAQ,gBAAuB,QAAO,gBAAqB"}
+{"version":3,"file":"entities.d.ts","names":[],"sources":["../../src/transformers/entities.ts"],"mappings":";;;;;;;iBAkCiB;;EAEf;;;;;;;;EAQA;;;;;;;;;;;;;;;;;;;;;;;;;wBA0Bc,SAAS,cAAc,SAAQ,gBAAuB,QAAO;;;;;;wBAS7D,YAAY,KAAK,aAAa,SAAQ,gBAAuB,QAAO,gBAAqB"}

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

@@ -1,6 +1,5 @@
 //#region src/transformers/filters/defaults.d.ts
-type FilterFunction = (str: string, value: string) => string;
-declare const defaults: Record<string, FilterFunction>;
+export type FilterFunction = (str: string, value: string) => string;
+export declare const defaults: Record<string, FilterFunction>;
 //#endregion
-export { FilterFunction, defaults };
 //# sourceMappingURL=defaults.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"defaults.d.ts","names":[],"sources":["../../../src/transformers/filters/defaults.ts"],"mappings":";KAAY,kBAAkB,aAAa;cAgB9B,UAAU,eAAe"}
+{"version":3,"file":"defaults.d.ts","names":[],"sources":["../../../src/transformers/filters/defaults.ts"],"mappings":";YAAY,kBAAkB,aAAa;qBAgB9B,UAAU,eAAe"}

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

@@ -1,7 +1,7 @@
 import { FilterFunction } from "./defaults.js";
 import { ChildNode } from "domhandler";
 //#region src/transformers/filters/index.d.ts
-type FiltersConfig = false | Record<string, (str: string, value: string) => string>;
+export type FiltersConfig = false | Record<string, (str: string, value: string) => string>;
 /**
  * Apply transformation functions to the content of elements that have
  * matching filter attributes. Multiple filters on the same element are
@@ -30,13 +30,13 @@ type FiltersConfig = false | Record<string, (str: string, value: string) => stri
  * // Disable all filters
  * filters('<p uppercase>foo</p>', false)
  */
-declare function filters(html: string, custom?: FiltersConfig): string;
+export declare function filters(html: string, custom?: FiltersConfig): string;
 /**
  * DOM-form of {@link filters} used by the internal transformer pipeline.
  * Takes a parsed DOM, returns a parsed DOM — avoids redundant
  * serialize/parse round-trips when chained with other transformers.
  */
-declare function filtersDom(dom: ChildNode[], custom?: FiltersConfig): ChildNode[];
+export declare function filtersDom(dom: ChildNode[], custom?: FiltersConfig): ChildNode[];
 //#endregion
-export { type FilterFunction, FiltersConfig, filters, filtersDom };
+export type { FilterFunction };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/transformers/filters/index.ts"],"mappings":";;;KAMY,wBAAwB,gBAAgB,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2CjD,QAAQ,cAAc,SAAQ;;;;;;iBAS9B,WAAW,KAAK,aAAa,SAAQ,gBAAqB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/transformers/filters/index.ts"],"mappings":";;;YAMY,wBAAwB,gBAAgB,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2CjD,QAAQ,cAAc,SAAQ;;;;;;wBAS9B,WAAW,KAAK,aAAa,SAAQ,gBAAqB"}

package/dist/transformers/format.d.ts

@@ -15,7 +15,7 @@ import { FormatConfig, FormatConfig as FormatConfig$1 } from "oxfmt";
  *
  * const pretty = await format(html, { useTabs: true, tabWidth: 4 })
  */
-declare function format(html: string, options?: FormatConfig$1): Promise<string>;
+export declare function format(html: string, options?: FormatConfig$1): Promise<string>;
 //#endregion
-export { type FormatConfig, format };
+export type { FormatConfig };
 //# sourceMappingURL=format.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"format.d.ts","names":[],"sources":["../../src/transformers/format.ts"],"mappings":";;;;;;;;;;;;;;;;;iBA2BsB,OAAO,cAAc,UAAS,iBAAoB"}
+{"version":3,"file":"format.d.ts","names":[],"sources":["../../src/transformers/format.ts"],"mappings":";;;;;;;;;;;;;;;;;wBA2BsB,OAAO,cAAc,UAAS,iBAAoB"}

package/dist/transformers/imgWidth.d.ts

@@ -13,7 +13,6 @@ import { ChildNode } from "domhandler";
  * content box). When no pixel width is found anywhere, the marker is
  * dropped and the image stays fluid.
  */
-declare function imgWidthDom(dom: ChildNode[]): ChildNode[];
+export declare function imgWidthDom(dom: ChildNode[]): ChildNode[];
 //#endregion
-export { imgWidthDom };
 //# sourceMappingURL=imgWidth.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"imgWidth.d.ts","names":[],"sources":["../../src/transformers/imgWidth.ts"],"mappings":";;;;;;;;;;;;;;;iBAgDgB,YAAY,KAAK,cAAc"}
+{"version":3,"file":"imgWidth.d.ts","names":[],"sources":["../../src/transformers/imgWidth.ts"],"mappings":";;;;;;;;;;;;;;;wBAgDgB,YAAY,KAAK,cAAc"}

package/dist/transformers/index.d.ts

@@ -33,7 +33,6 @@ import { TailwindBlock } from "../composables/renderContext.js";
  * 15. Prettify
  * 16. Minify
  */
-declare function runTransformers(html: string, config: MaizzleConfig, filePath?: string, doctype?: string, tailwindBlocks?: TailwindBlock[], sourceFiles?: string[]): Promise<string>;
+export declare function runTransformers(html: string, config: MaizzleConfig, filePath?: string, doctype?: string, tailwindBlocks?: TailwindBlock[], sourceFiles?: string[]): Promise<string>;
 //#endregion
-export { runTransformers };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/transformers/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2DsB,gBACpB,cACA,QAAQ,eACR,mBACA,kBACA,iBAAiB,iBACjB,yBACC"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/transformers/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2DsB,gBACpB,cACA,QAAQ,eACR,mBACA,kBACA,iBAAiB,iBACjB,yBACC"}

package/dist/transformers/inlineCss.d.ts

@@ -6,7 +6,7 @@ type JuiceOptions = NonNullable<Parameters<typeof juice>[1]>;
  * Options for the `inlineCss` transformer. Accepts every Juice option plus a
  * handful of Maizzle-specific extras.
  */
-interface InlineCssOptions extends JuiceOptions {
+export interface InlineCssOptions extends JuiceOptions {
   /**
    * Convert `0px`, `0em` etc. to `0` in inline styles.
    *
@@ -72,13 +72,12 @@ interface InlineCssOptions extends JuiceOptions {
  *   removeStyleTags: true,
  * })
  */
-declare function inlineCss(html: string, options?: InlineCssOptions): string;
+export declare function inlineCss(html: string, options?: InlineCssOptions): string;
 /**
  * DOM-form of {@link inlineCss} used by the internal transformer pipeline.
  * Takes a parsed DOM, returns a parsed DOM — avoids the redundant
  * serialize/parse round-trips when chained with other transformers.
  */
-declare function inlineCssDom(dom: ChildNode[], options?: InlineCssOptions): ChildNode[];
+export declare function inlineCssDom(dom: ChildNode[], options?: InlineCssOptions): ChildNode[];
 //#endregion
-export { InlineCssOptions, inlineCss, inlineCssDom };
 //# sourceMappingURL=inlineCss.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"inlineCss.d.ts","names":[],"sources":["../../src/transformers/inlineCss.ts"],"mappings":";;;KAMK,eAAe,YAAY,kBAAkB;;;;;UAMjC,yBAAyB;;;;;;EAMxC;;;;;;;EAOA;;;;;EAKA;;;;;EAKA,mBAAmB;;;;;EAKnB;;;;;;;EAOA;;;;;;;EAOA;;;;;EAKA,aAAa;IAAiB;IAAe;;;;;;;;;;;;;;;;;iBAiB/B,UAAU,cAAc,UAAS;;;;;;iBASjC,aAAa,KAAK,aAAa,UAAS,mBAAwB"}
+{"version":3,"file":"inlineCss.d.ts","names":[],"sources":["../../src/transformers/inlineCss.ts"],"mappings":";;;KAMK,eAAe,YAAY,kBAAkB;;;;;iBAMjC,yBAAyB;;;;;;EAMxC;;;;;;;EAOA;;;;;EAKA;;;;;EAKA,mBAAmB;;;;;EAKnB;;;;;;;EAOA;;;;;;;EAOA;;;;;EAKA,aAAa;IAAiB;IAAe;;;;;;;;;;;;;;;;;wBAiB/B,UAAU,cAAc,UAAS;;;;;;wBASjC,aAAa,KAAK,aAAa,UAAS,mBAAwB"}

package/dist/transformers/inlineLink.d.ts

@@ -22,13 +22,12 @@ import { ChildNode } from "domhandler";
  *   '/path/to/template.html',
  * )
  */
-declare function inlineLink(html: string, filePath?: string): Promise<string>;
+export declare function inlineLink(html: string, filePath?: string): Promise<string>;
 /**
  * DOM-form of {@link inlineLink} 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 inlineLinkDom(dom: ChildNode[], filePath?: string): Promise<ChildNode[]>;
+export declare function inlineLinkDom(dom: ChildNode[], filePath?: string): Promise<ChildNode[]>;
 //#endregion
-export { inlineLink, inlineLinkDom };
 //# sourceMappingURL=inlineLink.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"inlineLink.d.ts","names":[],"sources":["../../src/transformers/inlineLink.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;iBA2BsB,WAAW,cAAc,oBAAoB;;;;;;iBAS7C,cAAc,KAAK,aAAa,oBAAoB,QAAQ"}
+{"version":3,"file":"inlineLink.d.ts","names":[],"sources":["../../src/transformers/inlineLink.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;wBA2BsB,WAAW,cAAc,oBAAoB;;;;;;wBAS7C,cAAc,KAAK,aAAa,oBAAoB,QAAQ"}

package/dist/transformers/minify.d.ts

@@ -14,7 +14,7 @@ import { Opts, Opts as MinifyOptions } from "html-crush";
  *
  * const tight = minify('<p>  hello  </p>', { removeIndentations: true })
  */
-declare function minify(html: string, options?: Partial<Opts>): string;
+export declare function minify(html: string, options?: Partial<Opts>): string;
 //#endregion
-export { type MinifyOptions, minify };
+export type { MinifyOptions };
 //# sourceMappingURL=minify.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"minify.d.ts","names":[],"sources":["../../src/transformers/minify.ts"],"mappings":";;;;;;;;;;;;;;;;iBAwBgB,OAAO,cAAc,UAAS,QAAQ"}
+{"version":3,"file":"minify.d.ts","names":[],"sources":["../../src/transformers/minify.ts"],"mappings":";;;;;;;;;;;;;;;;wBAwBgB,OAAO,cAAc,UAAS,QAAQ"}

package/dist/transformers/minifyCodeInline.d.ts

@@ -23,7 +23,6 @@
  * The marker attribute is intentionally generic so any component facing
  * the same formatter-vs-inline-structure problem can opt in.
  */
-declare function minifyCodeInline(html: string): string;
+export declare function minifyCodeInline(html: string): string;
 //#endregion
-export { minifyCodeInline };
 //# sourceMappingURL=minifyCodeInline.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"minifyCodeInline.d.ts","names":[],"sources":["../../src/transformers/minifyCodeInline.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;iBAwBgB,iBAAiB"}
+{"version":3,"file":"minifyCodeInline.d.ts","names":[],"sources":["../../src/transformers/minifyCodeInline.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;wBAwBgB,iBAAiB"}

package/dist/transformers/msoConditionals.d.ts

@@ -1,5 +1,4 @@
 //#region src/transformers/msoConditionals.d.ts
-declare function msoConditionals(html: string): string;
+export declare function msoConditionals(html: string): string;
 //#endregion
-export { msoConditionals };
 //# sourceMappingURL=msoConditionals.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"msoConditionals.d.ts","names":[],"sources":["../../src/transformers/msoConditionals.ts"],"mappings":";iBAkBgB,gBAAgB"}
+{"version":3,"file":"msoConditionals.d.ts","names":[],"sources":["../../src/transformers/msoConditionals.ts"],"mappings":";wBAkBgB,gBAAgB"}

package/dist/transformers/msoPlaceholders.d.ts

@@ -26,7 +26,6 @@ import { ChildNode } from "domhandler";
  * Single collect-walk + single substitute-walk: the same Container div
  * carries both marker kinds, so one element visit fills both maps.
  */
-declare function msoPlaceholders(dom: ChildNode[]): ChildNode[];
+export declare function msoPlaceholders(dom: ChildNode[]): ChildNode[];
 //#endregion
-export { msoPlaceholders };
 //# sourceMappingURL=msoPlaceholders.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"msoPlaceholders.d.ts","names":[],"sources":["../../src/transformers/msoPlaceholders.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8CgB,gBAAgB,KAAK,cAAc"}
+{"version":3,"file":"msoPlaceholders.d.ts","names":[],"sources":["../../src/transformers/msoPlaceholders.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8CgB,gBAAgB,KAAK,cAAc"}

package/dist/transformers/purgeCss.d.ts

@@ -4,7 +4,7 @@ import { Opts } from "email-comb";
 /**
  * Options for the `purgeCss` transformer.
  */
-interface PurgeCssOptions extends Partial<Omit<Opts, 'whitelist'>> {
+export interface PurgeCssOptions extends Partial<Omit<Opts, 'whitelist'>> {
   /**
    * Selectors to preserve regardless of whether they're matched in the
    * markup. Appended to Maizzle's built-in safelist (Gmail, Apple Mail,
@@ -30,13 +30,12 @@ interface PurgeCssOptions extends Partial<Omit<Opts, 'whitelist'>> {
  *   safelist: ['.keep'],
  * })
  */
-declare function purgeCss(html: string, options?: PurgeCssOptions): string;
+export declare function purgeCss(html: string, options?: PurgeCssOptions): string;
 /**
  * DOM-form of {@link purgeCss} 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 purgeCssDom(dom: ChildNode[], options?: PurgeCssOptions): ChildNode[];
+export declare function purgeCssDom(dom: ChildNode[], options?: PurgeCssOptions): ChildNode[];
 //#endregion
-export { PurgeCssOptions, purgeCss, purgeCssDom };
 //# sourceMappingURL=purgeCss.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"purgeCss.d.ts","names":[],"sources":["../../src/transformers/purgeCss.ts"],"mappings":";;;;;;UAsCiB,wBAAwB,QAAQ,KAAK;;;;;;EAMpD;;;;;;;;;;;;;;;;;;;;iBAqBc,SAAS,cAAc,UAAS;;;;;;iBAShC,YAAY,KAAK,aAAa,UAAS,kBAAuB"}
+{"version":3,"file":"purgeCss.d.ts","names":[],"sources":["../../src/transformers/purgeCss.ts"],"mappings":";;;;;;iBAsCiB,wBAAwB,QAAQ,KAAK;;;;;;EAMpD;;;;;;;;;;;;;;;;;;;;wBAqBc,SAAS,cAAc,UAAS;;;;;;wBAShC,YAAY,KAAK,aAAa,UAAS,kBAAuB"}

package/dist/transformers/removeAttributes.d.ts

@@ -3,7 +3,7 @@ import { ChildNode } from "domhandler";
 /**
  * Single attribute-removal rule.
  */
-interface RemoveAttributeRule {
+export interface RemoveAttributeRule {
   /** Attribute name to match. */
   name: string;
   /**
@@ -18,7 +18,7 @@ interface RemoveAttributeRule {
  * Entry passed to {@link removeAttributes}. A bare string targets the named
  * attribute and removes it when its value is empty.
  */
-type RemoveAttributeOption = string | RemoveAttributeRule;
+export type RemoveAttributeOption = string | RemoveAttributeRule;
 /**
  * Remove HTML attributes from elements.
  *
@@ -41,13 +41,12 @@ type RemoveAttributeOption = string | RemoveAttributeRule;
  *   { name: 'role', value: 'none' },
  * ])
  */
-declare function removeAttributes(html: string, attributes?: RemoveAttributeOption[]): string;
+export declare function removeAttributes(html: string, attributes?: RemoveAttributeOption[]): string;
 /**
  * DOM-form of {@link removeAttributes} used by the internal transformer
  * pipeline. Takes a parsed DOM, returns a parsed DOM — avoids redundant
  * serialize/parse round-trips when chained with other transformers.
  */
-declare function removeAttributesDom(dom: ChildNode[], attributes?: RemoveAttributeOption[]): ChildNode[];
+export declare function removeAttributesDom(dom: ChildNode[], attributes?: RemoveAttributeOption[]): ChildNode[];
 //#endregion
-export { RemoveAttributeOption, RemoveAttributeRule, removeAttributes, removeAttributesDom };
 //# sourceMappingURL=removeAttributes.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"removeAttributes.d.ts","names":[],"sources":["../../src/transformers/removeAttributes.ts"],"mappings":";;;;;UAMiB;;EAEf;;;;;;;EAOA,iBAAiB;;;;;;KAOP,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;iBAwB7B,iBAAiB,cAAc,aAAY;;;;;;iBAS3C,oBAAoB,KAAK,aAAa,aAAY,0BAA+B"}
+{"version":3,"file":"removeAttributes.d.ts","names":[],"sources":["../../src/transformers/removeAttributes.ts"],"mappings":";;;;;iBAMiB;;EAEf;;;;;;;EAOA,iBAAiB;;;;;;YAOP,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;wBAwB7B,iBAAiB,cAAc,aAAY;;;;;;wBAS3C,oBAAoB,KAAK,aAAa,aAAY,0BAA+B"}

package/dist/transformers/replaceStrings.d.ts

@@ -9,7 +9,6 @@ import { MaizzleConfig } from "../types/config.js";
  *
  * Character classes must be escaped in keys, e.g. `\\s` for `\s`.
  */
-declare function replaceStrings(html: string, config?: MaizzleConfig): string;
+export declare function replaceStrings(html: string, config?: MaizzleConfig): string;
 //#endregion
-export { replaceStrings };
 //# sourceMappingURL=replaceStrings.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"replaceStrings.d.ts","names":[],"sources":["../../src/transformers/replaceStrings.ts"],"mappings":";;;;;;;;;;;iBAWgB,eAAe,cAAc,SAAQ"}
+{"version":3,"file":"replaceStrings.d.ts","names":[],"sources":["../../src/transformers/replaceStrings.ts"],"mappings":";;;;;;;;;;;wBAWgB,eAAe,cAAc,SAAQ"}

package/dist/transformers/safeSelectors.d.ts

@@ -24,13 +24,12 @@ import { ChildNode } from "domhandler";
  *
  * const out = safeSelectors('<div class="sm:text-base"></div>')
  */
-declare function safeSelectors(html: string, config?: CssConfig): string;
+export declare function safeSelectors(html: string, config?: CssConfig): string;
 /**
  * DOM-form of {@link safeSelectors} 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 safeSelectorsDom(dom: ChildNode[], config?: CssConfig): ChildNode[];
+export declare function safeSelectorsDom(dom: ChildNode[], config?: CssConfig): ChildNode[];
 //#endregion
-export { safeSelectors, safeSelectorsDom };
 //# sourceMappingURL=safeSelectors.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"safeSelectors.d.ts","names":[],"sources":["../../src/transformers/safeSelectors.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;iBA2HgB,cAAc,cAAc,SAAQ;;;;;;iBASpC,iBAAiB,KAAK,aAAa,SAAQ,YAAiB"}
+{"version":3,"file":"safeSelectors.d.ts","names":[],"sources":["../../src/transformers/safeSelectors.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;wBA2HgB,cAAc,cAAc,SAAQ;;;;;;wBASpC,iBAAiB,KAAK,aAAa,SAAQ,YAAiB"}

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"}