@node-minify/utils 10.4.0 → 10.5.0

package/dist/setPublicFolder.js

@@ -10,13 +10,18 @@ import path from "node:path";
 * Prepend the public folder to each file.
 * @param input Path to file(s)
 * @param publicFolder Path to the public folder
+* @returns Object containing the updated input path(s), or an empty object if `publicFolder` is invalid
 */
 function setPublicFolder(input, publicFolder) {
 	if (typeof publicFolder !== "string") return {};
 	const normalizedPublicFolder = path.normalize(publicFolder);
+	const isAlreadyInPublicFolder = (filePath) => {
+		const relativePath = path.relative(normalizedPublicFolder, filePath);
+		return relativePath === "" || !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+	};
 	const addPublicFolder = (item) => {
 		const normalizedPath = path.normalize(item);
-		return normalizedPath.includes(normalizedPublicFolder) ? normalizedPath : path.normalize(normalizedPublicFolder + item);
+		return isAlreadyInPublicFolder(normalizedPath) ? normalizedPath : path.join(normalizedPublicFolder, normalizedPath);
 	};
 	return { input: Array.isArray(input) ? input.map(addPublicFolder) : addPublicFolder(input) };
 }

package/dist/setPublicFolder.js.map

@@ -1 +1 @@
-{"version":3,"file":"setPublicFolder.js","names":[],"sources":["../src/setPublicFolder.ts"],"sourcesContent":["/*!\n * node-minify\n * Copyright (c) 2011-2026 Rodolphe Stoclin\n * MIT Licensed\n */\n\nimport path from \"node:path\";\n\n/**\n * Prepend the public folder to each file.\n * @param input Path to file(s)\n * @param publicFolder Path to the public folder\n */\nexport function setPublicFolder(\n    input: string | string[],\n    publicFolder: string\n) {\n    if (typeof publicFolder !== \"string\") {\n        return {};\n    }\n\n    const normalizedPublicFolder = path.normalize(publicFolder);\n\n    const addPublicFolder = (item: string) => {\n        const normalizedPath = path.normalize(item);\n        return normalizedPath.includes(normalizedPublicFolder)\n            ? normalizedPath\n            : path.normalize(normalizedPublicFolder + item);\n    };\n\n    return {\n        input: Array.isArray(input)\n            ? input.map(addPublicFolder)\n            : addPublicFolder(input),\n    };\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,SAAgB,gBACZ,OACA,cACF;AACE,KAAI,OAAO,iBAAiB,SACxB,QAAO,EAAE;CAGb,MAAM,yBAAyB,KAAK,UAAU,aAAa;CAE3D,MAAM,mBAAmB,SAAiB;EACtC,MAAM,iBAAiB,KAAK,UAAU,KAAK;AAC3C,SAAO,eAAe,SAAS,uBAAuB,GAChD,iBACA,KAAK,UAAU,yBAAyB,KAAK;;AAGvD,QAAO,EACH,OAAO,MAAM,QAAQ,MAAM,GACrB,MAAM,IAAI,gBAAgB,GAC1B,gBAAgB,MAAM,EAC/B"}
+{"version":3,"file":"setPublicFolder.js","names":[],"sources":["../src/setPublicFolder.ts"],"sourcesContent":["/*!\n * node-minify\n * Copyright (c) 2011-2026 Rodolphe Stoclin\n * MIT Licensed\n */\n\nimport path from \"node:path\";\n\n/**\n * Prepend the public folder to each file.\n * @param input Path to file(s)\n * @param publicFolder Path to the public folder\n * @returns Object containing the updated input path(s), or an empty object if `publicFolder` is invalid\n */\nexport function setPublicFolder(\n    input: string | string[],\n    publicFolder: string\n) {\n    if (typeof publicFolder !== \"string\") {\n        return {};\n    }\n\n    const normalizedPublicFolder = path.normalize(publicFolder);\n\n    const isAlreadyInPublicFolder = (filePath: string) => {\n        const relativePath = path.relative(normalizedPublicFolder, filePath);\n        return (\n            relativePath === \"\" ||\n            (!relativePath.startsWith(\"..\") && !path.isAbsolute(relativePath))\n        );\n    };\n\n    const addPublicFolder = (item: string) => {\n        const normalizedPath = path.normalize(item);\n        return isAlreadyInPublicFolder(normalizedPath)\n            ? normalizedPath\n            : path.join(normalizedPublicFolder, normalizedPath);\n    };\n\n    return {\n        input: Array.isArray(input)\n            ? input.map(addPublicFolder)\n            : addPublicFolder(input),\n    };\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,SAAgB,gBACZ,OACA,cACF;AACE,KAAI,OAAO,iBAAiB,SACxB,QAAO,EAAE;CAGb,MAAM,yBAAyB,KAAK,UAAU,aAAa;CAE3D,MAAM,2BAA2B,aAAqB;EAClD,MAAM,eAAe,KAAK,SAAS,wBAAwB,SAAS;AACpE,SACI,iBAAiB,MAChB,CAAC,aAAa,WAAW,KAAK,IAAI,CAAC,KAAK,WAAW,aAAa;;CAIzE,MAAM,mBAAmB,SAAiB;EACtC,MAAM,iBAAiB,KAAK,UAAU,KAAK;AAC3C,SAAO,wBAAwB,eAAe,GACxC,iBACA,KAAK,KAAK,wBAAwB,eAAe;;AAG3D,QAAO,EACH,OAAO,MAAM,QAAQ,MAAM,GACrB,MAAM,IAAI,gBAAgB,GAC1B,gBAAgB,MAAM,EAC/B"}

package/dist/sourceMap.d.ts

@@ -0,0 +1,27 @@
+//#region src/sourceMap.d.ts
+/*!
+ * node-minify
+ * Copyright (c) 2011-2026 Rodolphe Stoclin
+ * MIT Licensed
+ */
+/**
+ * Normalize sourceMap option to boolean for compressors that only accept boolean.
+ *
+ * @param options - Compressor options object that may contain a `sourceMap` property
+ * @returns `true` if `sourceMap` is truthy, `false` otherwise
+ */
+declare function getSourceMapBoolean(options?: Record<string, unknown>): boolean;
+/**
+ * Extract sourceMap from options, returning the boolean flag and remaining options separately.
+ * Useful for compressors where sourceMap must be handled as a distinct parameter.
+ *
+ * @param options - Compressor options object that may contain a `sourceMap` property
+ * @returns Object with `sourceMap` boolean and `restOptions` without the sourceMap key
+ */
+declare function extractSourceMapOption(options?: Record<string, unknown>): {
+  sourceMap: boolean;
+  restOptions: Record<string, unknown>;
+};
+//#endregion
+export { extractSourceMapOption, getSourceMapBoolean };
+//# sourceMappingURL=sourceMap.d.ts.map

package/dist/sourceMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sourceMap.d.ts","names":[],"sources":["../src/sourceMap.ts"],"mappings":";;AAYA;;;;;AAaA;;;;;iBAbgB,mBAAA,CACZ,OAAA,GAAU,MAAA;;;;;;;;iBAYE,sBAAA,CAAuB,OAAA,GAAU,MAAA;EAC7C,SAAA;EACA,WAAA,EAAa,MAAA;AAAA"}

package/dist/sourceMap.js

@@ -0,0 +1,37 @@
+//#region src/sourceMap.ts
+/*!
+* node-minify
+* Copyright (c) 2011-2026 Rodolphe Stoclin
+* MIT Licensed
+*/
+/**
+* Normalize sourceMap option to boolean for compressors that only accept boolean.
+*
+* @param options - Compressor options object that may contain a `sourceMap` property
+* @returns `true` if `sourceMap` is truthy, `false` otherwise
+*/
+function getSourceMapBoolean(options) {
+	return !!options?.sourceMap;
+}
+/**
+* Extract sourceMap from options, returning the boolean flag and remaining options separately.
+* Useful for compressors where sourceMap must be handled as a distinct parameter.
+*
+* @param options - Compressor options object that may contain a `sourceMap` property
+* @returns Object with `sourceMap` boolean and `restOptions` without the sourceMap key
+*/
+function extractSourceMapOption(options) {
+	if (!options) return {
+		sourceMap: false,
+		restOptions: {}
+	};
+	const { sourceMap, ...restOptions } = options;
+	return {
+		sourceMap: !!sourceMap,
+		restOptions
+	};
+}
+
+//#endregion
+export { extractSourceMapOption, getSourceMapBoolean };
+//# sourceMappingURL=sourceMap.js.map

package/dist/sourceMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sourceMap.js","names":[],"sources":["../src/sourceMap.ts"],"sourcesContent":["/*!\n * node-minify\n * Copyright (c) 2011-2026 Rodolphe Stoclin\n * MIT Licensed\n */\n\n/**\n * Normalize sourceMap option to boolean for compressors that only accept boolean.\n *\n * @param options - Compressor options object that may contain a `sourceMap` property\n * @returns `true` if `sourceMap` is truthy, `false` otherwise\n */\nexport function getSourceMapBoolean(\n    options?: Record<string, unknown>\n): boolean {\n    return !!options?.sourceMap;\n}\n\n/**\n * Extract sourceMap from options, returning the boolean flag and remaining options separately.\n * Useful for compressors where sourceMap must be handled as a distinct parameter.\n *\n * @param options - Compressor options object that may contain a `sourceMap` property\n * @returns Object with `sourceMap` boolean and `restOptions` without the sourceMap key\n */\nexport function extractSourceMapOption(options?: Record<string, unknown>): {\n    sourceMap: boolean;\n    restOptions: Record<string, unknown>;\n} {\n    if (!options) {\n        return { sourceMap: false, restOptions: {} };\n    }\n    const { sourceMap, ...restOptions } = options;\n    return {\n        sourceMap: !!sourceMap,\n        restOptions,\n    };\n}\n"],"mappings":";;;;;;;;;;;;AAYA,SAAgB,oBACZ,SACO;AACP,QAAO,CAAC,CAAC,SAAS;;;;;;;;;AAUtB,SAAgB,uBAAuB,SAGrC;AACE,KAAI,CAAC,QACD,QAAO;EAAE,WAAW;EAAO,aAAa,EAAE;EAAE;CAEhD,MAAM,EAAE,WAAW,GAAG,gBAAgB;AACtC,QAAO;EACH,WAAW,CAAC,CAAC;EACb;EACH"}

package/dist/{types-CWBFD3au.d.ts → types-D10QejTN.d.ts}

@@ -1,5 +1,4 @@
 //#region ../types/src/types.d.ts
-
 /**
  * Output result for multi-format image compression.
  */
@@ -8,7 +7,6 @@ type CompressorOutput = {
    * Format of the output (e.g., 'webp', 'avif').
    */
   format?: string;
-
   /**
    * Output content as string or Buffer.
    */
@@ -22,19 +20,16 @@ type CompressorResult = {
    * Minified content as string (for text-based formats like JS, CSS, HTML, SVG).
    */
   code: string;
-
   /**
    * Source map (for JS/CSS compressors).
    */
   map?: string;
-
   /**
    * Minified content as Buffer (for binary formats like images).
    * @example
    * When using sharp for PNG/WebP compression
    */
   buffer?: Buffer;
-
   /**
    * Multiple outputs for multi-format image compression.
    * Used when converting to multiple formats simultaneously.
@@ -80,12 +75,10 @@ type Settings<TOptions extends CompressorOptions = CompressorOptions> = {
    * The compressor function to use for minification.
    */
   compressor: Compressor<TOptions>;
-
   /**
    * Optional label for the compressor (used in logging).
    */
   compressorLabel?: string;
-
   /**
    * Content to minify (for in-memory minification).
    * If provided, input/output are not required.
@@ -93,7 +86,6 @@ type Settings<TOptions extends CompressorOptions = CompressorOptions> = {
    * For binary formats (images): Buffer (handled internally by image compressors)
    */
   content?: string | Buffer;
-
   /**
    * Input file path(s) or glob pattern.
    * Can be a single file, array of files, or wildcard pattern.
@@ -104,7 +96,6 @@ type Settings<TOptions extends CompressorOptions = CompressorOptions> = {
    * - 'src/**\/*.js'
    */
   input?: string | string[];
-
   /**
    * Output file path.
    * Use $1 as placeholder for input filename in multi-file scenarios.
@@ -116,43 +107,36 @@ type Settings<TOptions extends CompressorOptions = CompressorOptions> = {
    * - '$1.min.js' (creates app.min.js from app.js)
    */
   output?: string | string[];
-
   /**
    * Compressor-specific options.
    * See individual compressor documentation for available options.
    */
   options?: TOptions;
-
   /**
    * CLI option string (used by CLI only).
    * @internal
    */
   option?: string;
-
   /**
    * Buffer size for file operations (in bytes).
    * @default 1024000 (1MB)
    */
   buffer?: number;
-
   /**
    * Timeout for the compressor process (in milliseconds).
    * If execution exceeds this limit, the process will be killed.
    */
   timeout?: number;
-
   /**
    * File type for compressors that support multiple types.
    * Required for YUI compressor.
    */
   type?: FileType;
-
   /**
    * Suppress console output.
    * @default false
    */
   silence?: boolean;
-
   /**
    * Public folder to prepend to input paths.
    *
@@ -161,13 +145,11 @@ type Settings<TOptions extends CompressorOptions = CompressorOptions> = {
    * the actual path becomes 'public/js/app.js'
    */
   publicFolder?: string;
-
   /**
    * Replace files in place instead of creating new output files.
    * @default false
    */
   replaceInPlace?: boolean;
-
   /**
    * Allow empty output without throwing an error.
    * When true, if minification results in empty content, the output file will not be written.
@@ -185,7 +167,6 @@ type MinifierOptions<TOptions extends CompressorOptions = CompressorOptions> = {
    * The full settings object.
    */
   settings: Settings<TOptions>;
-
   /**
    * The content to minify.
    * For text-based formats (JS, CSS, HTML, SVG): string
@@ -193,7 +174,6 @@ type MinifierOptions<TOptions extends CompressorOptions = CompressorOptions> = {
    * For multiple binary files: Buffer[]
    */
   content?: string | Buffer | Buffer[];
-
   /**
    * Index of current file when processing multiple files.
    */
@@ -201,4 +181,4 @@ type MinifierOptions<TOptions extends CompressorOptions = CompressorOptions> = {
 };
 //#endregion
 export { Settings as i, CompressorOptions as n, MinifierOptions as r, Compressor as t };
-//# sourceMappingURL=types-CWBFD3au.d.ts.map
+//# sourceMappingURL=types-D10QejTN.d.ts.map

package/dist/types-D10QejTN.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-D10QejTN.d.ts","names":["CompressorReturnType","ImageFormat","CompressorOutput","Buffer","format","content","CompressorResult","code","map","buffer","outputs","CompressorOptions","Record","Compressor","TOptions","MinifierOptions","Promise","args","FileType","Settings","compressor","compressorLabel","input","output","options","option","timeout","type","silence","publicFolder","replaceInPlace","allowEmptyOutput","settings","index","Result","size","sizeGzip","MinifyOptions"],"sources":["../../types/src/types.d.ts"],"mappings":";;AAkFA;;KArDYE,gBAAAA;EAqD4BS;;;EAjDpCP,MAAAA;EAkDqCY;;;EA7CrCX,OAAAA,WAAkBF,MAAAA;AAAAA;;;;KAMVG,gBAAAA;EAuCqCA;;;EAnC7CC,IAAAA;;;;EAKAC,GAAAA;EAsDgBM;;;;;EA/ChBL,MAAAA,GAASN,MAAAA;EAqHFe;;;;;;EA7GPR,OAAAA,GAAUR,gBAAAA;AAAAA;;;;;KAOFS,iBAAAA,GAAoBC,MAAAA;;;;;;KAOpBC,UAAAA,kBAA4BF,iBAAAA,GAAoBA,iBAAAA,KACvDM,IAAAA,EAAMF,eAAAA,CAAgBD,QAAAA,MAAcE,OAAAA,CAAQV,gBAAAA;;;;KAKrCY,QAAAA;;;;;;;;;;;;;;;;;;KAmBAC,QAAAA,kBAA0BR,iBAAAA,GAAoBA,iBAAAA;EAwH1BR;;;EApH5BiB,UAAAA,EAAYP,UAAAA,CAAWC,QAAAA;;;;EAKvBO,eAAAA;;;;;;;EAQAhB,OAAAA,YAAmBF,MAAAA;;;;;;;;;;EAWnBmB,KAAAA;;;;;;;;;;;EAYAC,MAAAA;;;;;EAMAC,OAAAA,GAAUV,QAAAA;;;;;EAMVW,MAAAA;;;;;EAMAhB,MAAAA;;;;;EAMAiB,OAAAA;;;;;EAMAC,IAAAA,GAAOT,QAAAA;;;;;EAMPU,OAAAA;;;;;;;;EASAC,YAAAA;;;;;EAMAC,cAAAA;;;;;;;EAQAC,gBAAAA;AAAAA;;;;;KAOQhB,eAAAA,kBACSJ,iBAAAA,GAAoBA,iBAAAA;;;;EAKrCqB,QAAAA,EAAUb,QAAAA,CAASL,QAAAA;;;;;;;EAQnBT,OAAAA,YAAmBF,MAAAA,GAASA,MAAAA;;;;EAK5B8B,KAAAA;AAAAA"}

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;AAMA;;;;UAAiB,gBAAA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";;AAMA;;;;UAAiB,gBAAA;EAAA,CACZ,GAAA;AAAA"}

package/dist/wildcards.d.ts

@@ -4,16 +4,34 @@
  * Copyright (c) 2011-2026 Rodolphe Stoclin
  * MIT Licensed
  */
+/**
+ * Options for wildcards function
+ */
+interface WildcardOptions {
+  /**
+   * Path to the public folder
+   */
+  publicFolder?: string;
+  /**
+   * Patterns to ignore when matching files
+   */
+  ignore?: string[];
+}
+/**
+ * Default ignore patterns for common build artifacts and dependencies
+ */
+declare const DEFAULT_IGNORES: string[];
 /**
  * Handle wildcards in a path, get the real path of each file.
  * @param input - Path with wildcards
- * @param publicFolder - Path to the public folder
+ * @param options - Options object or string publicFolder for backward compatibility
+ * @returns Object with resolved file paths
  */
-declare function wildcards(input: string | string[], publicFolder?: string): {
+declare function wildcards(input: string | string[], options?: WildcardOptions | string): {
   input: string[];
 } | {
   input?: undefined;
 };
 //#endregion
-export { wildcards };
+export { DEFAULT_IGNORES, WildcardOptions, wildcards };
 //# sourceMappingURL=wildcards.d.ts.map

package/dist/wildcards.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wildcards.d.ts","names":[],"sources":["../src/wildcards.ts"],"sourcesContent":[],"mappings":";;AAqBA;;;;;;;;;iBAAgB,SAAA"}
+{"version":3,"file":"wildcards.d.ts","names":[],"sources":["../src/wildcards.ts"],"mappings":";;AAaA;;;;;AAcA;;UAdiB,eAAA;EAuBhB;;AAwBD;EA3CI,YAAA;;;;EAIA,MAAA;AAAA;;;;cAMS,eAAA;;;;;;;iBAiCG,SAAA,CACZ,KAAA,qBACA,OAAA,GAAU,eAAA"}

package/dist/wildcards.js

@@ -1,3 +1,4 @@
+import path from "node:path";
 import os from "node:os";
 import fg from "fast-glob";
 
@@ -8,51 +9,74 @@ import fg from "fast-glob";
 * MIT Licensed
 */
 /**
+* Default ignore patterns for common build artifacts and dependencies
+*/
+const DEFAULT_IGNORES = [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/.next/**",
+	"**/*.min.{js,css}",
+	"**/*.d.ts",
+	"**/__tests__/**",
+	"**/.*"
+];
+/**
 * Check if the platform is Windows
 */
 function isWindows() {
 	return os.platform() === "win32";
 }
 /**
+* Normalize any Windows path separators to POSIX separators.
+* @param value Path-like string
+* @returns Path string using `/` separators
+*/
+function toPosixPath(value) {
+	return value.replaceAll("\\", "/");
+}
+/**
 * Handle wildcards in a path, get the real path of each file.
 * @param input - Path with wildcards
-* @param publicFolder - Path to the public folder
+* @param options - Options object or string publicFolder for backward compatibility
+* @returns Object with resolved file paths
 */
-function wildcards(input, publicFolder) {
-	if (Array.isArray(input)) return wildcardsArray(input, publicFolder);
-	return wildcardsString(input, publicFolder);
+function wildcards(input, options) {
+	const normalizedOptions = typeof options === "string" ? { publicFolder: options } : options ?? {};
+	if (Array.isArray(input)) return wildcardsArray(input, normalizedOptions);
+	return wildcardsString(input, normalizedOptions);
 }
 /**
 * Handle wildcards in a path (string only), get the real path of each file.
 * @param input - Path with wildcards
-* @param publicFolder - Path to the public folder
+* @param options - Wildcard options
 */
-function wildcardsString(input, publicFolder) {
+function wildcardsString(input, options) {
 	if (!input.includes("*")) return {};
-	return { input: getFilesFromWildcards(input, publicFolder).filter((path) => !path.includes("*")) };
+	return { input: getFilesFromWildcards(input, options).filter((path) => !path.includes("*")) };
 }
 /**
 * Handle wildcards in a path (array only), get the real path of each file.
 * @param input - Array of paths with wildcards
-* @param publicFolder - Path to the public folder
+* @param options - Wildcard options
 */
-function wildcardsArray(input, publicFolder) {
+function wildcardsArray(input, options) {
 	const inputWithPublicFolder = input.map((item) => {
-		const input2 = publicFolder ? publicFolder + item : item;
+		const input2 = options.publicFolder ? path.posix.join(toPosixPath(options.publicFolder), toPosixPath(item)) : item;
 		return isWindows() ? fg.convertPathToPattern(input2) : input2;
 	});
-	return { input: (inputWithPublicFolder.some((item) => item.includes("*")) ? fg.globSync(inputWithPublicFolder) : input).filter((path) => !path.includes("*")) };
+	return { input: (inputWithPublicFolder.some((item) => item.includes("*")) ? fg.globSync(inputWithPublicFolder, { ignore: options.ignore }) : inputWithPublicFolder).filter((path) => !path.includes("*")) };
 }
 /**
 * Get the real path of each file.
 * @param input - Path with wildcards
-* @param publicFolder - Path to the public folder
+* @param options - Wildcard options
 */
-function getFilesFromWildcards(input, publicFolder) {
-	const fullPath = publicFolder ? `${publicFolder}${input}` : input;
-	return fg.globSync(isWindows() ? fg.convertPathToPattern(fullPath) : fullPath);
+function getFilesFromWildcards(input, options) {
+	const fullPath = options.publicFolder ? path.posix.join(toPosixPath(options.publicFolder), toPosixPath(input)) : input;
+	return fg.globSync(isWindows() ? fg.convertPathToPattern(fullPath) : fullPath, { ignore: options.ignore });
 }
 
 //#endregion
-export { wildcards };
+export { DEFAULT_IGNORES, wildcards };
 //# sourceMappingURL=wildcards.js.map

package/dist/wildcards.js.map

@@ -1 +1 @@
-{"version":3,"file":"wildcards.js","names":[],"sources":["../src/wildcards.ts"],"sourcesContent":["/*!\n * node-minify\n * Copyright (c) 2011-2026 Rodolphe Stoclin\n * MIT Licensed\n */\n\nimport os from \"node:os\";\nimport fg from \"fast-glob\";\n\n/**\n * Check if the platform is Windows\n */\nfunction isWindows() {\n    return os.platform() === \"win32\";\n}\n\n/**\n * Handle wildcards in a path, get the real path of each file.\n * @param input - Path with wildcards\n * @param publicFolder - Path to the public folder\n */\nexport function wildcards(input: string | string[], publicFolder?: string) {\n    if (Array.isArray(input)) {\n        return wildcardsArray(input, publicFolder);\n    }\n\n    return wildcardsString(input, publicFolder);\n}\n\n/**\n * Handle wildcards in a path (string only), get the real path of each file.\n * @param input - Path with wildcards\n * @param publicFolder - Path to the public folder\n */\nfunction wildcardsString(input: string, publicFolder?: string) {\n    if (!input.includes(\"*\")) {\n        return {};\n    }\n\n    const files = getFilesFromWildcards(input, publicFolder);\n    const finalPaths = files.filter((path: string) => !path.includes(\"*\"));\n\n    return {\n        input: finalPaths,\n    };\n}\n\n/**\n * Handle wildcards in a path (array only), get the real path of each file.\n * @param input - Array of paths with wildcards\n * @param publicFolder - Path to the public folder\n */\nfunction wildcardsArray(input: string[], publicFolder?: string) {\n    // Convert input paths to patterns with public folder prefix\n    const inputWithPublicFolder = input.map((item) => {\n        const input2 = publicFolder ? publicFolder + item : item;\n        return isWindows() ? fg.convertPathToPattern(input2) : input2;\n    });\n\n    // Check if any wildcards exist\n    const hasWildcards = inputWithPublicFolder.some((item) =>\n        item.includes(\"*\")\n    );\n\n    // Process paths based on whether wildcards exist\n    const processedPaths = hasWildcards\n        ? fg.globSync(inputWithPublicFolder)\n        : input;\n\n    // Filter out any remaining paths with wildcards\n    const finalPaths = processedPaths.filter(\n        (path: string) => !path.includes(\"*\")\n    );\n\n    return { input: finalPaths };\n}\n\n/**\n * Get the real path of each file.\n * @param input - Path with wildcards\n * @param publicFolder - Path to the public folder\n */\nfunction getFilesFromWildcards(input: string, publicFolder?: string) {\n    const fullPath = publicFolder ? `${publicFolder}${input}` : input;\n    return fg.globSync(\n        isWindows() ? fg.convertPathToPattern(fullPath) : fullPath\n    );\n}\n"],"mappings":";;;;;;;;;;;;AAYA,SAAS,YAAY;AACjB,QAAO,GAAG,UAAU,KAAK;;;;;;;AAQ7B,SAAgB,UAAU,OAA0B,cAAuB;AACvE,KAAI,MAAM,QAAQ,MAAM,CACpB,QAAO,eAAe,OAAO,aAAa;AAG9C,QAAO,gBAAgB,OAAO,aAAa;;;;;;;AAQ/C,SAAS,gBAAgB,OAAe,cAAuB;AAC3D,KAAI,CAAC,MAAM,SAAS,IAAI,CACpB,QAAO,EAAE;AAMb,QAAO,EACH,OAJU,sBAAsB,OAAO,aAAa,CAC/B,QAAQ,SAAiB,CAAC,KAAK,SAAS,IAAI,CAAC,EAIrE;;;;;;;AAQL,SAAS,eAAe,OAAiB,cAAuB;CAE5D,MAAM,wBAAwB,MAAM,KAAK,SAAS;EAC9C,MAAM,SAAS,eAAe,eAAe,OAAO;AACpD,SAAO,WAAW,GAAG,GAAG,qBAAqB,OAAO,GAAG;GACzD;AAiBF,QAAO,EAAE,QAdY,sBAAsB,MAAM,SAC7C,KAAK,SAAS,IAAI,CACrB,GAIK,GAAG,SAAS,sBAAsB,GAClC,OAG4B,QAC7B,SAAiB,CAAC,KAAK,SAAS,IAAI,CACxC,EAE2B;;;;;;;AAQhC,SAAS,sBAAsB,OAAe,cAAuB;CACjE,MAAM,WAAW,eAAe,GAAG,eAAe,UAAU;AAC5D,QAAO,GAAG,SACN,WAAW,GAAG,GAAG,qBAAqB,SAAS,GAAG,SACrD"}
+{"version":3,"file":"wildcards.js","names":[],"sources":["../src/wildcards.ts"],"sourcesContent":["/*!\n * node-minify\n * Copyright (c) 2011-2026 Rodolphe Stoclin\n * MIT Licensed\n */\n\nimport os from \"node:os\";\nimport path from \"node:path\";\nimport fg from \"fast-glob\";\n\n/**\n * Options for wildcards function\n */\nexport interface WildcardOptions {\n    /**\n     * Path to the public folder\n     */\n    publicFolder?: string;\n    /**\n     * Patterns to ignore when matching files\n     */\n    ignore?: string[];\n}\n\n/**\n * Default ignore patterns for common build artifacts and dependencies\n */\nexport const DEFAULT_IGNORES: string[] = [\n    \"**/node_modules/**\",\n    \"**/dist/**\",\n    \"**/build/**\",\n    \"**/.next/**\",\n    \"**/*.min.{js,css}\",\n    \"**/*.d.ts\",\n    \"**/__tests__/**\",\n    \"**/.*\",\n];\n\n/**\n * Check if the platform is Windows\n */\nfunction isWindows() {\n    return os.platform() === \"win32\";\n}\n\n/**\n * Normalize any Windows path separators to POSIX separators.\n * @param value Path-like string\n * @returns Path string using `/` separators\n */\nfunction toPosixPath(value: string): string {\n    return value.replaceAll(\"\\\\\", \"/\");\n}\n\n/**\n * Handle wildcards in a path, get the real path of each file.\n * @param input - Path with wildcards\n * @param options - Options object or string publicFolder for backward compatibility\n * @returns Object with resolved file paths\n */\nexport function wildcards(\n    input: string | string[],\n    options?: WildcardOptions | string\n) {\n    const normalizedOptions: WildcardOptions =\n        typeof options === \"string\"\n            ? { publicFolder: options }\n            : (options ?? {});\n\n    if (Array.isArray(input)) {\n        return wildcardsArray(input, normalizedOptions);\n    }\n\n    return wildcardsString(input, normalizedOptions);\n}\n\n/**\n * Handle wildcards in a path (string only), get the real path of each file.\n * @param input - Path with wildcards\n * @param options - Wildcard options\n */\nfunction wildcardsString(input: string, options: WildcardOptions) {\n    if (!input.includes(\"*\")) {\n        return {};\n    }\n\n    const files = getFilesFromWildcards(input, options);\n    const finalPaths = files.filter((path: string) => !path.includes(\"*\"));\n\n    return {\n        input: finalPaths,\n    };\n}\n\n/**\n * Handle wildcards in a path (array only), get the real path of each file.\n * @param input - Array of paths with wildcards\n * @param options - Wildcard options\n */\nfunction wildcardsArray(input: string[], options: WildcardOptions) {\n    const inputWithPublicFolder = input.map((item) => {\n        const input2 = options.publicFolder\n            ? path.posix.join(\n                  toPosixPath(options.publicFolder),\n                  toPosixPath(item)\n              )\n            : item;\n        return isWindows() ? fg.convertPathToPattern(input2) : input2;\n    });\n\n    const hasWildcards = inputWithPublicFolder.some((item) =>\n        item.includes(\"*\")\n    );\n\n    const processedPaths = hasWildcards\n        ? fg.globSync(inputWithPublicFolder, { ignore: options.ignore })\n        : inputWithPublicFolder;\n\n    const finalPaths = processedPaths.filter(\n        (path: string) => !path.includes(\"*\")\n    );\n\n    return { input: finalPaths };\n}\n\n/**\n * Get the real path of each file.\n * @param input - Path with wildcards\n * @param options - Wildcard options\n */\nfunction getFilesFromWildcards(input: string, options: WildcardOptions) {\n    const fullPath = options.publicFolder\n        ? path.posix.join(toPosixPath(options.publicFolder), toPosixPath(input))\n        : input;\n    return fg.globSync(\n        isWindows() ? fg.convertPathToPattern(fullPath) : fullPath,\n        { ignore: options.ignore }\n    );\n}\n"],"mappings":";;;;;;;;;;;;;AA2BA,MAAa,kBAA4B;CACrC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACH;;;;AAKD,SAAS,YAAY;AACjB,QAAO,GAAG,UAAU,KAAK;;;;;;;AAQ7B,SAAS,YAAY,OAAuB;AACxC,QAAO,MAAM,WAAW,MAAM,IAAI;;;;;;;;AAStC,SAAgB,UACZ,OACA,SACF;CACE,MAAM,oBACF,OAAO,YAAY,WACb,EAAE,cAAc,SAAS,GACxB,WAAW,EAAE;AAExB,KAAI,MAAM,QAAQ,MAAM,CACpB,QAAO,eAAe,OAAO,kBAAkB;AAGnD,QAAO,gBAAgB,OAAO,kBAAkB;;;;;;;AAQpD,SAAS,gBAAgB,OAAe,SAA0B;AAC9D,KAAI,CAAC,MAAM,SAAS,IAAI,CACpB,QAAO,EAAE;AAMb,QAAO,EACH,OAJU,sBAAsB,OAAO,QAAQ,CAC1B,QAAQ,SAAiB,CAAC,KAAK,SAAS,IAAI,CAAC,EAIrE;;;;;;;AAQL,SAAS,eAAe,OAAiB,SAA0B;CAC/D,MAAM,wBAAwB,MAAM,KAAK,SAAS;EAC9C,MAAM,SAAS,QAAQ,eACjB,KAAK,MAAM,KACP,YAAY,QAAQ,aAAa,EACjC,YAAY,KAAK,CACpB,GACD;AACN,SAAO,WAAW,GAAG,GAAG,qBAAqB,OAAO,GAAG;GACzD;AAcF,QAAO,EAAE,QAZY,sBAAsB,MAAM,SAC7C,KAAK,SAAS,IAAI,CACrB,GAGK,GAAG,SAAS,uBAAuB,EAAE,QAAQ,QAAQ,QAAQ,CAAC,GAC9D,uBAE4B,QAC7B,SAAiB,CAAC,KAAK,SAAS,IAAI,CACxC,EAE2B;;;;;;;AAQhC,SAAS,sBAAsB,OAAe,SAA0B;CACpE,MAAM,WAAW,QAAQ,eACnB,KAAK,MAAM,KAAK,YAAY,QAAQ,aAAa,EAAE,YAAY,MAAM,CAAC,GACtE;AACN,QAAO,GAAG,SACN,WAAW,GAAG,GAAG,qBAAqB,SAAS,GAAG,UAClD,EAAE,QAAQ,QAAQ,QAAQ,CAC7B"}

package/dist/writeFile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writeFile.d.ts","names":[],"sources":["../src/writeFile.ts"],"sourcesContent":[],"mappings":";;;AA4BA;;;UAlBU,eAAA,CAqBN;EACD,IAAA,EAAA,MAAA,GAAA,MAAA,EAAA;EAA2B,OAAA,EAAA,MAAA,GApBR,MAoBQ;EAAM,KAAA,CAAA,EAAA,MAAA;AA8BpC;;;;;;;;;;;;;iBAlCgB,SAAA;;;;GAIb,2BAA2B;;;;;;;;;;;;;;iBA8BR,cAAA;;;;GAInB,kBAAkB,iBAAiB"}
+{"version":3,"file":"writeFile.d.ts","names":[],"sources":["../src/writeFile.ts"],"mappings":";;;;;;UAUU,eAAA;EACN,IAAA;EACA,OAAA,WAAkB,MAAA;EAClB,KAAA;AAAA;;AAeJ;;;;;;;;;;;iBAAgB,SAAA,CAAA;EACZ,IAAA;EACA,OAAA;EACA;AAAA,GACD,eAAA,YAA2B,MAAA;;;;;;;;;AA8B9B;;;;;iBAAsB,cAAA,CAAA;EAClB,IAAA;EACA,OAAA;EACA;AAAA,GACD,eAAA,GAAkB,OAAA,UAAiB,MAAA"}

package/dist/writeFile.js

@@ -1,3 +1,96 @@
-import { n as writeFileAsync, t as writeFile } from "./writeFile-mfUS3rMz.js";
+import { FileOperationError, ValidationError } from "./error.js";
+import { writeFileSync } from "node:fs";
+import { writeFile as writeFile$1 } from "node:fs/promises";
 
-export { writeFile, writeFileAsync };
+//#region src/writeFile.ts
+/*!
+* node-minify
+* Copyright (c) 2011-2026 Rodolphe Stoclin
+* MIT Licensed
+*/
+/**
+* Write provided content to a target file.
+*
+* When `file` is an array and `index` is provided, the file at that index is used; otherwise `file` is used directly.
+*
+* @param file - Target path or array of target paths
+* @param content - Content to write; may be a `string` or `Buffer`
+* @param index - Optional index to select a file when `file` is an array
+* @returns The same `content` value that was written
+* @throws ValidationError If no target file, no content, or the resolved target path is invalid
+* @throws FileOperationError If the underlying filesystem write fails (wraps the original error)
+*/
+function writeFile({ file, content, index }) {
+	try {
+		const targetFile = resolveTargetFile(file, index);
+		validateContent(content);
+		writeFileSync(targetFile, content, Buffer.isBuffer(content) ? void 0 : "utf8");
+		return content;
+	} catch (error) {
+		handleWriteError(error, file);
+		return content;
+	}
+}
+/**
+* Write content to a resolved target file path.
+*
+* Resolves the target from `file` (string or array) using `index` when provided, validates the content,
+* ensures the target is not a directory, and writes the content to disk.
+*
+* @param file - Target path or array of target paths; when `file` is an array, `index` selects the entry
+* @param content - Content to write; a `string` or `Buffer`
+* @param index - Optional index used to select a file when `file` is an array
+* @returns The same `content` value that was written
+* @throws ValidationError If no target file, no content, or the resolved target path is invalid
+* @throws FileOperationError If the underlying filesystem write fails (wraps the original error)
+*/
+async function writeFileAsync({ file, content, index }) {
+	try {
+		const targetFile = resolveTargetFile(file, index);
+		validateContent(content);
+		await writeFile$1(targetFile, content, Buffer.isBuffer(content) ? void 0 : "utf8");
+		return content;
+	} catch (error) {
+		handleWriteError(error, file);
+		return content;
+	}
+}
+/**
+* Resolve a target file path from a string or an array of paths, optionally selecting by index.
+*
+* @param file - A file path or an array of file paths to resolve from.
+* @param index - Optional index to select an entry when `file` is an array; ignored if not provided.
+* @returns The resolved file path.
+* @throws ValidationError if no file is provided or the resolved target is not a string.
+*/
+function resolveTargetFile(file, index) {
+	if (!file) throw new ValidationError("No target file provided");
+	const targetFile = index !== void 0 ? Array.isArray(file) ? file[index] : file : file;
+	if (typeof targetFile !== "string") throw new ValidationError("Invalid target file path");
+	return targetFile;
+}
+/**
+* Ensure content is present before writing.
+*
+* @param content - The data to write; a string or Buffer
+* @throws ValidationError if `content` is empty or otherwise falsy
+*/
+function validateContent(content) {
+	if (!content) throw new ValidationError("No content provided");
+}
+/**
+* Normalize and rethrow errors that occur while attempting to write to one or more files.
+*
+* @param error - The original error thrown during the write attempt
+* @param file - The target file path or an array of paths that were the intended write targets
+* @throws ValidationError - rethrows the provided ValidationError without modification
+* @throws FileOperationError - thrown for any other error, wrapping the original error with context about the write operation and the target file(s)
+*/
+function handleWriteError(error, file) {
+	if (error instanceof ValidationError) throw error;
+	throw new FileOperationError("write to", typeof file === "string" ? file : "multiple files", error);
+}
+
+//#endregion
+export { writeFile, writeFileAsync };
+//# sourceMappingURL=writeFile.js.map

package/dist/writeFile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeFile.js","names":["writeFileFs"],"sources":["../src/writeFile.ts"],"sourcesContent":["/*!\n * node-minify\n * Copyright (c) 2011-2026 Rodolphe Stoclin\n * MIT Licensed\n */\n\nimport { writeFileSync } from \"node:fs\";\nimport { writeFile as writeFileFs } from \"node:fs/promises\";\nimport { FileOperationError, ValidationError } from \"./error.ts\";\n\ninterface WriteFileParams {\n    file: string | string[];\n    content: string | Buffer;\n    index?: number;\n}\n\n/**\n * Write provided content to a target file.\n *\n * When `file` is an array and `index` is provided, the file at that index is used; otherwise `file` is used directly.\n *\n * @param file - Target path or array of target paths\n * @param content - Content to write; may be a `string` or `Buffer`\n * @param index - Optional index to select a file when `file` is an array\n * @returns The same `content` value that was written\n * @throws ValidationError If no target file, no content, or the resolved target path is invalid\n * @throws FileOperationError If the underlying filesystem write fails (wraps the original error)\n */\nexport function writeFile({\n    file,\n    content,\n    index,\n}: WriteFileParams): string | Buffer {\n    try {\n        const targetFile = resolveTargetFile(file, index);\n        validateContent(content);\n\n        writeFileSync(\n            targetFile,\n            content,\n            Buffer.isBuffer(content) ? undefined : \"utf8\"\n        );\n        return content;\n    } catch (error) {\n        handleWriteError(error, file);\n        return content; // Should be unreachable due to handleWriteError throwing\n    }\n}\n\n/**\n * Write content to a resolved target file path.\n *\n * Resolves the target from `file` (string or array) using `index` when provided, validates the content,\n * ensures the target is not a directory, and writes the content to disk.\n *\n * @param file - Target path or array of target paths; when `file` is an array, `index` selects the entry\n * @param content - Content to write; a `string` or `Buffer`\n * @param index - Optional index used to select a file when `file` is an array\n * @returns The same `content` value that was written\n * @throws ValidationError If no target file, no content, or the resolved target path is invalid\n * @throws FileOperationError If the underlying filesystem write fails (wraps the original error)\n */\nexport async function writeFileAsync({\n    file,\n    content,\n    index,\n}: WriteFileParams): Promise<string | Buffer> {\n    try {\n        const targetFile = resolveTargetFile(file, index);\n        validateContent(content);\n\n        await writeFileFs(\n            targetFile,\n            content,\n            Buffer.isBuffer(content) ? undefined : \"utf8\"\n        );\n        return content;\n    } catch (error) {\n        handleWriteError(error, file);\n        return content; // Should be unreachable due to handleWriteError throwing\n    }\n}\n\n/**\n * Resolve a target file path from a string or an array of paths, optionally selecting by index.\n *\n * @param file - A file path or an array of file paths to resolve from.\n * @param index - Optional index to select an entry when `file` is an array; ignored if not provided.\n * @returns The resolved file path.\n * @throws ValidationError if no file is provided or the resolved target is not a string.\n */\nfunction resolveTargetFile(file: string | string[], index?: number): string {\n    if (!file) {\n        throw new ValidationError(\"No target file provided\");\n    }\n\n    const targetFile =\n        index !== undefined ? (Array.isArray(file) ? file[index] : file) : file;\n\n    if (typeof targetFile !== \"string\") {\n        throw new ValidationError(\"Invalid target file path\");\n    }\n\n    return targetFile;\n}\n\n/**\n * Ensure content is present before writing.\n *\n * @param content - The data to write; a string or Buffer\n * @throws ValidationError if `content` is empty or otherwise falsy\n */\nfunction validateContent(content: string | Buffer): void {\n    if (!content) {\n        throw new ValidationError(\"No content provided\");\n    }\n}\n\n/**\n * Normalize and rethrow errors that occur while attempting to write to one or more files.\n *\n * @param error - The original error thrown during the write attempt\n * @param file - The target file path or an array of paths that were the intended write targets\n * @throws ValidationError - rethrows the provided ValidationError without modification\n * @throws FileOperationError - thrown for any other error, wrapping the original error with context about the write operation and the target file(s)\n */\nfunction handleWriteError(error: unknown, file: string | string[]): never {\n    if (error instanceof ValidationError) {\n        throw error;\n    }\n    throw new FileOperationError(\n        \"write to\",\n        typeof file === \"string\" ? file : \"multiple files\",\n        error as Error\n    );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,UAAU,EACtB,MACA,SACA,SACiC;AACjC,KAAI;EACA,MAAM,aAAa,kBAAkB,MAAM,MAAM;AACjD,kBAAgB,QAAQ;AAExB,gBACI,YACA,SACA,OAAO,SAAS,QAAQ,GAAG,SAAY,OAC1C;AACD,SAAO;UACF,OAAO;AACZ,mBAAiB,OAAO,KAAK;AAC7B,SAAO;;;;;;;;;;;;;;;;AAiBf,eAAsB,eAAe,EACjC,MACA,SACA,SAC0C;AAC1C,KAAI;EACA,MAAM,aAAa,kBAAkB,MAAM,MAAM;AACjD,kBAAgB,QAAQ;AAExB,QAAMA,YACF,YACA,SACA,OAAO,SAAS,QAAQ,GAAG,SAAY,OAC1C;AACD,SAAO;UACF,OAAO;AACZ,mBAAiB,OAAO,KAAK;AAC7B,SAAO;;;;;;;;;;;AAYf,SAAS,kBAAkB,MAAyB,OAAwB;AACxE,KAAI,CAAC,KACD,OAAM,IAAI,gBAAgB,0BAA0B;CAGxD,MAAM,aACF,UAAU,SAAa,MAAM,QAAQ,KAAK,GAAG,KAAK,SAAS,OAAQ;AAEvE,KAAI,OAAO,eAAe,SACtB,OAAM,IAAI,gBAAgB,2BAA2B;AAGzD,QAAO;;;;;;;;AASX,SAAS,gBAAgB,SAAgC;AACrD,KAAI,CAAC,QACD,OAAM,IAAI,gBAAgB,sBAAsB;;;;;;;;;;AAYxD,SAAS,iBAAiB,OAAgB,MAAgC;AACtE,KAAI,iBAAiB,gBACjB,OAAM;AAEV,OAAM,IAAI,mBACN,YACA,OAAO,SAAS,WAAW,OAAO,kBAClC,MACH"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@node-minify/utils",
-  "version": "10.4.0",
+  "version": "10.5.0",
   "description": "utils for @node-minify",
   "keywords": [
     "compressor",
@@ -56,6 +56,6 @@
     "gzip-size": "7.0.0"
   },
   "devDependencies": {
-    "@node-minify/types": "10.4.0"
+    "@node-minify/types": "10.5.0"
   }
 }

package/dist/error-CUgKxOvI.js

@@ -1,32 +0,0 @@
-//#region src/error.ts
-/*!
-* node-minify
-* Copyright (c) 2011-2026 Rodolphe Stoclin
-* MIT Licensed
-*/
-/**
-* Error class for file operation failures.
-* @extends Error
-*/
-var FileOperationError = class extends Error {
-	cause;
-	constructor(operation, path, originalError) {
-		super(`Failed to ${operation} file ${path}: ${originalError?.message || ""}`, originalError ? { cause: originalError } : void 0);
-		this.name = "FileOperationError";
-		if (originalError && !this.cause) this.cause = originalError;
-	}
-};
-/**
-* Error class for validation failures.
-* @extends Error
-*/
-var ValidationError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "ValidationError";
-	}
-};
-
-//#endregion
-export { ValidationError as n, FileOperationError as t };
-//# sourceMappingURL=error-CUgKxOvI.js.map

package/dist/error-CUgKxOvI.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-CUgKxOvI.js","names":[],"sources":["../src/error.ts"],"sourcesContent":["/*!\n * node-minify\n * Copyright (c) 2011-2026 Rodolphe Stoclin\n * MIT Licensed\n */\n\n/**\n * Error class for file operation failures.\n * @extends Error\n */\nexport class FileOperationError extends Error {\n    override cause?: Error;\n\n    constructor(operation: string, path: string, originalError?: Error) {\n        super(\n            `Failed to ${operation} file ${path}: ${originalError?.message || \"\"}`,\n            originalError ? { cause: originalError } : undefined\n        );\n        this.name = \"FileOperationError\";\n        // For older runtimes that don't support the cause option\n        if (originalError && !this.cause) {\n            this.cause = originalError;\n        }\n    }\n}\n\n/**\n * Error class for validation failures.\n * @extends Error\n */\nexport class ValidationError extends Error {\n    constructor(message: string) {\n        super(message);\n        this.name = \"ValidationError\";\n    }\n}\n"],"mappings":";;;;;;;;;;AAUA,IAAa,qBAAb,cAAwC,MAAM;CAC1C,AAAS;CAET,YAAY,WAAmB,MAAc,eAAuB;AAChE,QACI,aAAa,UAAU,QAAQ,KAAK,IAAI,eAAe,WAAW,MAClE,gBAAgB,EAAE,OAAO,eAAe,GAAG,OAC9C;AACD,OAAK,OAAO;AAEZ,MAAI,iBAAiB,CAAC,KAAK,MACvB,MAAK,QAAQ;;;;;;;AASzB,IAAa,kBAAb,cAAqC,MAAM;CACvC,YAAY,SAAiB;AACzB,QAAM,QAAQ;AACd,OAAK,OAAO"}

package/dist/isValidFile-COstpeyW.js

@@ -1,46 +0,0 @@
-import { t as FileOperationError } from "./error-CUgKxOvI.js";
-import { existsSync, lstatSync } from "node:fs";
-import { lstat } from "node:fs/promises";
-
-//#region src/isValidFile.ts
-/*!
-* node-minify
-* Copyright (c) 2011-2026 Rodolphe Stoclin
-* MIT Licensed
-*/
-/**
-* Check if the path is a valid file.
-* @param path Path to check
-* @returns true if path exists and is a file, false otherwise
-* @throws {FileOperationError} If filesystem operations fail
-* @example
-* if (isValidFile('path/to/file.js')) {
-*   // do something
-* }
-*/
-function isValidFile(path) {
-	try {
-		return existsSync(path) && !lstatSync(path).isDirectory();
-	} catch (error) {
-		throw new FileOperationError("validate", path, error);
-	}
-}
-/**
-* Determine whether a filesystem path refers to an existing file (not a directory).
-*
-* @param path - Path to check
-* @returns `true` if the path exists and is a file, `false` otherwise.
-* @throws {FileOperationError} If a filesystem error other than `ENOENT` occurs while validating the path.
-*/
-async function isValidFileAsync(path) {
-	try {
-		return !(await lstat(path)).isDirectory();
-	} catch (error) {
-		if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return false;
-		throw new FileOperationError("validate", path, error instanceof Error ? error : new Error(String(error)));
-	}
-}
-
-//#endregion
-export { isValidFileAsync as n, isValidFile as t };
-//# sourceMappingURL=isValidFile-COstpeyW.js.map