@maizzle/framework 6.0.0-rc.16 → 6.0.0-rc.18

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

@@ -1,31 +1,10 @@
-import { walk } from "../utils/ast/walker.mjs";
-import "../utils/ast/index.mjs";
-import resolveProps_default from "../plugins/postcss/resolveProps.mjs";
-import pruneVars_default from "../plugins/postcss/pruneVars.mjs";
-import { tailwindCleanup } from "../plugins/postcss/tailwindCleanup.mjs";
-import { mergeMediaQueries } from "../plugins/postcss/mergeMediaQueries.mjs";
-import { quoteFontFamilies } from "../plugins/postcss/quoteFontFamilies.mjs";
-import { decodeStyleEntities } from "../utils/decodeStyleEntities.mjs";
+import { walk } from "../utils/ast/walker.js";
+import "../utils/ast/index.js";
+import { compileTailwindCss } from "../utils/compileTailwindCss.js";
+import { decodeStyleEntities } from "../utils/decodeStyleEntities.js";
 import { dirname, relative, resolve } from "node:path";
-import postcss from "postcss";
-import tailwindcssPostcss from "@tailwindcss/postcss";
-import postcssCalc from "postcss-calc";
-import safeParser from "postcss-safe-parser";
-import { transform } from "lightningcss";
 
 //#region src/transformers/tailwindcss.ts
