@maizzle/framework 6.0.0-rc.2 → 6.0.0-rc.21

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

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

package/dist/types/config.js

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

package/dist/types/index.d.ts

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

package/dist/types/index.js

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

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

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

package/dist/utils/ast/index.js

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,8 @@
+import { ChildNode } from "domhandler";
+import { DomSerializerOptions } from "dom-serializer";
+
+//#region src/utils/ast/serializer.d.ts
+declare function serialize(dom: ChildNode[], options?: DomSerializerOptions): string;
+//#endregion
+export { serialize };
+//# 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.js

@@ -0,0 +1,36 @@
+import { walk } from "./walker.js";
+import render from "dom-serializer";
+//#region src/utils/ast/serializer.ts
+/**
+* Re-encode < and > as entities in text nodes inside <code> elements.
+*
+* The DOM parser decodes entities like &#x3C; into raw < in text nodes.
+* With encodeEntities: false the serializer outputs them as-is, which
+* creates broken HTML (e.g. </a> inside a code block closes the real tag).
+*
+* We selectively fix this for <code> contents only, so the rest of the
+* document (where encodeEntities: false is needed) is unaffected.
+*/
+function encodeCodeTextNodes(dom) {
+	walk(dom, (node) => {
+		const el = node;
+		if (el.name !== "code") return;
+		walk(el.children ?? [], (child) => {
+			if (child.type === "text") {
+				const text = child;
+				text.data = text.data.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+			}
+		});
+	});
+}
+function serialize(dom, options) {
+	encodeCodeTextNodes(dom);
+	return render(dom, {
+		encodeEntities: false,
+		...options
+	});
+}
+//#endregion
+export { serialize };
+
+//# sourceMappingURL=serializer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.js","names":[],"sources":["../../../src/utils/ast/serializer.ts"],"sourcesContent":["import render from 'dom-serializer'\nimport type { ChildNode } 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;CACnD,KAAK,MAAM,SAAS;EAClB,MAAM,KAAK;EACX,IAAI,GAAG,SAAS,QAAQ;EAExB,KAAK,GAAG,YAAY,EAAE,GAAG,UAAU;GACjC,IAAI,MAAM,SAAS,QAAQ;IACzB,MAAM,OAAO;IACb,KAAK,OAAO,KAAK,KAAK,QAAQ,MAAM,OAAO,CAAC,QAAQ,MAAM,OAAO;;IAEnE;GACF;;AAGJ,SAAgB,UAAU,KAAkB,SAAwC;CAClF,oBAAoB,IAAI;CACxB,OAAO,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}

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"walker.js","names":[],"sources":["../../../src/utils/ast/walker.ts"],"sourcesContent":["import type { ChildNode } from 'domhandler'\n\nexport function walk(ast: ChildNode[], callback: (node: ChildNode) => void): void {\n  function traverse(node: ChildNode) {\n    callback(node)\n\n    if ('children' in node && node.children && node.children.length > 0) {\n      for (const child of node.children) {\n        traverse(child)\n      }\n    }\n  }\n\n  for (const node of ast) {\n    traverse(node)\n  }\n}\n"],"mappings":";AAEA,SAAgB,KAAK,KAAkB,UAA2C;CAChF,SAAS,SAAS,MAAiB;EACjC,SAAS,KAAK;EAEd,IAAI,cAAc,QAAQ,KAAK,YAAY,KAAK,SAAS,SAAS,GAChE,KAAK,MAAM,SAAS,KAAK,UACvB,SAAS,MAAM;;CAKrB,KAAK,MAAM,QAAQ,KACjB,SAAS,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,54 @@
+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;CAC7D,OAAO,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;CAQlD,OAPe,UAAU;EACvB,UAAU;EACV,MAAM,OAAO,KAAK,IAAI;EACtB,QAAQ;EACR,SAAS,EAAE,IAAI,KAAQ;EACxB,CAEY,CAAC,KAAK,UAAU;;AAG/B,eAAsB,oBAAoB,KAAa,QAAwC;CAC7F,MAAM,UAA4B,CAAC,GAAG,gBAAgB,OAAO,EAAE,mBAAmB,CAAC;CAEnF,MAAM,cAAc,kBAAkB,OAAO;CAC7C,IAAI,aAAa,QAAQ,KAAK,YAAY;CAI1C,QAAO,MAFc,QAAQ,QAAQ,CAAC,QAAQ,KAAK,EAAE,MAAM,KAAA,GAAW,CAAC,EAEzD;;;;;;;AAQhB,eAAsB,mBACpB,UACA,QACA,MACiB;CAIjB,OAAO,oBADS,gBAAe,MAFb,wBAAwB,OACZ,CAAC,QAAQ,UAAU;EAAE;EAAM,QAAQ;EAAY,CAAC,EACxC,IACJ,EAAE,OAAO"}

