html-minifier-next 4.11.1 → 4.12.0

package/README.md

@@ -236,32 +236,32 @@ 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/) | 266 | **206** | n/a | 236 | 239 | 240 | 242 | 243 |
-| [BBC](https://www.bbc.co.uk/) | 697 | **634** | n/a | 655 | 655 | 656 | 691 | n/a |
-| [CERN](https://home.cern/) | 156 | **87** | n/a | 95 | 95 | 95 | 97 | 100 |
-| [CSS-Tricks](https://css-tricks.com/) | 163 | **122** | n/a | 128 | 143 | 144 | 149 | 145 |
-| [ECMAScript](https://tc39.es/ecma262/) | 7238 | **6342** | **6342** | 6561 | 6444 | 6567 | 6614 | 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/) | 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/) | 55 | **47** | n/a | 50 | 48 | 49 | 50 | 50 |
+| [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/) | 1604 | 1494 | 1499 | **1437** | 1527 | 1539 | 1550 | 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/) | 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/) | 1481 | **1259** | n/a | 1361 | 1386 | 1392 | 1468 | n/a |
-| [HTML Living Standard](https://html.spec.whatwg.org/multipage/) | 149 | **147** | n/a | 153 | **147** | 149 | 155 | 149 |
-| [Igalia](https://www.igalia.com/) | 50 | **33** | **33** | 36 | 36 | 36 | 37 | 36 |
-| [Leanpub](https://leanpub.com/) | 1521 | **1287** | **1287** | 1294 | 1293 | 1290 | 1516 | n/a |
-| [Mastodon](https://mastodon.social/explore) | 37 | **27** | n/a | 32 | 34 | 35 | 35 | 35 |
-| [MDN](https://developer.mozilla.org/en-US/) | 109 | **62** | n/a | 64 | 65 | 65 | 68 | 68 |
-| [Middle East Eye](https://www.middleeasteye.net/) | 222 | **195** | **195** | 202 | 200 | 200 | 202 | 203 |
+| [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 | **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/) | 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** | n/a | 160 | 164 | 166 | 172 | 171 |
+| [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 | **36** | **36** | 38 | 38 | 38 | 40 | 38 |
-| **Average processing time** |  | 478 ms (26/26) | 735 ms (16/26) | 174 ms (26/26) | 57 ms (26/26) | **17 ms (26/26)** | 318 ms (26/26) | 1536 ms (20/26) |
+| [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 17, 2025)
 <!-- End auto-generated -->

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);
+    });
   }
 })();

package/dist/htmlminifier.cjs

@@ -92,7 +92,7 @@ const preCompiledStackedTags = {
 // Cache for compiled attribute regexes per handler configuration
 const attrRegexCache = new WeakMap();
 
-function attrForHandler(handler) {
+function buildAttrRegex(handler) {
   let pattern = singleAttrIdentifier.source +
     '(?:\\s*(' + joinSingleAttrAssigns(handler) + ')' +
     '[ \\t\\n\\f\\r]*(?:' + singleAttrValues.join('|') + '))?';
@@ -111,6 +111,14 @@ function attrForHandler(handler) {
   return new RegExp('^\\s*' + pattern);
 }
 
+function getAttrRegexForHandler(handler) {
+  let cached = attrRegexCache.get(handler);
+  if (cached) return cached;
+  const compiled = buildAttrRegex(handler);
+  attrRegexCache.set(handler, compiled);
+  return compiled;
+}
+
 function joinSingleAttrAssigns(handler) {
   return singleAttrAssigns.concat(
     handler.customAttrAssign || []
@@ -134,12 +142,8 @@ class HTMLParser {
     const fullLength = fullHtml.length;
 
     const stack = []; let lastTag;
-    // Use cached attribute regex if available
-    let attribute = attrRegexCache.get(handler);
-    if (!attribute) {
-      attribute = attrForHandler(handler);
-      attrRegexCache.set(handler, attribute);
-    }
+    // Use cached attribute regex for this handler configuration
+    const attribute = getAttrRegexForHandler(handler);
     let prevTag = undefined, nextTag = undefined;
 
     // Index-based parsing
@@ -1263,7 +1267,7 @@ const cssMinifyCache = new LRU(200);
 
 const trimWhitespace = str => {
   if (!str) return str;
-  // Fast path: if no whitespace at start or end, return early
+  // Fast path: If no whitespace at start or end, return early
   if (!/^[ \n\r\t\f]/.test(str) && !/[ \n\r\t\f]$/.test(str)) {
     return str;
   }
@@ -1272,7 +1276,7 @@ const trimWhitespace = str => {
 
 function collapseWhitespaceAll(str) {
   if (!str) return str;
-  // Fast path: if there are no common whitespace characters, return early
+  // Fast path: If there are no common whitespace characters, return early
   if (!/[ \n\r\t\f\xA0]/.test(str)) {
     return str;
   }
@@ -2027,7 +2031,7 @@ async function normalizeAttr(attr, attrs, tag, options) {
   let attrValue = attr.value;
 
   if (options.decodeEntities && attrValue) {
-    // Fast path: only decode when entities are present
+    // Fast path: Only decode when entities are present
     if (attrValue.indexOf('&') !== -1) {
       attrValue = entities.decodeHTMLStrict(attrValue);
     }
@@ -2227,7 +2231,7 @@ const processOptions = (inputOptions) => {
       const lightningCssOptions = typeof option === 'object' ? option : {};
 
       options.minifyCSS = async function (text, type) {
-        // Fast path: nothing to minify
+        // Fast path: Nothing to minify
         if (!text || !text.trim()) {
           return text;
         }
@@ -2319,7 +2323,7 @@ const processOptions = (inputOptions) => {
 
         let jsKey;
         try {
-          // Fast path: avoid invoking Terser for empty/whitespace-only content
+          // Fast path: Avoid invoking Terser for empty/whitespace-only content
           if (!code || !code.trim()) {
             return '';
           }
@@ -2371,9 +2375,18 @@ const processOptions = (inputOptions) => {
         relateUrlOptions = {};
       }
 
+      // Cache RelateURL instance for reuse (expensive to create)
+      const relateUrlInstance = new RelateURL(relateUrlOptions.site || '', relateUrlOptions);
+
       options.minifyURLs = function (text) {
+        // Fast-path: Skip if text doesn’t look like a URL that needs processing
+        // Only process if contains URL-like characters (`/`, `:`, `#`, `?`) or spaces that need encoding
+        if (!/[/:?#\s]/.test(text)) {
+          return text;
+        }
+
         try {
-          return RelateURL.relate(text, relateUrlOptions);
+          return relateUrlInstance.relate(text);
         } catch (err) {
           if (!options.continueOnMinifyError) {
             throw err;
@@ -2469,11 +2482,11 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
 
     try {
       await parser.parse();
-    } catch (e) {
+    } catch (err) {
       // If parsing fails during analysis pass, just skip it—we’ll still have
       // partial frequency data from what we could parse
       if (!options.continueOnParseError) {
-        throw e;
+        throw err;
       }
     }
   }
@@ -2562,7 +2575,21 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
   }
   if (classChain) {
     const sorter = classChain.createSorter();
+    // Memoize `sortClassName` results—class lists often repeat in templates
+    const classNameCache = new LRU(200);
+
     options.sortClassName = function (value) {
+      // Fast path: Single class (no spaces) needs no sorting
+      if (value.indexOf(' ') === -1) {
+        return value;
+      }
+
+      // Check cache first
+      const cached = classNameCache.get(value);
+      if (cached !== undefined) {
+        return cached;
+      }
+
       // Expand UID tokens back to original content before sorting
       // Fast path: Skip if no HTML comments (UID markers) present
       let expandedValue = value;
@@ -2577,7 +2604,11 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
         return cls !== '';
       });
       const sorted = sorter.sort(classes);
-      return sorted.join(' ');
+      const result = sorted.join(' ');
+
+      // Cache the result
+      classNameCache.set(value, result);
+      return result;
     };
   }
 }
@@ -2618,7 +2649,7 @@ async function minifyHTML(value, options, partialMarkup) {
   const customElementsInput = options.inlineCustomElements ?? [];
   const customElementsArr = Array.isArray(customElementsInput) ? customElementsInput : Array.from(customElementsInput);
   const normalizedCustomElements = customElementsArr.map(name => options.name(name));
-  // Fast path: reuse base Sets if no custom elements
+  // Fast path: Reuse base Sets if no custom elements
   const inlineTextSet = normalizedCustomElements.length
     ? new Set([...inlineElementsToKeepWhitespaceWithin, ...normalizedCustomElements])
     : inlineElementsToKeepWhitespaceWithin;

package/dist/htmlminifier.esm.bundle.js

@@ -5234,7 +5234,7 @@ const preCompiledStackedTags = {
 // Cache for compiled attribute regexes per handler configuration
 const attrRegexCache = new WeakMap();
 
-function attrForHandler(handler) {
+function buildAttrRegex(handler) {
   let pattern = singleAttrIdentifier.source +
     '(?:\\s*(' + joinSingleAttrAssigns(handler) + ')' +
     '[ \\t\\n\\f\\r]*(?:' + singleAttrValues.join('|') + '))?';
@@ -5253,6 +5253,14 @@ function attrForHandler(handler) {
   return new RegExp('^\\s*' + pattern);
 }
 
+function getAttrRegexForHandler(handler) {
+  let cached = attrRegexCache.get(handler);
+  if (cached) return cached;
+  const compiled = buildAttrRegex(handler);
+  attrRegexCache.set(handler, compiled);
+  return compiled;
+}
+
 function joinSingleAttrAssigns(handler) {
   return singleAttrAssigns.concat(
     handler.customAttrAssign || []
@@ -5276,12 +5284,8 @@ class HTMLParser {
     const fullLength = fullHtml.length;
 
     const stack = []; let lastTag;
-    // Use cached attribute regex if available
-    let attribute = attrRegexCache.get(handler);
-    if (!attribute) {
-      attribute = attrForHandler(handler);
-      attrRegexCache.set(handler, attribute);
-    }
+    // Use cached attribute regex for this handler configuration
+    const attribute = getAttrRegexForHandler(handler);
     let prevTag = undefined, nextTag = undefined;
 
     // Index-based parsing
@@ -6405,7 +6409,7 @@ const cssMinifyCache = new LRU(200);
 
 const trimWhitespace = str => {
   if (!str) return str;
-  // Fast path: if no whitespace at start or end, return early
+  // Fast path: If no whitespace at start or end, return early
   if (!/^[ \n\r\t\f]/.test(str) && !/[ \n\r\t\f]$/.test(str)) {
     return str;
   }
@@ -6414,7 +6418,7 @@ const trimWhitespace = str => {
 
 function collapseWhitespaceAll(str) {
   if (!str) return str;
-  // Fast path: if there are no common whitespace characters, return early
+  // Fast path: If there are no common whitespace characters, return early
   if (!/[ \n\r\t\f\xA0]/.test(str)) {
     return str;
   }
@@ -7169,7 +7173,7 @@ async function normalizeAttr(attr, attrs, tag, options) {
   let attrValue = attr.value;
 
   if (options.decodeEntities && attrValue) {
-    // Fast path: only decode when entities are present
+    // Fast path: Only decode when entities are present
     if (attrValue.indexOf('&') !== -1) {
       attrValue = decodeHTMLStrict(attrValue);
     }
@@ -7369,7 +7373,7 @@ const processOptions = (inputOptions) => {
       const lightningCssOptions = typeof option === 'object' ? option : {};
 
       options.minifyCSS = async function (text, type) {
-        // Fast path: nothing to minify
+        // Fast path: Nothing to minify
         if (!text || !text.trim()) {
           return text;
         }
@@ -7461,7 +7465,7 @@ const processOptions = (inputOptions) => {
 
         let jsKey;
         try {
-          // Fast path: avoid invoking Terser for empty/whitespace-only content
+          // Fast path: Avoid invoking Terser for empty/whitespace-only content
           if (!code || !code.trim()) {
             return '';
           }
@@ -7513,9 +7517,18 @@ const processOptions = (inputOptions) => {
         relateUrlOptions = {};
       }
 
+      // Cache RelateURL instance for reuse (expensive to create)
+      const relateUrlInstance = new RelateURL(relateUrlOptions.site || '', relateUrlOptions);
+
       options.minifyURLs = function (text) {
+        // Fast-path: Skip if text doesn’t look like a URL that needs processing
+        // Only process if contains URL-like characters (`/`, `:`, `#`, `?`) or spaces that need encoding
+        if (!/[/:?#\s]/.test(text)) {
+          return text;
+        }
+
         try {
-          return RelateURL.relate(text, relateUrlOptions);
+          return relateUrlInstance.relate(text);
         } catch (err) {
           if (!options.continueOnMinifyError) {
             throw err;
@@ -7611,11 +7624,11 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
 
     try {
       await parser.parse();
-    } catch (e) {
+    } catch (err) {
       // If parsing fails during analysis pass, just skip it—we’ll still have
       // partial frequency data from what we could parse
       if (!options.continueOnParseError) {
-        throw e;
+        throw err;
       }
     }
   }
@@ -7704,7 +7717,21 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
   }
   if (classChain) {
     const sorter = classChain.createSorter();
+    // Memoize `sortClassName` results—class lists often repeat in templates
+    const classNameCache = new LRU(200);
+
     options.sortClassName = function (value) {
+      // Fast path: Single class (no spaces) needs no sorting
+      if (value.indexOf(' ') === -1) {
+        return value;
+      }
+
+      // Check cache first
+      const cached = classNameCache.get(value);
+      if (cached !== undefined) {
+        return cached;
+      }
+
       // Expand UID tokens back to original content before sorting
       // Fast path: Skip if no HTML comments (UID markers) present
       let expandedValue = value;
@@ -7719,7 +7746,11 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
         return cls !== '';
       });
       const sorted = sorter.sort(classes);
-      return sorted.join(' ');
+      const result = sorted.join(' ');
+
+      // Cache the result
+      classNameCache.set(value, result);
+      return result;
     };
   }
 }
@@ -7760,7 +7791,7 @@ async function minifyHTML(value, options, partialMarkup) {
   const customElementsInput = options.inlineCustomElements ?? [];
   const customElementsArr = Array.isArray(customElementsInput) ? customElementsInput : Array.from(customElementsInput);
   const normalizedCustomElements = customElementsArr.map(name => options.name(name));
-  // Fast path: reuse base Sets if no custom elements
+  // Fast path: Reuse base Sets if no custom elements
   const inlineTextSet = normalizedCustomElements.length
     ? new Set([...inlineElementsToKeepWhitespaceWithin, ...normalizedCustomElements])
     : inlineElementsToKeepWhitespaceWithin;

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"htmlparser.d.ts","sourceRoot":"","sources":["../../src/htmlparser.js"],"names":[],"mappings":"AA8CA,4BAAoE;AAuEpE;IACE,qCAGC;IAFC,UAAgB;IAChB,aAAsB;IAGxB,uBAoeC;CACF"}
+{"version":3,"file":"htmlparser.d.ts","sourceRoot":"","sources":["../../src/htmlparser.js"],"names":[],"mappings":"AA8CA,4BAAoE;AA+EpE;IACE,qCAGC;IAFC,UAAgB;IAChB,aAAsB;IAGxB,uBAgeC;CACF"}

package/package.json

@@ -84,5 +84,5 @@
     "test:watch": "node --test --watch tests/*.spec.js"
   },
   "type": "module",
-  "version": "4.11.1"
+  "version": "4.12.0"
 }

package/src/htmlminifier.js

@@ -463,7 +463,7 @@ const cssMinifyCache = new LRU(200);
 
 const trimWhitespace = str => {
   if (!str) return str;
-  // Fast path: if no whitespace at start or end, return early
+  // Fast path: If no whitespace at start or end, return early
   if (!/^[ \n\r\t\f]/.test(str) && !/[ \n\r\t\f]$/.test(str)) {
     return str;
   }
@@ -472,7 +472,7 @@ const trimWhitespace = str => {
 
 function collapseWhitespaceAll(str) {
   if (!str) return str;
-  // Fast path: if there are no common whitespace characters, return early
+  // Fast path: If there are no common whitespace characters, return early
   if (!/[ \n\r\t\f\xA0]/.test(str)) {
     return str;
   }
@@ -1227,7 +1227,7 @@ async function normalizeAttr(attr, attrs, tag, options) {
   let attrValue = attr.value;
 
   if (options.decodeEntities && attrValue) {
-    // Fast path: only decode when entities are present
+    // Fast path: Only decode when entities are present
     if (attrValue.indexOf('&') !== -1) {
       attrValue = decodeHTMLStrict(attrValue);
     }
@@ -1427,7 +1427,7 @@ const processOptions = (inputOptions) => {
       const lightningCssOptions = typeof option === 'object' ? option : {};
 
       options.minifyCSS = async function (text, type) {
-        // Fast path: nothing to minify
+        // Fast path: Nothing to minify
         if (!text || !text.trim()) {
           return text;
         }
@@ -1519,7 +1519,7 @@ const processOptions = (inputOptions) => {
 
         let jsKey;
         try {
-          // Fast path: avoid invoking Terser for empty/whitespace-only content
+          // Fast path: Avoid invoking Terser for empty/whitespace-only content
           if (!code || !code.trim()) {
             return '';
           }
@@ -1571,9 +1571,18 @@ const processOptions = (inputOptions) => {
         relateUrlOptions = {};
       }
 
+      // Cache RelateURL instance for reuse (expensive to create)
+      const relateUrlInstance = new RelateURL(relateUrlOptions.site || '', relateUrlOptions);
+
       options.minifyURLs = function (text) {
+        // Fast-path: Skip if text doesn’t look like a URL that needs processing
+        // Only process if contains URL-like characters (`/`, `:`, `#`, `?`) or spaces that need encoding
+        if (!/[/:?#\s]/.test(text)) {
+          return text;
+        }
+
         try {
-          return RelateURL.relate(text, relateUrlOptions);
+          return relateUrlInstance.relate(text);
         } catch (err) {
           if (!options.continueOnMinifyError) {
             throw err;
@@ -1669,11 +1678,11 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
 
     try {
       await parser.parse();
-    } catch (e) {
+    } catch (err) {
       // If parsing fails during analysis pass, just skip it—we’ll still have
       // partial frequency data from what we could parse
       if (!options.continueOnParseError) {
-        throw e;
+        throw err;
       }
     }
   }
@@ -1762,7 +1771,21 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
   }
   if (classChain) {
     const sorter = classChain.createSorter();
+    // Memoize `sortClassName` results—class lists often repeat in templates
+    const classNameCache = new LRU(200);
+
     options.sortClassName = function (value) {
+      // Fast path: Single class (no spaces) needs no sorting
+      if (value.indexOf(' ') === -1) {
+        return value;
+      }
+
+      // Check cache first
+      const cached = classNameCache.get(value);
+      if (cached !== undefined) {
+        return cached;
+      }
+
       // Expand UID tokens back to original content before sorting
       // Fast path: Skip if no HTML comments (UID markers) present
       let expandedValue = value;
@@ -1777,7 +1800,11 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
         return cls !== '';
       });
       const sorted = sorter.sort(classes);
-      return sorted.join(' ');
+      const result = sorted.join(' ');
+
+      // Cache the result
+      classNameCache.set(value, result);
+      return result;
     };
   }
 }
@@ -1818,7 +1845,7 @@ async function minifyHTML(value, options, partialMarkup) {
   const customElementsInput = options.inlineCustomElements ?? [];
   const customElementsArr = Array.isArray(customElementsInput) ? customElementsInput : Array.from(customElementsInput);
   const normalizedCustomElements = customElementsArr.map(name => options.name(name));
-  // Fast path: reuse base Sets if no custom elements
+  // Fast path: Reuse base Sets if no custom elements
   const inlineTextSet = normalizedCustomElements.length
     ? new Set([...inlineElementsToKeepWhitespaceWithin, ...normalizedCustomElements])
     : inlineElementsToKeepWhitespaceWithin;

package/src/htmlparser.js

@@ -85,7 +85,7 @@ const preCompiledStackedTags = {
 // Cache for compiled attribute regexes per handler configuration
 const attrRegexCache = new WeakMap();
 
-function attrForHandler(handler) {
+function buildAttrRegex(handler) {
   let pattern = singleAttrIdentifier.source +
     '(?:\\s*(' + joinSingleAttrAssigns(handler) + ')' +
     '[ \\t\\n\\f\\r]*(?:' + singleAttrValues.join('|') + '))?';
@@ -104,6 +104,14 @@ function attrForHandler(handler) {
   return new RegExp('^\\s*' + pattern);
 }
 
+function getAttrRegexForHandler(handler) {
+  let cached = attrRegexCache.get(handler);
+  if (cached) return cached;
+  const compiled = buildAttrRegex(handler);
+  attrRegexCache.set(handler, compiled);
+  return compiled;
+}
+
 function joinSingleAttrAssigns(handler) {
   return singleAttrAssigns.concat(
     handler.customAttrAssign || []
@@ -127,12 +135,8 @@ export class HTMLParser {
     const fullLength = fullHtml.length;
 
     const stack = []; let lastTag;
-    // Use cached attribute regex if available
-    let attribute = attrRegexCache.get(handler);
-    if (!attribute) {
-      attribute = attrForHandler(handler);
-      attrRegexCache.set(handler, attribute);
-    }
+    // Use cached attribute regex for this handler configuration
+    const attribute = getAttrRegexForHandler(handler);
     let prevTag = undefined, nextTag = undefined;
 
     // Index-based parsing