-function createProcessor(config) {
-	return postcss([
-		tailwindcssPostcss({
-			base: config.css?.base,
-			transformAssetUrls: false,
-			optimize: false
-		}),
-		resolveProps_default(),
-		postcssCalc({}),
-		pruneVars_default()
-	]);
-}
 /**
 * Check if CSS content uses Tailwind features that require source scanning.
 *
@@ -37,33 +16,6 @@ function usesTailwind(css) {
 	return /((@import|@reference)\s+["'](tailwindcss|@maizzle\/tailwindcss)|@tailwind\s)/.test(css);
 }
 /**
-* Lower modern CSS syntax using lightningcss.
-*
-* Targets IE 1 to maximize syntax lowering — converts modern features
-* like nesting, oklch(), color-mix(), @property, etc. into simple CSS
-* that email clients can understand.
-*/
-function lowerSyntax(css) {
-	return transform({
-		filename: "email.css",
-		code: Buffer.from(css),
-		minify: false,
-		targets: { ie: 128 }
-	}).code.toString();
-}
-/**
-* Run cleanup and media query merging on the compiled CSS.
-*
-* Removes unwanted selectors (:host, :lang) and at-rules (@layer, @property),
-* then sorts and merges media queries.
-*/
-async function optimizeCss(css, config) {
-	const plugins = [...tailwindCleanup(config), quoteFontFamilies()];
-	const mediaPlugin = mergeMediaQueries(config);
-	if (mediaPlugin) plugins.push(mediaPlugin);
-	return (await postcss(plugins).process(css, { from: void 0 })).css;
-}
-/**
 * Build @source directives for Tailwind CSS scanning.
 *
 * Configures two types of sources:
@@ -121,17 +73,13 @@ async function tailwindcss(dom, config, filePath) {
 	const fromPath = filePath ?? resolve(process.cwd(), "template.vue");
 	const fromDir = dirname(fromPath);
 	const sourceDirectives = styleTags.some(({ cssContent }) => usesTailwind(cssContent)) ? buildSourceDirectives(dom, config, fromDir) : "";
-	const processor = createProcessor(config);
 	for (let i = 0; i < styleTags.length; i++) {
 		const { node, cssContent } = styleTags[i];
 		const fullCss = usesTailwind(cssContent) ? `${cssContent}\n${sourceDirectives}` : cssContent;
 		try {
 			node.children = [{
 				type: "text",
-				data: await optimizeCss(lowerSyntax((await processor.process(fullCss, {
-					from: `${fromPath}?style=${i}`,
-					parser: safeParser
-				})).css), config),
+				data: await compileTailwindCss(fullCss, config, `${fromPath}?style=${i}`),
 				parent: node
 			}];
 		} catch {
@@ -147,4 +95,4 @@ async function tailwindcss(dom, config, filePath) {
 
 //#endregion
 export { tailwindcss };
-//# sourceMappingURL=tailwindcss.mjs.map
+//# sourceMappingURL=tailwindcss.js.map

package/dist/transformers/tailwindcss.js.map

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

package/dist/transformers/{urlQuery.d.mts → urlQuery.d.ts}

@@ -1,4 +1,4 @@
-import { UrlConfig } from "../types/config.mjs";
+import { UrlConfig } from "../types/config.js";
 import { ChildNode } from "domhandler";
 
 //#region src/transformers/urlQuery.d.ts
@@ -21,4 +21,4 @@ import { ChildNode } from "domhandler";
 declare function urlQuery(dom: ChildNode[], config?: UrlConfig): ChildNode[];
 //#endregion
 export { urlQuery };
-//# sourceMappingURL=urlQuery.d.mts.map
+//# sourceMappingURL=urlQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"urlQuery.d.ts","names":[],"sources":["../../src/transformers/urlQuery.ts"],"mappings":";;;;;;AA0CA;;;;;;;;;;;;;;iBAAgB,QAAA,CAAS,GAAA,EAAK,SAAA,IAAa,MAAA,GAAQ,SAAA,GAAiB,SAAA"}

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

@@ -1,4 +1,4 @@
-import { isAbsoluteUrl } from "../utils/url.mjs";
+import { isAbsoluteUrl } from "../utils/url.js";
 import queryString from "query-string";
 import { selectAll } from "css-select";
 
@@ -62,4 +62,4 @@ function urlQuery(dom, config = {}) {
 
 //#endregion
 export { urlQuery };
-//# sourceMappingURL=urlQuery.mjs.map
+//# sourceMappingURL=urlQuery.js.map

package/dist/transformers/urlQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"urlQuery.js","names":[],"sources":["../../src/transformers/urlQuery.ts"],"sourcesContent":["import queryString from 'query-string'\nimport { selectAll } from 'css-select'\nimport type { ChildNode, Element } from 'domhandler'\nimport { isAbsoluteUrl } from '../utils/url.ts'\nimport type { UrlConfig, UrlQueryOptions } from '../types/config.ts'\n\nconst DEFAULT_ATTRIBUTES = ['src', 'href', 'poster', 'srcset', 'background']\nconst DEFAULT_TAGS = ['a']\n\n/**\n * Append query parameters to a URL string using query-string.\n */\nfunction appendParams(\n  url: string,\n  params: Record<string, unknown>,\n  qsOptions: queryString.StringifyOptions,\n  strict: boolean,\n): string {\n  if (strict && !isAbsoluteUrl(url)) return url\n\n  return queryString.stringifyUrl(\n    { url, query: params as queryString.StringifiableRecord },\n    qsOptions,\n  )\n}\n\n/**\n * URL query transformer.\n *\n * Appends query parameters to URLs found in specified attributes of\n * specified HTML tags.\n *\n * Reads config from the `config.url` object in `MaizzleConfig` (pass\n * `config.url` directly when calling as a standalone transformer).\n * The `_options` key inside `query` controls behaviour:\n * - `tags`       — CSS selectors for elements to process. Default: `['a']`\n * - `attributes` — attribute names to process. Default: `['src', 'href', 'poster', 'srcset', 'background']`\n * - `strict`     — only append to absolute URLs. Default: `true`\n * - `qs`         — options forwarded to query-string. Default: `{ encode: false }`\n *\n * All non-`_options` keys inside `query` are treated as URL parameters to append.\n */\nexport function urlQuery(dom: ChildNode[], config: UrlConfig = {}): ChildNode[] {\n  const queryConfig = config.query\n\n  if (!queryConfig || Object.keys(queryConfig).length === 0) return dom\n\n  const { _options, ...params } = queryConfig as Record<string, unknown>\n  const options = (_options ?? {}) as UrlQueryOptions\n\n  if (Object.keys(params).length === 0) return dom\n\n  const tags = options.tags ?? DEFAULT_TAGS\n  const attributes = options.attributes ?? DEFAULT_ATTRIBUTES\n  const strict = options.strict ?? true\n  const qsOptions: queryString.StringifyOptions = { encode: false, ...((options.qs ?? {}) as queryString.StringifyOptions) }\n\n  // Use css-select to find all elements matching any of the tag selectors\n  const selector = tags.join(', ')\n  const elements = selectAll(selector, dom) as Element[]\n\n  for (const el of elements) {\n    for (const attr of attributes) {\n      const value = el.attribs[attr]\n      if (!value) continue\n\n      const updated = appendParams(value, params, qsOptions, strict)\n      if (updated !== value) {\n        el.attribs[attr] = updated\n      }\n    }\n  }\n\n  return dom\n}\n"],"mappings":";;;;;AAMA,MAAM,qBAAqB;CAAC;CAAO;CAAQ;CAAU;CAAU;CAAa;AAC5E,MAAM,eAAe,CAAC,IAAI;;;;AAK1B,SAAS,aACP,KACA,QACA,WACA,QACQ;AACR,KAAI,UAAU,CAAC,cAAc,IAAI,CAAE,QAAO;AAE1C,QAAO,YAAY,aACjB;EAAE;EAAK,OAAO;EAA2C,EACzD,UACD;;;;;;;;;;;;;;;;;;AAmBH,SAAgB,SAAS,KAAkB,SAAoB,EAAE,EAAe;CAC9E,MAAM,cAAc,OAAO;AAE3B,KAAI,CAAC,eAAe,OAAO,KAAK,YAAY,CAAC,WAAW,EAAG,QAAO;CAElE,MAAM,EAAE,UAAU,GAAG,WAAW;CAChC,MAAM,UAAW,YAAY,EAAE;AAE/B,KAAI,OAAO,KAAK,OAAO,CAAC,WAAW,EAAG,QAAO;CAE7C,MAAM,OAAO,QAAQ,QAAQ;CAC7B,MAAM,aAAa,QAAQ,cAAc;CACzC,MAAM,SAAS,QAAQ,UAAU;CACjC,MAAM,YAA0C;EAAE,QAAQ;EAAO,GAAK,QAAQ,MAAM,EAAE;EAAoC;CAI1H,MAAM,WAAW,UADA,KAAK,KAAK,KAAK,EACK,IAAI;AAEzC,MAAK,MAAM,MAAM,SACf,MAAK,MAAM,QAAQ,YAAY;EAC7B,MAAM,QAAQ,GAAG,QAAQ;AACzB,MAAI,CAAC,MAAO;EAEZ,MAAM,UAAU,aAAa,OAAO,QAAQ,WAAW,OAAO;AAC9D,MAAI,YAAY,MACd,IAAG,QAAQ,QAAQ;;AAKzB,QAAO"}

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

@@ -1,4 +1,4 @@
-import { RemoveValue } from "../plugins/postcss/removeDeclarations.mjs";
+import { RemoveValue } from "../plugins/postcss/removeDeclarations.js";
 import { Directive, Plugin } from "vue";
 import { Options } from "juice";
 import * as oxfmt from "oxfmt";
@@ -361,6 +361,41 @@ interface VueConfig {
   /** 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, safeClassNames, 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 {
+  safeClassNames?: 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;
+}
 interface MaizzleConfig {
   /**
    * Root directory for the Maizzle email project.
@@ -511,9 +546,15 @@ interface MaizzleConfig {
   /**
    * 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.
    *
@@ -595,5 +636,5 @@ interface MaizzleConfig {
   [key: string]: any;
 }
 //#endregion
-export { AttributesConfig, CaniemailClient, ChecksConfig, CssConfig, EntitiesConfig, FilterFunction, FiltersConfig, HtmlConfig, MaizzleConfig, MarkdownConfig, PostcssConfig, UrlConfig, UrlQuery, UrlQueryOptions, VueConfig };
-//# sourceMappingURL=config.d.mts.map
+export { AttributesConfig, CaniemailClient, ChecksConfig, CssConfig, EntitiesConfig, FilterFunction, FiltersConfig, HtmlConfig, MaizzleConfig, MarkdownConfig, 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/{index.d.mts → index.d.ts}

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

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,5 @@
+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,SAAA"}

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

@@ -12,4 +12,4 @@ function parse(html, options = {}) {
 
 //#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,EAAE,EAAe;CAChF,MAAM,UAAU,IAAI,YAAY;CAChC,MAAM,SAAS,IAAI,OAAO,SAAS,QAAQ;AAC3C,QAAO,MAAM,KAAK;AAClB,QAAO,KAAK;AACZ,QAAO,QAAQ"}

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":";;;;iBA6BgB,SAAA,CAAU,GAAA,EAAK,SAAA,IAAa,OAAA,GAAU,oBAAA"}

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

@@ -1,4 +1,4 @@
-import { walk } from "./walker.mjs";
+import { walk } from "./walker.js";
 import render from "dom-serializer";
 
 //#region src/utils/ast/serializer.ts
@@ -34,4 +34,4 @@ function serialize(dom, options) {
 
 //#endregion
 export { serialize };
-//# sourceMappingURL=serializer.mjs.map
+//# 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 } from 'domhandler'\nimport type { DomSerializerOptions } from 'dom-serializer'\nimport { walk } from './walker.ts'\n\n/**\n * Re-encode < and > as entities in text nodes inside <code> elements.\n *\n * The DOM parser decodes entities like &#x3C; into raw < in text nodes.\n * With encodeEntities: false the serializer outputs them as-is, which\n * creates broken HTML (e.g. </a> inside a code block closes the real tag).\n *\n * We selectively fix this for <code> contents only, so the rest of the\n * document (where encodeEntities: false is needed) is unaffected.\n */\nfunction encodeCodeTextNodes(dom: ChildNode[]): void {\n  walk(dom, (node) => {\n    const el = node as import('domhandler').Element\n    if (el.name !== 'code') return\n\n    walk(el.children ?? [], (child) => {\n      if (child.type === 'text') {\n        const text = child as import('domhandler').Text\n        text.data = text.data.replace(/</g, '&lt;').replace(/>/g, '&gt;')\n      }\n    })\n  })\n}\n\nexport function serialize(dom: ChildNode[], options?: DomSerializerOptions): string {\n  encodeCodeTextNodes(dom)\n  return render(dom, { encodeEntities: false, ...options })\n}\n"],"mappings":";;;;;;;;;;;;;;AAeA,SAAS,oBAAoB,KAAwB;AACnD,MAAK,MAAM,SAAS;EAClB,MAAM,KAAK;AACX,MAAI,GAAG,SAAS,OAAQ;AAExB,OAAK,GAAG,YAAY,EAAE,GAAG,UAAU;AACjC,OAAI,MAAM,SAAS,QAAQ;IACzB,MAAM,OAAO;AACb,SAAK,OAAO,KAAK,KAAK,QAAQ,MAAM,OAAO,CAAC,QAAQ,MAAM,OAAO;;IAEnE;GACF;;AAGJ,SAAgB,UAAU,KAAkB,SAAwC;AAClF,qBAAoB,IAAI;AACxB,QAAO,OAAO,KAAK;EAAE,gBAAgB;EAAO,GAAG;EAAS,CAAC"}

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

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

@@ -9,4 +9,4 @@ function walk(ast, callback) {
 
 //#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;AACjC,WAAS,KAAK;AAEd,MAAI,cAAc,QAAQ,KAAK,YAAY,KAAK,SAAS,SAAS,EAChE,MAAK,MAAM,SAAS,KAAK,SACvB,UAAS,MAAM;;AAKrB,MAAK,MAAM,QAAQ,IACjB,UAAS,KAAK"}

package/dist/utils/compileTailwindCss.d.ts

@@ -0,0 +1,16 @@
+import { MaizzleConfig } from "../types/config.js";
+import postcss from "postcss";
+
+//#region src/utils/compileTailwindCss.d.ts
+declare function createTailwindProcessor(config: MaizzleConfig): postcss.Processor;
+declare function lowerCssSyntax(css: string): string;
+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): Promise<string>;
+//#endregion
+export { compileTailwindCss, createTailwindProcessor, lowerCssSyntax, optimizeTailwindCss };
+//# sourceMappingURL=compileTailwindCss.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compileTailwindCss.d.ts","names":[],"sources":["../../src/utils/compileTailwindCss.ts"],"mappings":";;;;iBAagB,uBAAA,CAAwB,MAAA,EAAQ,aAAA,GAAa,OAAA,CAAA,SAAA;AAAA,iBAe7C,cAAA,CAAe,GAAA;AAAA,iBAWT,mBAAA,CAAoB,GAAA,UAAa,MAAA,EAAQ,aAAA,GAAgB,OAAA;;;;;;iBAgBzD,kBAAA,CACpB,QAAA,UACA,MAAA,EAAQ,aAAA,EACR,IAAA,WACC,OAAA"}

package/dist/utils/compileTailwindCss.js

@@ -0,0 +1,55 @@
+import resolveProps_default from "../plugins/postcss/resolveProps.js";
+import pruneVars_default from "../plugins/postcss/pruneVars.js";
+import { tailwindCleanup } from "../plugins/postcss/tailwindCleanup.js";
+import { mergeMediaQueries } from "../plugins/postcss/mergeMediaQueries.js";
+import { quoteFontFamilies } from "../plugins/postcss/quoteFontFamilies.js";
+import { resolveMaizzleImports } from "../plugins/postcss/resolveMaizzleImports.js";
+import postcss from "postcss";
+import tailwindcssPostcss from "@tailwindcss/postcss";
+import postcssCalc from "postcss-calc";
+import safeParser from "postcss-safe-parser";
+import { transform } from "lightningcss";
+
+//#region src/utils/compileTailwindCss.ts
+function createTailwindProcessor(config) {
+	return postcss([
+		resolveMaizzleImports(),
+		tailwindcssPostcss({
+			base: config.css?.base,
+			transformAssetUrls: false,
+			optimize: false
+		}),
+		resolveProps_default(),
+		postcssCalc({}),
+		pruneVars_default()
+	]);
+}
+function lowerCssSyntax(css) {
+	return transform({
+		filename: "email.css",
+		code: Buffer.from(css),
+		minify: false,
+		targets: { ie: 128 }
+	}).code.toString();
+}
+async function optimizeTailwindCss(css, config) {
+	const plugins = [...tailwindCleanup(config), quoteFontFamilies()];
+	const mediaPlugin = mergeMediaQueries(config);
+	if (mediaPlugin) plugins.push(mediaPlugin);
+	return (await postcss(plugins).process(css, { from: void 0 })).css;
+}
+/**
+* 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.
+*/
+async function compileTailwindCss(cssInput, config, from) {
+	return optimizeTailwindCss(lowerCssSyntax((await createTailwindProcessor(config).process(cssInput, {
+		from,
+		parser: safeParser
+	})).css), config);
+}
+
+//#endregion
+export { compileTailwindCss, createTailwindProcessor, lowerCssSyntax, optimizeTailwindCss };
+//# sourceMappingURL=compileTailwindCss.js.map

package/dist/utils/compileTailwindCss.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileTailwindCss.js","names":["resolveProps","pruneVars"],"sources":["../../src/utils/compileTailwindCss.ts"],"sourcesContent":["import postcss from 'postcss'\nimport tailwindcssPostcss from '@tailwindcss/postcss'\nimport postcssCalc from 'postcss-calc'\nimport safeParser from 'postcss-safe-parser'\nimport { transform } from 'lightningcss'\nimport resolveProps from '../plugins/postcss/resolveProps.ts'\nimport pruneVars from '../plugins/postcss/pruneVars.ts'\nimport { tailwindCleanup } from '../plugins/postcss/tailwindCleanup.ts'\nimport { mergeMediaQueries } from '../plugins/postcss/mergeMediaQueries.ts'\nimport { quoteFontFamilies } from '../plugins/postcss/quoteFontFamilies.ts'\nimport { resolveMaizzleImports } from '../plugins/postcss/resolveMaizzleImports.ts'\nimport type { MaizzleConfig } from '../types/config.ts'\n\nexport function createTailwindProcessor(config: MaizzleConfig) {\n  return postcss([\n    // Must run before @tailwindcss/postcss so it sees absolute import paths\n    resolveMaizzleImports(),\n    tailwindcssPostcss({\n      base: config.css?.base,\n      transformAssetUrls: false,\n      optimize: false,\n    }),\n    resolveProps(),\n    postcssCalc({}),\n    pruneVars(),\n  ])\n}\n\nexport function lowerCssSyntax(css: string): string {\n  const result = transform({\n    filename: 'email.css',\n    code: Buffer.from(css),\n    minify: false,\n    targets: { ie: 4 << 5 },\n  })\n\n  return result.code.toString()\n}\n\nexport async function optimizeTailwindCss(css: string, config: MaizzleConfig): Promise<string> {\n  const plugins: postcss.Plugin[] = [...tailwindCleanup(config), quoteFontFamilies()]\n\n  const mediaPlugin = mergeMediaQueries(config)\n  if (mediaPlugin) plugins.push(mediaPlugin)\n\n  const result = await postcss(plugins).process(css, { from: undefined })\n\n  return result.css\n}\n\n/**\n * Compile a Tailwind CSS source string into final email-safe CSS:\n * runs @tailwindcss/postcss, lowers modern syntax via lightningcss,\n * then applies cleanup + media-query merging.\n */\nexport async function compileTailwindCss(\n  cssInput: string,\n  config: MaizzleConfig,\n  from: string,\n): Promise<string> {\n  const processor = createTailwindProcessor(config)\n  const result = await processor.process(cssInput, { from, parser: safeParser })\n  const lowered = lowerCssSyntax(result.css)\n  return optimizeTailwindCss(lowered, config)\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,SAAgB,wBAAwB,QAAuB;AAC7D,QAAO,QAAQ;EAEb,uBAAuB;EACvB,mBAAmB;GACjB,MAAM,OAAO,KAAK;GAClB,oBAAoB;GACpB,UAAU;GACX,CAAC;EACFA,sBAAc;EACd,YAAY,EAAE,CAAC;EACfC,mBAAW;EACZ,CAAC;;AAGJ,SAAgB,eAAe,KAAqB;AAQlD,QAPe,UAAU;EACvB,UAAU;EACV,MAAM,OAAO,KAAK,IAAI;EACtB,QAAQ;EACR,SAAS,EAAE,IAAI,KAAQ;EACxB,CAAC,CAEY,KAAK,UAAU;;AAG/B,eAAsB,oBAAoB,KAAa,QAAwC;CAC7F,MAAM,UAA4B,CAAC,GAAG,gBAAgB,OAAO,EAAE,mBAAmB,CAAC;CAEnF,MAAM,cAAc,kBAAkB,OAAO;AAC7C,KAAI,YAAa,SAAQ,KAAK,YAAY;AAI1C,SAFe,MAAM,QAAQ,QAAQ,CAAC,QAAQ,KAAK,EAAE,MAAM,QAAW,CAAC,EAEzD;;;;;;;AAQhB,eAAsB,mBACpB,UACA,QACA,MACiB;AAIjB,QAAO,oBADS,gBADD,MADG,wBAAwB,OAAO,CAClB,QAAQ,UAAU;EAAE;EAAM,QAAQ;EAAY,CAAC,EACxC,IAAI,EACN,OAAO"}

package/dist/utils/{decodeStyleEntities.d.mts → decodeStyleEntities.d.ts}

@@ -12,4 +12,4 @@
 declare function decodeStyleEntities(s: string): string;
 //#endregion
 export { decodeStyleEntities };
-//# sourceMappingURL=decodeStyleEntities.d.mts.map
+//# sourceMappingURL=decodeStyleEntities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decodeStyleEntities.d.ts","names":[],"sources":["../../src/utils/decodeStyleEntities.ts"],"mappings":";;AAUA;;;;;;;;;iBAAgB,mBAAA,CAAoB,CAAA"}

package/dist/utils/{decodeStyleEntities.mjs → decodeStyleEntities.js}

@@ -15,4 +15,4 @@ function decodeStyleEntities(s) {
 
 //#endregion
 export { decodeStyleEntities };
-//# sourceMappingURL=decodeStyleEntities.mjs.map
+//# sourceMappingURL=decodeStyleEntities.js.map

package/dist/utils/decodeStyleEntities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decodeStyleEntities.js","names":[],"sources":["../../src/utils/decodeStyleEntities.ts"],"sourcesContent":["/**\n * Decode HTML entities that Vue SSR encodes inside `<style>` tags.\n *\n * Vue's `renderToString` HTML-encodes quotes and angle brackets within\n * style elements in templates, breaking CSS like\n * `@import \"tailwindcss\"` → `@import &quot;tailwindcss&quot;`.\n *\n * `&amp;` is decoded last so previously-decoded entities are not\n * re-processed.\n */\nexport function decodeStyleEntities(s: string): string {\n  return s\n    .replace(/&quot;/g, '\"')\n    .replace(/&#39;/g, \"'\")\n    .replace(/&apos;/g, \"'\")\n    .replace(/&lt;/g, '<')\n    .replace(/&gt;/g, '>')\n    .replace(/&amp;/g, '&')\n}\n"],"mappings":";;;;;;;;;;;AAUA,SAAgB,oBAAoB,GAAmB;AACrD,QAAO,EACJ,QAAQ,WAAW,KAAI,CACvB,QAAQ,UAAU,IAAI,CACtB,QAAQ,WAAW,IAAI,CACvB,QAAQ,SAAS,IAAI,CACrB,QAAQ,SAAS,IAAI,CACrB,QAAQ,UAAU,IAAI"}

package/dist/utils/{detect.d.mts → detect.d.ts}

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

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

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

package/dist/utils/{detect.mjs → detect.js}

@@ -8,4 +8,4 @@ function isLaravel(cwd = process.cwd()) {
 
 //#endregion
 export { isLaravel };
-//# sourceMappingURL=detect.mjs.map
+//# sourceMappingURL=detect.js.map

package/dist/utils/detect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.js","names":[],"sources":["../../src/utils/detect.ts"],"sourcesContent":["import { existsSync } from 'node:fs'\nimport { resolve } from 'node:path'\n\nexport function isLaravel(cwd: string = process.cwd()): boolean {\n  return existsSync(resolve(cwd, 'artisan'))\n}\n"],"mappings":";;;;AAGA,SAAgB,UAAU,MAAc,QAAQ,KAAK,EAAW;AAC9D,QAAO,WAAW,QAAQ,KAAK,UAAU,CAAC"}

package/dist/utils/{url.d.mts → url.d.ts}

@@ -5,4 +5,4 @@ declare function isAbsoluteUrl(url: string): boolean;
 declare function processSrcset(srcset: string, baseUrl: string): string;
 //#endregion
 export { defaultTags, isAbsoluteUrl, processSrcset, urlAttributes };
-//# sourceMappingURL=url.d.mts.map
+//# sourceMappingURL=url.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","names":[],"sources":["../../src/utils/url.ts"],"mappings":";cAEa,WAAA,EAAa,MAAA;AAAA,cAcb,aAAA;AAAA,iBAEG,aAAA,CAAc,GAAA;AAAA,iBAMd,aAAA,CAAc,MAAA,UAAgB,OAAA"}

package/dist/utils/{url.mjs → url.js}

@@ -29,4 +29,4 @@ function processSrcset(srcset, baseUrl) {
 
 //#endregion
 export { defaultTags, isAbsoluteUrl, processSrcset, urlAttributes };
-//# sourceMappingURL=url.mjs.map
+//# sourceMappingURL=url.js.map

package/dist/utils/url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.js","names":[],"sources":["../../src/utils/url.ts"],"sourcesContent":["import isUrl from 'is-url-superb'\n\nexport const defaultTags: Record<string, string[]> = {\n  a: ['href'],\n  img: ['src', 'srcset'],\n  video: ['src', 'poster'],\n  source: ['src', 'srcset'],\n  link: ['href'],\n  script: ['src'],\n  object: ['data'],\n  embed: ['src'],\n  iframe: ['src'],\n  'v:image': ['src'],\n  'v:fill': ['src'],\n}\n\nexport const urlAttributes = [...new Set(Object.values(defaultTags).flat())]\n\nexport function isAbsoluteUrl(url: string): boolean {\n  if (!url) return true\n\n  return url.startsWith('//') || url.startsWith('#') || url.startsWith('?') || isUrl(url)\n}\n\nexport function processSrcset(srcset: string, baseUrl: string): string {\n  return srcset.split(',').map(entry => {\n    const parts = entry.trim().split(/\\s+/)\n\n    if (parts[0] && !isAbsoluteUrl(parts[0])) {\n      parts[0] = baseUrl + parts[0]\n    }\n\n    return parts.join(' ')\n  }).join(', ')\n}\n"],"mappings":";;;AAEA,MAAa,cAAwC;CACnD,GAAG,CAAC,OAAO;CACX,KAAK,CAAC,OAAO,SAAS;CACtB,OAAO,CAAC,OAAO,SAAS;CACxB,QAAQ,CAAC,OAAO,SAAS;CACzB,MAAM,CAAC,OAAO;CACd,QAAQ,CAAC,MAAM;CACf,QAAQ,CAAC,OAAO;CAChB,OAAO,CAAC,MAAM;CACd,QAAQ,CAAC,MAAM;CACf,WAAW,CAAC,MAAM;CAClB,UAAU,CAAC,MAAM;CAClB;AAED,MAAa,gBAAgB,CAAC,GAAG,IAAI,IAAI,OAAO,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC;AAE5E,SAAgB,cAAc,KAAsB;AAClD,KAAI,CAAC,IAAK,QAAO;AAEjB,QAAO,IAAI,WAAW,KAAK,IAAI,IAAI,WAAW,IAAI,IAAI,IAAI,WAAW,IAAI,IAAI,MAAM,IAAI;;AAGzF,SAAgB,cAAc,QAAgB,SAAyB;AACrE,QAAO,OAAO,MAAM,IAAI,CAAC,KAAI,UAAS;EACpC,MAAM,QAAQ,MAAM,MAAM,CAAC,MAAM,MAAM;AAEvC,MAAI,MAAM,MAAM,CAAC,cAAc,MAAM,GAAG,CACtC,OAAM,KAAK,UAAU,MAAM;AAG7B,SAAO,MAAM,KAAK,IAAI;GACtB,CAAC,KAAK,KAAK"}

package/node_modules/@clack/core/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @clack/core
 
+## 1.3.0
+
+### Minor Changes
+
+- 78fd3ae: Remove unused `debug` option key.
+- ea5702e: fix: add engines field expressing node >=20.12 requirement
+- 814ab9a: Add new multiline prompt for multi-line text input.
+
 ## 1.2.0
 
 ### Minor Changes

package/node_modules/@clack/core/dist/index.d.mts

@@ -100,7 +100,6 @@ interface PromptOptions<TValue, Self extends Prompt<TValue>> {
     validate?: ((value: TValue | undefined) => string | Error | undefined) | undefined;
     input?: Readable;
     output?: Writable;
-    debug?: boolean;
     signal?: AbortSignal;
 }
 declare class Prompt<TValue> {
@@ -148,6 +147,7 @@ declare class Prompt<TValue> {
     emit<T extends keyof ClackEvents<TValue>>(event: T, ...data: Parameters<ClackEvents<TValue>[T]>): void;
     prompt(): Promise<symbol | TValue | undefined>;
     protected _isActionKey(char: string | undefined, _key: Key): boolean;
+    protected _shouldSubmit(_char: string | undefined, _key: Key): boolean;
     protected _setValue(value: TValue | undefined): void;
     protected _setUserInput(value: string | undefined, write?: boolean): void;
     protected _clearUserInput(): void;
@@ -258,6 +258,20 @@ declare class GroupMultiSelectPrompt<T extends {
     constructor(opts: GroupMultiSelectOptions<T>);
 }
 
+interface MultiLineOptions extends PromptOptions<string, MultiLinePrompt> {
+    placeholder?: string;
+    defaultValue?: string;
+    showSubmit?: boolean;
+}
+declare class MultiLinePrompt extends Prompt<string> {
+    #private;
+    focused: 'editor' | 'submit';
+    get userInputWithCursor(): string;
+    get cursor(): number;
+    protected _shouldSubmit(_char: string | undefined, _key: Key): boolean;
+    constructor(opts: MultiLineOptions);
+}
+
 interface OptionLike {
     value: any;
     disabled?: boolean;
@@ -343,7 +357,7 @@ interface BlockOptions {
 declare function block({ input, output, overwrite, hideCursor, }?: BlockOptions): () => void;
 declare const getColumns: (output: Writable) => number;
 declare const getRows: (output: Writable) => number;
-declare function wrapTextWithPrefix(output: Writable | undefined, text: string, prefix: string, startPrefix?: string): string;
+declare function wrapTextWithPrefix(output: Writable | undefined, text: string, prefix: string, startPrefix?: string, lineFormatter?: (line: string, index: number) => string): string;
 
-export { AutocompletePrompt, ConfirmPrompt, DatePrompt, GroupMultiSelectPrompt, MultiSelectPrompt, PasswordPrompt, Prompt, SelectKeyPrompt, SelectPrompt, TextPrompt, block, getColumns, getRows, isCancel, settings, updateSettings, wrapTextWithPrefix };
-export type { AutocompleteOptions, ClackSettings, ConfirmOptions, DateFormat, DateOptions, DateParts, GroupMultiSelectOptions, MultiSelectOptions, PasswordOptions, PromptOptions, SelectKeyOptions, SelectOptions, ClackState as State, TextOptions };
+export { AutocompletePrompt, ConfirmPrompt, DatePrompt, GroupMultiSelectPrompt, MultiLinePrompt, MultiSelectPrompt, PasswordPrompt, Prompt, SelectKeyPrompt, SelectPrompt, TextPrompt, block, getColumns, getRows, isCancel, settings, updateSettings, wrapTextWithPrefix };
+export type { AutocompleteOptions, ClackSettings, ConfirmOptions, DateFormat, DateOptions, DateParts, GroupMultiSelectOptions, MultiLineOptions, MultiSelectOptions, PasswordOptions, PromptOptions, SelectKeyOptions, SelectOptions, ClackState as State, TextOptions };