package/dist/utils/componentSources.d.ts

@@ -0,0 +1,50 @@
+import { ComponentSource } from "../types/config.js";
+
+//#region src/utils/componentSources.d.ts
+/**
+ * Internal representation of a component source after defaults are
+ * resolved and `path` is made absolute. Always carries the same shape
+ * regardless of which user-facing form produced it.
+ */
+interface NormalizedComponentSource {
+  /** Absolute directory path. */
+  path: string;
+  /**
+   * Custom prefix prepended to resolved component names.
+   *   - `undefined` → use folder-name namespace (the `directoryAsNamespace`
+   *     behavior of unplugin-vue-components).
+   *   - `''` (empty string) → no prefix at all; use the bare filename.
+   *   - any other string → exact prefix.
+   */
+  prefix?: string;
+  /** Include intermediate subfolder names in the resolved name. */
+  pathPrefix: boolean;
+}
+/**
+ * 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 {
+  /** Absolute path to the component file. */
+  filePath: string;
+  /** Absolute path to the dir root the component was discovered under. */
+  dirRoot: string;
+  /** See {@link NormalizedComponentSource.prefix}. */
+  prefix?: string;
+  /** See {@link NormalizedComponentSource.pathPrefix}. */
+  pathPrefix: boolean;
+}
+/**
+ * Compute the component name unplugin-vue-components would assign for a
+ * given file under a given dir, mirroring the plugin's
+ * `directoryAsNamespace: true` + `collapseSamePrefixes: true` behavior
+ * and layering custom-prefix sources on top.
+ *
+ * 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;
+//#endregion
+export { ComponentNameOptions, NormalizedComponentSource, componentNameFromPath, normalizeComponentSources };
+//# sourceMappingURL=componentSources.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"componentSources.d.ts","names":[],"sources":["../../src/utils/componentSources.ts"],"mappings":";;;;;AAQA;;;UAAiB,yBAAA;EAEf;EAAA,IAAA;EAUA;;;AAOF;;;;EATE,MAAA;EAYC;EAVD,UAAA;AAAA;;;;;iBAOc,yBAAA,CACd,OAAA,EAAS,eAAA,GAAkB,eAAA,gBAC3B,GAAA,WACC,yBAAA;AAAA,UAqBc,oBAAA;EArBW;EAuB1B,QAAA;EAFmC;EAInC,OAAA;EAJmC;EAMnC,MAAA;EAFA;EAIA,UAAA;AAAA;;;AAYF;;;;;;;iBAAgB,qBAAA,CAAsB,IAAA,EAAM,oBAAA"}

package/dist/utils/componentSources.js

@@ -0,0 +1,50 @@
+import { relative, resolve } from "node:path";
+//#region src/utils/componentSources.ts
+/**
+* Normalize a user-supplied `components.source` value into an array
+* of absolute, fully-defaulted entries.
+*/
+function normalizeComponentSources(sources, cwd) {
+	if (!sources) return [];
+	return (Array.isArray(sources) ? sources : [sources]).map((s) => {
+		if (typeof s === "string") return {
+			path: resolve(cwd, s),
+			prefix: void 0,
+			pathPrefix: true
+		};
+		return {
+			path: resolve(cwd, s.path),
+			prefix: s.prefix,
+			pathPrefix: s.pathPrefix ?? true
+		};
+	});
+}
+function pascalCase(s) {
+	return s.replace(/[-_\s]+(.)/g, (_, c) => c.toUpperCase()).replace(/^(.)/, (c) => c.toUpperCase());
+}
+/**
+* Compute the component name unplugin-vue-components would assign for a
+* given file under a given dir, mirroring the plugin's
+* `directoryAsNamespace: true` + `collapseSamePrefixes: true` behavior
+* and layering custom-prefix sources on top.
+*
+* Used both at render time (to register a custom resolver) and at lint
+* time (so the linter can follow component graph correctly).
+*/
+function componentNameFromPath(opts) {
+	const { filePath, dirRoot, prefix, pathPrefix } = opts;
+	const segments = relative(dirRoot, filePath).replace(/\\/g, "/").replace(/\.(vue|md)$/, "").split("/").map(pascalCase);
+	const fileName = segments.pop() ?? "";
+	if (prefix !== void 0) {
+		const folderPart = pathPrefix ? segments.join("") : "";
+		const stripped = prefix && fileName.startsWith(prefix) ? fileName.slice(prefix.length) : fileName;
+		return prefix + folderPart + stripped;
+	}
+	const folderPart = segments.join("");
+	if (folderPart && fileName.startsWith(folderPart)) return fileName;
+	return folderPart + fileName;
+}
+//#endregion
+export { componentNameFromPath, normalizeComponentSources };
+
+//# sourceMappingURL=componentSources.js.map

