html-minifier-next 4.11.0 → 4.12.0

package/README.md

@@ -236,34 +236,34 @@ How does HTML Minifier Next compare to other minifiers? (All with the most aggre
 | Site | Original Size (KB) | [HTML Minifier Next](https://github.com/j9t/html-minifier-next)<br>[![npm last update](https://img.shields.io/npm/last-update/html-minifier-next)](https://socket.dev/npm/package/html-minifier-next) | [HTML Minifier Terser](https://github.com/terser/html-minifier-terser)<br>[![npm last update](https://img.shields.io/npm/last-update/html-minifier-terser)](https://socket.dev/npm/package/html-minifier-terser) | [htmlnano](https://github.com/posthtml/htmlnano)<br>[![npm last update](https://img.shields.io/npm/last-update/htmlnano)](https://socket.dev/npm/package/htmlnano) | [@swc/html](https://github.com/swc-project/swc)<br>[![npm last update](https://img.shields.io/npm/last-update/@swc/html)](https://socket.dev/npm/package/@swc/html) | [minify-html](https://github.com/wilsonzlin/minify-html)<br>[![npm last update](https://img.shields.io/npm/last-update/@minify-html/node)](https://socket.dev/npm/package/@minify-html/node) | [minimize](https://github.com/Swaagie/minimize)<br>[![npm last update](https://img.shields.io/npm/last-update/minimize)](https://socket.dev/npm/package/minimize) | [html­com­pressor.­com](https://htmlcompressor.com/) |
 | --- | --- | --- | --- | --- | --- | --- | --- | --- |
 | [A List Apart](https://alistapart.com/) | 59 | **49** | 50 | 51 | 52 | 51 | 54 | 52 |
-| [Apple](https://www.apple.com/) | 260 | **203** | 204 | 231 | 235 | 236 | 238 | 238 |
-| [BBC](https://www.bbc.co.uk/) | 720 | **655** | 665 | 677 | 677 | 678 | 714 | n/a |
+| [Apple](https://www.apple.com/) | 266 | **207** | **207** | 236 | 239 | 240 | 242 | 243 |
+| [BBC](https://www.bbc.co.uk/) | 739 | **675** | 685 | 695 | 695 | 697 | 733 | n/a |
 | [CERN](https://home.cern/) | 156 | **87** | **87** | 95 | 95 | 95 | 97 | 100 |
-| [CSS-Tricks](https://css-tricks.com/) | 163 | 122 | **120** | 128 | 143 | 144 | 149 | 145 |
+| [CSS-Tricks](https://css-tricks.com/) | 161 | 121 | **119** | 127 | 142 | 142 | 147 | 144 |
 | [ECMAScript](https://tc39.es/ecma262/) | 7238 | **6341** | **6341** | 6561 | 6444 | 6567 | 6614 | n/a |
 | [EDRi](https://edri.org/) | 80 | **59** | 60 | 70 | 70 | 71 | 75 | 73 |
-| [EFF](https://www.eff.org/) | 56 | **48** | **48** | 50 | 49 | 49 | 51 | 51 |
+| [EFF](https://www.eff.org/) | 55 | **47** | **47** | 50 | 48 | 49 | 50 | 50 |
 | [European Alternatives](https://european-alternatives.eu/) | 48 | **30** | **30** | 32 | 32 | 32 | 32 | 32 |
-| [FAZ](https://www.faz.net/aktuell/) | 1562 | 1455 | 1460 | **1400** | 1487 | 1498 | 1509 | n/a |
+| [FAZ](https://www.faz.net/aktuell/) | 1543 | 1436 | 1441 | **1383** | 1468 | 1479 | 1490 | n/a |
 | [French Tech](https://lafrenchtech.gouv.fr/) | 152 | **121** | 122 | 125 | 125 | 125 | 132 | 126 |
-| [Frontend Dogma](https://frontenddogma.com/) | 222 | **213** | 215 | 236 | 221 | 222 | 241 | 222 |
+| [Frontend Dogma](https://frontenddogma.com/) | 223 | **213** | 215 | 236 | 221 | 223 | 241 | 222 |
 | [Google](https://www.google.com/) | 18 | **17** | **17** | **17** | **17** | **17** | 18 | 18 |
-| [Ground News](https://ground.news/) | 2339 | **2052** | 2056 | 2151 | 2179 | 2182 | 2326 | n/a |
+| [Ground News](https://ground.news/) | 1437 | **1222** | 1225 | 1320 | 1346 | 1353 | 1424 | n/a |
 | [HTML Living Standard](https://html.spec.whatwg.org/multipage/) | 149 | **147** | **147** | 153 | **147** | 149 | 155 | 149 |
-| [Igalia](https://www.igalia.com/) | 50 | **33** | **33** | 36 | 36 | 36 | 37 | 36 |
-| [Leanpub](https://leanpub.com/) | 1204 | **997** | **997** | 1004 | 1003 | 1001 | 1198 | n/a |
+| [Igalia](https://www.igalia.com/) | 50 | **34** | **34** | 36 | 36 | 36 | 37 | 37 |
+| [Leanpub](https://leanpub.com/) | 1288 | **1092** | **1092** | 1099 | 1097 | 1094 | 1283 | n/a |
 | [Mastodon](https://mastodon.social/explore) | 37 | **27** | **27** | 32 | 34 | 35 | 35 | 35 |
 | [MDN](https://developer.mozilla.org/en-US/) | 109 | **62** | **62** | 64 | 65 | 65 | 68 | 68 |
-| [Middle East Eye](https://www.middleeasteye.net/) | 222 | **195** | 196 | 202 | 200 | 200 | 202 | 203 |
-| [Nielsen Norman Group](https://www.nngroup.com/) | 84 | 71 | 71 | **53** | 71 | 73 | 74 | 73 |
+| [Middle East Eye](https://www.middleeasteye.net/) | 223 | **196** | **196** | 203 | 201 | 200 | 202 | 203 |
+| [Nielsen Norman Group](https://www.nngroup.com/) | 86 | 74 | 74 | **55** | 74 | 75 | 77 | 76 |
 | [SitePoint](https://www.sitepoint.com/) | 485 | **354** | **354** | 425 | 459 | 464 | 481 | n/a |
 | [TetraLogical](https://tetralogical.com/) | 44 | 38 | 38 | **35** | 38 | 38 | 39 | 39 |
-| [TPGi](https://www.tpgi.com/) | 175 | **159** | 161 | 160 | 164 | 165 | 172 | 171 |
-| [United Nations](https://www.un.org/en/) | 151 | **112** | 114 | 121 | 125 | 124 | 130 | 123 |
-| [W3C](https://www.w3.org/) | 50 | **36** | **36** | 38 | 38 | 38 | 40 | 38 |
-| **Average processing time** |  | 302 ms (26/26) | 356 ms (26/26) | 178 ms (26/26) | 59 ms (26/26) | **16 ms (26/26)** | 329 ms (26/26) | 1468 ms (20/26) |
+| [TPGi](https://www.tpgi.com/) | 175 | **160** | 161 | **160** | 164 | 166 | 172 | 172 |
+| [United Nations](https://www.un.org/en/) | 150 | **112** | 113 | 120 | 124 | 124 | 129 | 122 |
+| [W3C](https://www.w3.org/) | 50 | **35** | 36 | 38 | 38 | 38 | 40 | 38 |
+| **Average processing time** |  | 306 ms (26/26) | 364 ms (26/26) | 162 ms (26/26) | 55 ms (26/26) | **16 ms (26/26)** | 316 ms (26/26) | 1439 ms (20/26) |
 
-(Last updated: Dec 16, 2025)
+(Last updated: Dec 17, 2025)
 <!-- End auto-generated -->
 
 ## Examples

package/cli.js

@@ -28,10 +28,12 @@
 import fs from 'fs';
 import path from 'path';
 import { pathToFileURL } from 'url';
+import os from 'os';
 import { createRequire } from 'module';
 import { camelCase, paramCase } from 'change-case';
 import { Command } from 'commander';
-import { minify } from './src/htmlminifier.js';
+// Lazy-load HMN to reduce CLI cold-start overhead
+// import { minify } from './src/htmlminifier.js';
 import { getPreset, getPresetNames } from './src/presets.js';
 
 const require = createRequire(import.meta.url);
@@ -182,6 +184,15 @@ program.option('-o --output <file>', 'Specify output file (reads from file argum
 program.option('-v --verbose', 'Show detailed processing information');
 program.option('-d --dry', 'Dry run: process and report statistics without writing output');
 
+// Lazy import wrapper for HMN
+let minifyFnPromise;
+async function getMinify() {
+  if (!minifyFnPromise) {
+    minifyFnPromise = import('./src/htmlminifier.js').then(m => m.minify);
+  }
+  return minifyFnPromise;
+}
+
 function readFile(file) {
   try {
     return fs.readFileSync(file, { encoding: 'utf8' });
@@ -270,13 +281,30 @@ program.option('--file-ext <extensions>', 'Specify file extension(s) to process
 (async () => {
   let content;
   let filesProvided = false;
+  let capturedFiles = [];
   await program.arguments('[files...]').action(function (files) {
-    content = files.map(readFile).join('');
+    capturedFiles = files;
     filesProvided = files.length > 0;
+    // Defer reading files until after we check for consumed filenames
   }).parseAsync(process.argv);
 
   const programOptions = program.opts();
 
+  // Check if any `parseJSON` options consumed a filename as their value
+  // If so, treat the option as boolean true and add the filename back to the files list
+  const jsonOptionKeys = ['minifyCss', 'minifyJs', 'minifyUrls'];
+  for (const key of jsonOptionKeys) {
+    const value = programOptions[key];
+    if (typeof value === 'string' && /\.(html?|php|xml|svg|xhtml|jsx|tsx|vue|ejs|hbs|mustache|twig)$/i.test(value)) {
+      // The option consumed a filename - inject it back
+      programOptions[key] = true;
+      capturedFiles.push(value);
+      filesProvided = true;
+    }
+  }
+
+  // Defer reading files—multi-file mode will process per-file later
+
   // Load and normalize config if `--config-file` was specified
   if (programOptions.configFile) {
     config = await loadConfigFromPath(programOptions.configFile);
@@ -344,6 +372,7 @@ program.option('--file-ext <extensions>', 'Specify file extension(s) to process
 
     let minified;
     try {
+      const minify = await getMinify();
       minified = await minify(data, createOptions());
     } catch (err) {
       fatal('Minification error on ' + inputFile + '\n' + err.message);
@@ -472,6 +501,54 @@ program.option('--file-ext <extensions>', 'Specify file extension(s) to process
     process.stderr.write('\r\x1b[K'); // Clear the line
   }
 
+  // Utility: concurrency runner
+  async function runWithConcurrency(items, limit, worker) {
+    const results = new Array(items.length);
+    let next = 0;
+    let active = 0;
+    return new Promise((resolve, reject) => {
+      const launch = () => {
+        while (active < limit && next < items.length) {
+          const current = next++;
+          active++;
+          Promise.resolve(worker(items[current], current))
+            .then((res) => {
+              results[current] = res;
+              active--;
+              launch();
+            })
+            .catch(reject);
+        }
+        if (next >= items.length && active === 0) {
+          resolve(results);
+        }
+      };
+      launch();
+    });
+  }
+
+  async function collectFiles(dir, extensions, skipRootAbs, ignorePatterns, baseDir) {
+    const out = [];
+    const entries = await fs.promises.readdir(dir).catch(() => []);
+    for (const name of entries) {
+      const filePath = path.join(dir, name);
+      if (skipRootAbs) {
+        const real = await fs.promises.realpath(filePath).catch(() => undefined);
+        if (real && (real === skipRootAbs || real.startsWith(skipRootAbs + path.sep))) continue;
+      }
+      const lst = await fs.promises.lstat(filePath).catch(() => null);
+      if (!lst || lst.isSymbolicLink()) continue;
+      if (lst.isDirectory()) {
+        if (shouldIgnoreDirectory(filePath, ignorePatterns, baseDir)) continue;
+        const sub = await collectFiles(filePath, extensions, skipRootAbs, ignorePatterns, baseDir);
+        out.push(...sub);
+      } else if (shouldProcessFile(name, extensions)) {
+        out.push(filePath);
+      }
+    }
+    return out;
+  }
+
   async function processDirectory(inputDir, outputDir, extensions, isDryRun = false, isVerbose = false, skipRootAbs, progress = null, ignorePatterns = [], baseDir = null) {
     // If first call provided a string, normalize once; otherwise assume pre-parsed array
     if (typeof extensions === 'string') {
@@ -483,61 +560,27 @@ program.option('--file-ext <extensions>', 'Specify file extension(s) to process
       baseDir = inputDir;
     }
 
-    const files = await fs.promises.readdir(inputDir).catch(err => {
-      fatal('Cannot read directory ' + inputDir + '\n' + err.message);
-    });
-
-    const allStats = [];
-
-    for (const file of files) {
-      const inputFile = path.join(inputDir, file);
-      const outputFile = path.join(outputDir, file);
-
-      // Skip anything inside the output root to avoid reprocessing
-      if (skipRootAbs) {
-        const real = await fs.promises.realpath(inputFile).catch(() => undefined);
-        if (real && (real === skipRootAbs || real.startsWith(skipRootAbs + path.sep))) {
-          continue;
-        }
-      }
-
-      const lst = await fs.promises.lstat(inputFile).catch(err => {
-        fatal('Cannot read ' + inputFile + '\n' + err.message);
-      });
-
-      if (lst.isSymbolicLink()) {
-        continue;
+    // Collect all files first for bounded parallel processing
+    const list = await collectFiles(inputDir, extensions, skipRootAbs, ignorePatterns, baseDir);
+    const allStats = new Array(list.length);
+    const concurrency = Math.max(1, Math.min(os.cpus().length || 4, 8));
+    await runWithConcurrency(list, concurrency, async (inputFile, idx) => {
+      const rel = path.relative(inputDir, inputFile);
+      const outFile = path.join(outputDir, rel);
+      const outDir = path.dirname(outFile);
+      if (!isDryRun) {
+        await fs.promises.mkdir(outDir, { recursive: true }).catch(err => {
+          fatal('Cannot create directory ' + outDir + '\n' + err.message);
+        });
       }
-
-      if (lst.isDirectory()) {
-        // Skip ignored directories
-        if (shouldIgnoreDirectory(inputFile, ignorePatterns, baseDir)) {
-          continue;
-        }
-        const dirStats = await processDirectory(inputFile, outputFile, extensions, isDryRun, isVerbose, skipRootAbs, progress, ignorePatterns, baseDir);
-        if (dirStats) {
-          allStats.push(...dirStats);
-        }
-      } else if (shouldProcessFile(file, extensions)) {
-        if (!isDryRun) {
-          await fs.promises.mkdir(outputDir, { recursive: true }).catch(err => {
-            fatal('Cannot create directory ' + outputDir + '\n' + err.message);
-          });
-        }
-        const fileStats = await processFile(inputFile, outputFile, isDryRun, isVerbose);
-        if (fileStats) {
-          allStats.push(fileStats);
-        }
-
-        // Update progress after processing
-        if (progress) {
-          progress.current++;
-          updateProgress(progress.current, progress.total);
-        }
+      const stats = await processFile(inputFile, outFile, isDryRun, isVerbose);
+      allStats[idx] = stats;
+      if (progress) {
+        progress.current++;
+        updateProgress(progress.current, progress.total);
       }
-    }
-
-    return allStats;
+    });
+    return allStats.filter(Boolean);
   }
 
   const writeMinify = async () => {
@@ -551,6 +594,7 @@ program.option('--file-ext <extensions>', 'Specify file extension(s) to process
     let minified;
 
     try {
+      const minify = await getMinify();
       minified = await minify(content, minifierOptions);
     } catch (err) {
       fatal('Minification error:\n' + err.message);
@@ -576,17 +620,12 @@ program.option('--file-ext <extensions>', 'Specify file extension(s) to process
     }
 
     if (programOptions.output) {
-      await fs.promises.mkdir(path.dirname(programOptions.output), { recursive: true }).catch((e) => {
-        fatal('Cannot create directory ' + path.dirname(programOptions.output) + '\n' + e.message);
-      });
-      await new Promise((resolve, reject) => {
-        const fileStream = fs.createWriteStream(programOptions.output)
-          .on('error', reject)
-          .on('finish', resolve);
-        fileStream.end(minified);
-        }).catch((e) => {
-        fatal('Cannot write ' + programOptions.output + '\n' + e.message);
-      });
+      try {
+        await fs.promises.mkdir(path.dirname(programOptions.output), { recursive: true });
+        await fs.promises.writeFile(programOptions.output, minified, { encoding: 'utf8' });
+      } catch (err) {
+        fatal('Cannot write ' + programOptions.output + '\n' + err.message);
+      }
       return;
     }
 
@@ -646,6 +685,16 @@ program.option('--file-ext <extensions>', 'Specify file extension(s) to process
       // Parse ignore patterns
       const ignorePatterns = parseIgnorePatterns(resolvedIgnoreDir);
 
+      // Validate that the input directory exists and is readable
+      try {
+        const stat = await fs.promises.stat(inputDir);
+        if (!stat.isDirectory()) {
+          fatal(inputDir + ' is not a directory');
+        }
+      } catch (err) {
+        fatal('Cannot read directory ' + inputDir + '\n' + err.message);
+      }
+
       // Resolve base directory for consistent path comparisons
       const inputDirResolved = await fs.promises.realpath(inputDir).catch(() => inputDir);
 
@@ -688,12 +737,72 @@ program.option('--file-ext <extensions>', 'Specify file extension(s) to process
       }
     })();
   } else if (filesProvided) { // Minifying one or more files specified on the CMD line
-    writeMinify();
+    // Process each file independently, then concatenate outputs to preserve current behavior
+    const minifierOptions = createOptions();
+    // Show config info if verbose/dry
+    if (programOptions.verbose || programOptions.dry) {
+      getActiveOptionsDisplay(minifierOptions);
+    }
+
+    const concurrency = Math.max(1, Math.min(os.cpus().length || 4, 8));
+    const inputs = capturedFiles.slice();
+
+    // Read originals and minify in parallel with bounded concurrency
+    const originals = new Array(inputs.length);
+    const outputs = new Array(inputs.length);
+
+    await runWithConcurrency(inputs, concurrency, async (file, idx) => {
+      const data = await fs.promises.readFile(file, 'utf8').catch(err => fatal('Cannot read ' + file + '\n' + err.message));
+      const minify = await getMinify();
+      let out;
+      try {
+        out = await minify(data, minifierOptions);
+      } catch (err) {
+        fatal('Minification error on ' + file + '\n' + err.message);
+      }
+      originals[idx] = data;
+      outputs[idx] = out;
+    });
+
+    const originalCombined = originals.join('');
+    const minifiedCombined = outputs.join('');
+
+    const stats = calculateStats(originalCombined, minifiedCombined);
+
+    if (programOptions.dry) {
+      const inputSource = capturedFiles.join(', ');
+      const outputDest = programOptions.output || 'STDOUT';
+      console.error(`[DRY RUN] Would minify: ${inputSource} → ${outputDest}`);
+      console.error(`  Original: ${stats.originalSize.toLocaleString()} bytes`);
+      console.error(`  Minified: ${stats.minifiedSize.toLocaleString()} bytes`);
+      console.error(`  Saved: ${stats.sign}${Math.abs(stats.saved).toLocaleString()} bytes (${stats.percentage}%)`);
+      process.exit(0);
+    }
+
+    if (programOptions.verbose) {
+      const inputSource = capturedFiles.join(', ');
+      console.error(`  ✓ ${inputSource}: ${stats.originalSize.toLocaleString()} → ${stats.minifiedSize.toLocaleString()} bytes (${stats.sign}${Math.abs(stats.saved).toLocaleString()}, ${stats.percentage}%)`);
+    }
+
+    if (programOptions.output) {
+      try {
+        await fs.promises.mkdir(path.dirname(programOptions.output), { recursive: true });
+        await fs.promises.writeFile(programOptions.output, minifiedCombined, 'utf8');
+      } catch (err) {
+        fatal('Cannot write ' + programOptions.output + '\n' + err.message);
+      }
+    } else {
+      process.stdout.write(minifiedCombined);
+    }
+    process.exit(0);
   } else { // Minifying input coming from STDIN
     content = '';
     process.stdin.setEncoding('utf8');
     process.stdin.on('data', function (data) {
       content += data;
-    }).on('end', writeMinify);
+    }).on('end', async function() {
+      await writeMinify();
+      process.exit(0);
+    });
   }
 })();