package/dist/utils/componentSources.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"componentSources.js","names":[],"sources":["../../src/utils/componentSources.ts"],"sourcesContent":["import { resolve, relative } from 'node:path'\nimport type { ComponentSource } from '../types/config.ts'\n\n/**\n * Internal representation of a component source after defaults are\n * resolved and `path` is made absolute. Always carries the same shape\n * regardless of which user-facing form produced it.\n */\nexport interface NormalizedComponentSource {\n  /** Absolute directory path. */\n  path: string\n  /**\n   * Custom prefix prepended to resolved component names.\n   *   - `undefined` → use folder-name namespace (the `directoryAsNamespace`\n   *     behavior of unplugin-vue-components).\n   *   - `''` (empty string) → no prefix at all; use the bare filename.\n   *   - any other string → exact prefix.\n   */\n  prefix?: string\n  /** Include intermediate subfolder names in the resolved name. */\n  pathPrefix: boolean\n}\n\n/**\n * Normalize a user-supplied `components.source` value into an array\n * of absolute, fully-defaulted entries.\n */\nexport function normalizeComponentSources(\n  sources: ComponentSource | ComponentSource[] | undefined,\n  cwd: string,\n): NormalizedComponentSource[] {\n  if (!sources) return []\n  const list = Array.isArray(sources) ? sources : [sources]\n  return list.map((s) => {\n    if (typeof s === 'string') {\n      return { path: resolve(cwd, s), prefix: undefined, pathPrefix: true }\n    }\n    return {\n      path: resolve(cwd, s.path),\n      prefix: s.prefix,\n      pathPrefix: s.pathPrefix ?? true,\n    }\n  })\n}\n\nfunction pascalCase(s: string): string {\n  return s\n    .replace(/[-_\\s]+(.)/g, (_, c) => c.toUpperCase())\n    .replace(/^(.)/, c => c.toUpperCase())\n}\n\nexport interface ComponentNameOptions {\n  /** Absolute path to the component file. */\n  filePath: string\n  /** Absolute path to the dir root the component was discovered under. */\n  dirRoot: string\n  /** See {@link NormalizedComponentSource.prefix}. */\n  prefix?: string\n  /** See {@link NormalizedComponentSource.pathPrefix}. */\n  pathPrefix: boolean\n}\n\n/**\n * Compute the component name unplugin-vue-components would assign for a\n * given file under a given dir, mirroring the plugin's\n * `directoryAsNamespace: true` + `collapseSamePrefixes: true` behavior\n * and layering custom-prefix sources on top.\n *\n * Used both at render time (to register a custom resolver) and at lint\n * time (so the linter can follow component graph correctly).\n */\nexport function componentNameFromPath(opts: ComponentNameOptions): string {\n  const { filePath, dirRoot, prefix, pathPrefix } = opts\n\n  const rel = relative(dirRoot, filePath).replace(/\\\\/g, '/')\n  const noExt = rel.replace(/\\.(vue|md)$/, '')\n  const segments = noExt.split('/').map(pascalCase)\n  const fileName = segments.pop() ?? ''\n\n  if (prefix !== undefined) {\n    const folderPart = pathPrefix ? segments.join('') : ''\n    const stripped = prefix && fileName.startsWith(prefix)\n      ? fileName.slice(prefix.length)\n      : fileName\n    return prefix + folderPart + stripped\n  }\n\n  const folderPart = segments.join('')\n  if (folderPart && fileName.startsWith(folderPart)) {\n    return fileName\n  }\n  return folderPart + fileName\n}\n"],"mappings":";;;;;;AA2BA,SAAgB,0BACd,SACA,KAC6B;CAC7B,IAAI,CAAC,SAAS,OAAO,EAAE;CAEvB,QADa,MAAM,QAAQ,QAAQ,GAAG,UAAU,CAAC,QAAQ,EAC7C,KAAK,MAAM;EACrB,IAAI,OAAO,MAAM,UACf,OAAO;GAAE,MAAM,QAAQ,KAAK,EAAE;GAAE,QAAQ,KAAA;GAAW,YAAY;GAAM;EAEvE,OAAO;GACL,MAAM,QAAQ,KAAK,EAAE,KAAK;GAC1B,QAAQ,EAAE;GACV,YAAY,EAAE,cAAc;GAC7B;GACD;;AAGJ,SAAS,WAAW,GAAmB;CACrC,OAAO,EACJ,QAAQ,gBAAgB,GAAG,MAAM,EAAE,aAAa,CAAC,CACjD,QAAQ,SAAQ,MAAK,EAAE,aAAa,CAAC;;;;;;;;;;;AAuB1C,SAAgB,sBAAsB,MAAoC;CACxE,MAAM,EAAE,UAAU,SAAS,QAAQ,eAAe;CAIlD,MAAM,WAFM,SAAS,SAAS,SAAS,CAAC,QAAQ,OAAO,IACtC,CAAC,QAAQ,eAAe,GACnB,CAAC,MAAM,IAAI,CAAC,IAAI,WAAW;CACjD,MAAM,WAAW,SAAS,KAAK,IAAI;CAEnC,IAAI,WAAW,KAAA,GAAW;EACxB,MAAM,aAAa,aAAa,SAAS,KAAK,GAAG,GAAG;EACpD,MAAM,WAAW,UAAU,SAAS,WAAW,OAAO,GAClD,SAAS,MAAM,OAAO,OAAO,GAC7B;EACJ,OAAO,SAAS,aAAa;;CAG/B,MAAM,aAAa,SAAS,KAAK,GAAG;CACpC,IAAI,cAAc,SAAS,WAAW,WAAW,EAC/C,OAAO;CAET,OAAO,aAAa"}

package/dist/utils/decodeStyleEntities.d.ts

@@ -0,0 +1,15 @@
+//#region src/utils/decodeStyleEntities.d.ts
+/**
+ * Decode HTML entities that Vue SSR encodes inside `<style>` tags.
+ *
+ * Vue's `renderToString` HTML-encodes quotes and angle brackets within
+ * style elements in templates, breaking CSS like
+ * `@import "tailwindcss"` → `@import &quot;tailwindcss&quot;`.
+ *
+ * `&amp;` is decoded last so previously-decoded entities are not
+ * re-processed.
+ */
+declare function decodeStyleEntities(s: string): string;
+//#endregion
+export { decodeStyleEntities };
+//# 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.js

@@ -0,0 +1,18 @@
+//#region src/utils/decodeStyleEntities.ts
+/**
+* Decode HTML entities that Vue SSR encodes inside `<style>` tags.
+*
+* Vue's `renderToString` HTML-encodes quotes and angle brackets within
+* style elements in templates, breaking CSS like
+* `@import "tailwindcss"` → `@import &quot;tailwindcss&quot;`.
+*
+* `&amp;` is decoded last so previously-decoded entities are not
+* re-processed.
+*/
+function decodeStyleEntities(s) {
+	return s.replace(/&quot;/g, "\"").replace(/&#39;/g, "'").replace(/&apos;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}
+//#endregion
+export { decodeStyleEntities };
+
+//# 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;CACrD,OAAO,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.ts

@@ -0,0 +1,5 @@
+//#region src/utils/detect.d.ts
+declare function isLaravel(cwd?: string): boolean;
+//#endregion
+export { isLaravel };
+//# 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.js

@@ -0,0 +1,10 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+//#region src/utils/detect.ts
+function isLaravel(cwd = process.cwd()) {
+	return existsSync(resolve(cwd, "artisan"));
+}
+//#endregion
+export { isLaravel };
+
+//# 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;CAC9D,OAAO,WAAW,QAAQ,KAAK,UAAU,CAAC"}

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

@@ -0,0 +1,29 @@
+//#region src/utils/output-markers.d.ts
+/**
+ * Sentinel attributes the `<Plaintext>` and `<NotPlaintext>`
+ * components stamp on their wrapper `<div>` so the build step
+ * 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";
+/**
+ * Strip output markers for the HTML output: drop plaintext-only
+ * subtrees entirely, unwrap html-only wrappers (keep children).
+ *
+ * When no markers are present, the input is returned unchanged so
+ * the post-transformer formatting (prettify, XHTML self-closing
+ * slashes, etc.) survives intact for the typical case.
+ */
+declare function stripForHtml(html: string): string;
+/**
+ * Strip output markers for the plaintext source: drop html-only
+ * subtrees entirely, unwrap plaintext-only wrappers (keep children).
+ *
+ * The result is fed to `createPlaintext`, which then strips all
+ * remaining tags via `string-strip-html`.
+ */
+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

@@ -0,0 +1 @@
+{"version":3,"file":"output-markers.d.ts","names":[],"sources":["../../src/utils/output-markers.ts"],"mappings":";;AASA;;;;;cAAa,mBAAA;AAAA,cACA,cAAA;;;;AA+Cb;;;;;iBAAgB,YAAA,CAAa,IAAA;;;;;;;;iBAgBb,iBAAA,CAAkB,IAAA"}

package/dist/utils/output-markers.js

@@ -0,0 +1,68 @@
+import { parse } from "./ast/parser.js";
+import { serialize } from "./ast/serializer.js";
+import "./ast/index.js";
+//#region src/utils/output-markers.ts
+/**
+* Sentinel attributes the `<Plaintext>` and `<NotPlaintext>`
+* components stamp on their wrapper `<div>` so the build step
+* can route their slot content to one output and remove it
+* entirely from the other.
+*/
+const PLAINTEXT_ONLY_ATTR = "data-maizzle-plaintext-only";
+const HTML_ONLY_ATTR = "data-maizzle-html-only";
+const isElement = (n) => n.type === "tag";
+/**
+* Apply marker rules to a forest of nodes.
+*
+* - `drop` removes the matched element and its descendants.
+* - `unwrap` removes the wrapper element but keeps its children,
+*   splicing them into the parent's child list in place.
+*
+* Non-matching elements recurse so nested markers are handled.
+*/
+function applyRules(nodes, rules) {
+	const out = [];
+	for (const n of nodes) {
+		if (isElement(n)) {
+			const match = rules.find(([attr]) => n.attribs?.[attr] !== void 0);
+			if (match) {
+				const [, op] = match;
+				if (op === "drop") continue;
+				out.push(...applyRules(n.children ?? [], rules));
+				continue;
+			}
+			if (n.children?.length) n.children = applyRules(n.children, rules);
+		}
+		out.push(n);
+	}
+	return out;
+}
+const hasMarkers = (html) => html.includes("data-maizzle-plaintext-only") || html.includes("data-maizzle-html-only");
+/**
+* Strip output markers for the HTML output: drop plaintext-only
+* subtrees entirely, unwrap html-only wrappers (keep children).
+*
+* When no markers are present, the input is returned unchanged so
+* the post-transformer formatting (prettify, XHTML self-closing
+* slashes, etc.) survives intact for the typical case.
+*/
+function stripForHtml(html) {
+	if (!hasMarkers(html)) return html;
+	const isXhtml = /<!DOCTYPE\s+[^>]*xhtml/i.test(html);
+	return serialize(applyRules(parse(html), [[PLAINTEXT_ONLY_ATTR, "drop"], [HTML_ONLY_ATTR, "unwrap"]]), { selfClosingTags: isXhtml });
+}
+/**
+* Strip output markers for the plaintext source: drop html-only
+* subtrees entirely, unwrap plaintext-only wrappers (keep children).
+*
+* The result is fed to `createPlaintext`, which then strips all
+* remaining tags via `string-strip-html`.
+*/
+function stripForPlaintext(html) {
+	if (!hasMarkers(html)) return html;
+	return serialize(applyRules(parse(html), [[HTML_ONLY_ATTR, "drop"], [PLAINTEXT_ONLY_ATTR, "unwrap"]]));
+}
+//#endregion
+export { HTML_ONLY_ATTR, PLAINTEXT_ONLY_ATTR, stripForHtml, stripForPlaintext };
+
+//# sourceMappingURL=output-markers.js.map

package/dist/utils/output-markers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-markers.js","names":[],"sources":["../../src/utils/output-markers.ts"],"sourcesContent":["import { parse, serialize } from './ast/index.ts'\nimport type { ChildNode, Element } from 'domhandler'\n\n/**\n * Sentinel attributes the `<Plaintext>` and `<NotPlaintext>`\n * components stamp on their wrapper `<div>` so the build step\n * can route their slot content to one output and remove it\n * entirely from the other.\n */\nexport const PLAINTEXT_ONLY_ATTR = 'data-maizzle-plaintext-only'\nexport const HTML_ONLY_ATTR = 'data-maizzle-html-only'\n\ntype Op = 'drop' | 'unwrap'\ntype Rule = readonly [attr: string, op: Op]\n\nconst isElement = (n: ChildNode): n is Element => n.type === 'tag'\n\n/**\n * Apply marker rules to a forest of nodes.\n *\n * - `drop` removes the matched element and its descendants.\n * - `unwrap` removes the wrapper element but keeps its children,\n *   splicing them into the parent's child list in place.\n *\n * Non-matching elements recurse so nested markers are handled.\n */\nfunction applyRules(nodes: ChildNode[], rules: readonly Rule[]): ChildNode[] {\n  const out: ChildNode[] = []\n  for (const n of nodes) {\n    if (isElement(n)) {\n      const match = rules.find(([attr]) => n.attribs?.[attr] !== undefined)\n      if (match) {\n        const [, op] = match\n        if (op === 'drop') continue\n        out.push(...applyRules((n.children ?? []) as ChildNode[], rules))\n        continue\n      }\n      if (n.children?.length) {\n        n.children = applyRules(n.children as ChildNode[], rules) as Element['children']\n      }\n    }\n    out.push(n)\n  }\n  return out\n}\n\nconst hasMarkers = (html: string): boolean =>\n  html.includes(PLAINTEXT_ONLY_ATTR) || html.includes(HTML_ONLY_ATTR)\n\n/**\n * Strip output markers for the HTML output: drop plaintext-only\n * subtrees entirely, unwrap html-only wrappers (keep children).\n *\n * When no markers are present, the input is returned unchanged so\n * the post-transformer formatting (prettify, XHTML self-closing\n * slashes, etc.) survives intact for the typical case.\n */\nexport function stripForHtml(html: string): string {\n  if (!hasMarkers(html)) return html\n  const isXhtml = /<!DOCTYPE\\s+[^>]*xhtml/i.test(html)\n  return serialize(applyRules(parse(html), [\n    [PLAINTEXT_ONLY_ATTR, 'drop'],\n    [HTML_ONLY_ATTR, 'unwrap'],\n  ]), { selfClosingTags: isXhtml })\n}\n\n/**\n * Strip output markers for the plaintext source: drop html-only\n * subtrees entirely, unwrap plaintext-only wrappers (keep children).\n *\n * The result is fed to `createPlaintext`, which then strips all\n * remaining tags via `string-strip-html`.\n */\nexport function stripForPlaintext(html: string): string {\n  if (!hasMarkers(html)) return html\n  return serialize(applyRules(parse(html), [\n    [HTML_ONLY_ATTR, 'drop'],\n    [PLAINTEXT_ONLY_ATTR, 'unwrap'],\n  ]))\n}\n"],"mappings":";;;;;;;;;;AASA,MAAa,sBAAsB;AACnC,MAAa,iBAAiB;AAK9B,MAAM,aAAa,MAA+B,EAAE,SAAS;;;;;;;;;;AAW7D,SAAS,WAAW,OAAoB,OAAqC;CAC3E,MAAM,MAAmB,EAAE;CAC3B,KAAK,MAAM,KAAK,OAAO;EACrB,IAAI,UAAU,EAAE,EAAE;GAChB,MAAM,QAAQ,MAAM,MAAM,CAAC,UAAU,EAAE,UAAU,UAAU,KAAA,EAAU;GACrE,IAAI,OAAO;IACT,MAAM,GAAG,MAAM;IACf,IAAI,OAAO,QAAQ;IACnB,IAAI,KAAK,GAAG,WAAY,EAAE,YAAY,EAAE,EAAkB,MAAM,CAAC;IACjE;;GAEF,IAAI,EAAE,UAAU,QACd,EAAE,WAAW,WAAW,EAAE,UAAyB,MAAM;;EAG7D,IAAI,KAAK,EAAE;;CAEb,OAAO;;AAGT,MAAM,cAAc,SAClB,KAAK,SAAA,8BAA6B,IAAI,KAAK,SAAA,yBAAwB;;;;;;;;;AAUrE,SAAgB,aAAa,MAAsB;CACjD,IAAI,CAAC,WAAW,KAAK,EAAE,OAAO;CAC9B,MAAM,UAAU,0BAA0B,KAAK,KAAK;CACpD,OAAO,UAAU,WAAW,MAAM,KAAK,EAAE,CACvC,CAAC,qBAAqB,OAAO,EAC7B,CAAC,gBAAgB,SAAS,CAC3B,CAAC,EAAE,EAAE,iBAAiB,SAAS,CAAC;;;;;;;;;AAUnC,SAAgB,kBAAkB,MAAsB;CACtD,IAAI,CAAC,WAAW,KAAK,EAAE,OAAO;CAC9B,OAAO,UAAU,WAAW,MAAM,KAAK,EAAE,CACvC,CAAC,gBAAgB,OAAO,EACxB,CAAC,qBAAqB,SAAS,CAChC,CAAC,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}

@@ -1,5 +1,4 @@
 import isUrl from "is-url-superb";
-
 //#region src/utils/url.ts
 const defaultTags = {
 	a: ["href"],
@@ -26,7 +25,7 @@ function processSrcset(srcset, baseUrl) {
 		return parts.join(" ");
 	}).join(", ");
 }
-
 //#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;CAClD,IAAI,CAAC,KAAK,OAAO;CAEjB,OAAO,IAAI,WAAW,KAAK,IAAI,IAAI,WAAW,IAAI,IAAI,IAAI,WAAW,IAAI,IAAI,MAAM,IAAI;;AAGzF,SAAgB,cAAc,QAAgB,SAAyB;CACrE,OAAO,OAAO,MAAM,IAAI,CAAC,KAAI,UAAS;EACpC,MAAM,QAAQ,MAAM,MAAM,CAAC,MAAM,MAAM;EAEvC,IAAI,MAAM,MAAM,CAAC,cAAc,MAAM,GAAG,EACtC,MAAM,KAAK,UAAU,MAAM;EAG7B,OAAO,MAAM,KAAK,IAAI;GACtB,CAAC,KAAK,KAAK"}

package/dist/utils/watchPaths.d.ts

@@ -0,0 +1,11 @@
+//#region src/utils/watchPaths.d.ts
+/**
+ * Build a predicate that tells whether an absolute file path emitted by
+ * chokidar matches any of the given globs. Patterns are interpreted as
+ * project-relative; a leading `./` is stripped so user-supplied globs like
+ * `./locales/**` behave identically to `locales/**`.
+ */
+declare function createWatchedFileMatcher(patterns: string[], cwd: string): (file: string) => boolean;
+//#endregion
+export { createWatchedFileMatcher };
+//# sourceMappingURL=watchPaths.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"watchPaths.d.ts","names":[],"sources":["../../src/utils/watchPaths.ts"],"mappings":";;AAQA;;;;;iBAAgB,wBAAA,CAAyB,QAAA,YAAoB,GAAA,YAEnD,IAAA"}

package/dist/utils/watchPaths.js

@@ -0,0 +1,19 @@
+import { matchesGlob, relative } from "node:path";
+//#region src/utils/watchPaths.ts
+/**
+* Build a predicate that tells whether an absolute file path emitted by
+* chokidar matches any of the given globs. Patterns are interpreted as
+* project-relative; a leading `./` is stripped so user-supplied globs like
+* `./locales/**` behave identically to `locales/**`.
+*/
+function createWatchedFileMatcher(patterns, cwd) {
+	const normalized = patterns.map((p) => p.replace(/^\.\//, ""));
+	return (file) => {
+		const rel = relative(cwd, file).replace(/\\/g, "/");
+		return normalized.some((p) => matchesGlob(rel, p));
+	};
+}
+//#endregion
+export { createWatchedFileMatcher };
+
+//# sourceMappingURL=watchPaths.js.map

package/dist/utils/watchPaths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchPaths.js","names":[],"sources":["../../src/utils/watchPaths.ts"],"sourcesContent":["import { matchesGlob, relative } from 'node:path'\n\n/**\n * Build a predicate that tells whether an absolute file path emitted by\n * chokidar matches any of the given globs. Patterns are interpreted as\n * project-relative; a leading `./` is stripped so user-supplied globs like\n * `./locales/**` behave identically to `locales/**`.\n */\nexport function createWatchedFileMatcher(patterns: string[], cwd: string) {\n  const normalized = patterns.map(p => p.replace(/^\\.\\//, ''))\n  return (file: string) => {\n    const rel = relative(cwd, file).replace(/\\\\/g, '/')\n    return normalized.some(p => matchesGlob(rel, p))\n  }\n}\n"],"mappings":";;;;;;;;AAQA,SAAgB,yBAAyB,UAAoB,KAAa;CACxE,MAAM,aAAa,SAAS,KAAI,MAAK,EAAE,QAAQ,SAAS,GAAG,CAAC;CAC5D,QAAQ,SAAiB;EACvB,MAAM,MAAM,SAAS,KAAK,KAAK,CAAC,QAAQ,OAAO,IAAI;EACnD,OAAO,WAAW,MAAK,MAAK,YAAY,KAAK,EAAE,CAAC"}

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