html-minifier-next 4.8.3 → 4.9.1

package/README.md

@@ -4,7 +4,7 @@
 
 HTML Minifier Next (HMN) is a **super-configurable, well-tested, JavaScript-based HTML minifier**.
 
-The project was based on [HTML Minifier Terser](https://github.com/terser/html-minifier-terser), which in turn had been based on [Juriy Zaytsev’s HTML Minifier](https://github.com/kangax/html-minifier). HMN offers additional features, but is backwards-compatible with both. The project was set up because as of 2025, both HTML Minifier Terser and HTML Minifier had been unmaintained for a few years. As the project seems maintainable [to me, [Jens](https://meiert.com/)]—even more so with community support—, it’s being [updated, extended, and documented](https://github.com/j9t/html-minifier-next/blob/main/CHANGELOG.md) further in this place.
+The project was based on [HTML Minifier Terser](https://github.com/terser/html-minifier-terser), which in turn had been based on [Juriy “kangax” Zaytsev’s HTML Minifier](https://github.com/kangax/html-minifier). HMN offers additional features, but is backwards-compatible with both. The project was set up because as of 2025, both HTML Minifier Terser and HTML Minifier had been unmaintained for a few years. As the project seems maintainable [to me, [Jens](https://meiert.com/), an HTML optimizer]—even more so with community support—, it’s being [updated, extended, and documented](https://github.com/j9t/html-minifier-next/blob/main/CHANGELOG.md) further in this place.
 
 ## Installation
 
@@ -29,11 +29,12 @@ Use `html-minifier-next --help` to check all available options:
 | Option | Description | Example |
 | --- | --- | --- |
 | `--input-dir <dir>` | Specify an input directory (best restricted with `--file-ext`) | `--input-dir=src` |
+| `--ignore-dir <patterns>` | Exclude directories—relative to input directory—from processing (comma-separated, overrides config file setting) | `--ignore-dir=libs`, `--ignore-dir=libs,vendor,node_modules` |
 | `--output-dir <dir>` | Specify an output directory | `--output-dir=dist` |
-| `--file-ext <extensions>` | Specify file extension(s) to process (overrides config file setting) | `--file-ext=html`, `--file-ext=html,htm,php`, `--file-ext="html, htm, php"` |
+| `--file-ext <extensions>` | Specify file extension(s) to process (comma-separated, overrides config file setting) | `--file-ext=html`, `--file-ext=html,htm,php`, `--file-ext="html, htm, php"` |
 | `-o <file>`, `--output <file>` | Specify output file (reads from file arguments or STDIN) | File to file: `html-minifier-next input.html -o output.html`<br>Pipe to file: `cat input.html \| html-minifier-next -o output.html`<br>File to STDOUT: `html-minifier-next input.html` |
 | `-c <file>`, `--config-file <file>` | Use a configuration file | `--config-file=html-minifier.json` |
-| `--preset <name>` | Use a preset configuration (conservative, comprehensive) | `--preset=conservative` |
+| `--preset <name>` | Use a preset configuration (conservative or comprehensive) | `--preset=conservative` |
 | `-v`, `--verbose` | Show detailed processing information (active options, file statistics) | `html-minifier-next --input-dir=src --output-dir=dist --verbose --collapse-whitespace` |
 | `-d`, `--dry` | Dry run: Process and report statistics without writing output | `html-minifier-next input.html --dry --collapse-whitespace` |
 | `-V`, `--version` | Output the version number | `html-minifier-next --version` |
@@ -48,7 +49,8 @@ You can also use a configuration file to specify options. The file can be either
 {
   "collapseWhitespace": true,
   "removeComments": true,
-  "fileExt": "html,htm"
+  "fileExt": "html,htm",
+  "ignoreDir": "libs,vendor"
 }
 ```
 
@@ -58,7 +60,8 @@ You can also use a configuration file to specify options. The file can be either
 module.exports = {
   collapseWhitespace: true,
   removeComments: true,
-  fileExt: "html,htm"
+  fileExt: "html,htm",
+  ignoreDir: ["libs", "vendor"]
 };
 ```
 
@@ -230,29 +233,30 @@ 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/) | 258 | **202** | **202** | 230 | 233 | 234 | 236 | 237 |
-| [BBC](https://www.bbc.co.uk/) | 633 | **575** | 585 | 594 | 594 | 595 | 628 | n/a |
-| [CSS-Tricks](https://css-tricks.com/) | 161 | 121 | **119** | 126 | 141 | 141 | 147 | 143 |
+| [Apple](https://www.apple.com/) | 260 | **204** | **204** | 232 | 235 | 236 | 238 | 239 |
+| [BBC](https://www.bbc.co.uk/) | 803 | **683** | 693 | 746 | 757 | 760 | 796 | n/a |
+| [CSS-Tricks](https://css-tricks.com/) | 161 | 121 | **119** | 126 | 142 | 142 | 147 | 143 |
 | [ECMAScript](https://tc39.es/ecma262/) | 7238 | **6341** | **6341** | 6561 | 6444 | 6567 | 6614 | n/a |
-| [EFF](https://www.eff.org/) | 55 | **47** | **47** | 50 | 48 | 49 | 50 | 50 |
-| [FAZ](https://www.faz.net/aktuell/) | 1573 | 1465 | 1470 | **1411** | 1498 | 1509 | 1520 | n/a |
-| [Frontend Dogma](https://frontenddogma.com/) | 222 | **213** | **213** | 234 | 219 | 221 | 239 | 220 |
-| [Google](https://www.google.com/) | 76 | **71** | 72 | n/a | 72 | 73 | 76 | 75 |
+| [EFF](https://www.eff.org/) | 56 | **47** | 48 | 50 | 49 | 49 | 51 | 51 |
+| [FAZ](https://www.faz.net/aktuell/) | 1602 | 1492 | 1497 | **1435** | 1525 | 1537 | 1548 | n/a |
+| [Frontend Dogma](https://frontenddogma.com/) | 222 | **212** | 213 | 234 | 219 | 221 | 240 | 221 |
+| [Google](https://www.google.com/) | 18 | **17** | **17** | **17** | **17** | **17** | 18 | 18 |
+| [Ground News](https://ground.news/) | 1576 | **1353** | 1356 | 1450 | 1473 | 1478 | 1563 | n/a |
 | [HTML Living Standard](https://html.spec.whatwg.org/multipage/) | 149 | **147** | **147** | 153 | **147** | 149 | 155 | 149 |
 | [Igalia](https://www.igalia.com/) | 49 | **33** | **33** | 35 | 35 | 35 | 36 | 36 |
-| [Leanpub](https://leanpub.com/) | 1457 | **1225** | **1225** | 1232 | 1231 | 1226 | 1451 | n/a |
-| [Mastodon](https://mastodon.social/explore) | 35 | **26** | **26** | 30 | 33 | 33 | 34 | 34 |
-| [MDN](https://developer.mozilla.org/en-US/) | 107 | **62** | **62** | 64 | 64 | 65 | 67 | 68 |
-| [Middle East Eye](https://www.middleeasteye.net/) | 222 | **195** | **195** | 202 | 200 | 200 | 202 | 203 |
-| [Nielsen Norman Group](https://www.nngroup.com/) | 84 | 71 | 71 | **53** | 71 | 72 | 74 | 73 |
-| [SitePoint](https://www.sitepoint.com/) | 495 | **353** | **353** | 431 | 469 | 473 | 491 | n/a |
-| [TetraLogical](https://tetralogical.com/) | 44 | 38 | 38 | **35** | 37 | 38 | 39 | 39 |
-| [TPGi](https://www.tpgi.com/) | 99 | **79** | **79** | 84 | 84 | 84 | 88 | 86 |
-| [United Nations](https://www.un.org/en/) | 154 | **115** | 116 | 123 | 127 | 127 | 133 | 126 |
-| [W3C](https://www.w3.org/) | 50 | **36** | **36** | 38 | 38 | 38 | 40 | 39 |
-| **Average processing time** |  | 352 ms (21/21) | 401 ms (21/21) | 175 ms (20/21) | 56 ms (21/21) | **17 ms (21/21)** | 395 ms (21/21) | 1481 ms (16/21) |
-
-(Last updated: Dec 10, 2025)
+| [Leanpub](https://leanpub.com/) | 2036 | **1755** | **1755** | 1762 | 1761 | 1759 | 2031 | n/a |
+| [Mastodon](https://mastodon.social/explore) | 36 | **27** | **27** | 31 | 34 | 34 | 35 | 35 |
+| [MDN](https://developer.mozilla.org/en-US/) | 107 | **61** | **61** | 63 | 63 | 64 | 66 | 67 |
+| [Middle East Eye](https://www.middleeasteye.net/) | 223 | **195** | 196 | 203 | 201 | 200 | 202 | 203 |
+| [Nielsen Norman Group](https://www.nngroup.com/) | 84 | 72 | 72 | **53** | 72 | 73 | 74 | 73 |
+| [SitePoint](https://www.sitepoint.com/) | 487 | **346** | **346** | 424 | 461 | 466 | 484 | n/a |
+| [TetraLogical](https://tetralogical.com/) | 44 | 38 | 38 | **35** | 38 | 38 | 39 | 39 |
+| [TPGi](https://www.tpgi.com/) | 175 | **160** | 162 | **160** | 165 | 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** |  | 338 ms (22/22) | 385 ms (22/22) | 191 ms (22/22) | 70 ms (22/22) | **18 ms (22/22)** | 365 ms (22/22) | 1403 ms (16/22) |
+
+(Last updated: Dec 12, 2025)
 <!-- End auto-generated -->
 
 ## Examples
@@ -283,6 +287,19 @@ html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist
 # Consider restricting with `--file-ext` to avoid touching binaries (e.g., images, archives)
 ```
 
+**Exclude directories from processing:**
+
+```bash
+# Ignore a single directory
+html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist --ignore-dir=libs
+
+# Ignore multiple directories
+html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist --ignore-dir=libs,vendor,node_modules
+
+# Ignore by relative path (only ignores src/static/libs, not other “libs” directories)
+html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist --ignore-dir=static/libs
+```
+
 **Dry run mode (preview outcome without writing files):**
 
 ```bash
@@ -414,4 +431,4 @@ npm run benchmarks
 
 ## Acknowledgements
 
-With many thanks to all the previous authors of HTML Minifier, especially [Juriy Zaytsev](https://github.com/kangax), and to everyone who helped make this new edition better, particularly [Daniel Ruf](https://github.com/DanielRuf) and [Jonas Geiler](https://github.com/jonasgeiler).
+With many thanks to all the previous authors of HTML Minifier, especially [Juriy “kangax” Zaytsev](https://github.com/kangax), and to everyone who helped make this new edition better, particularly [Daniel Ruf](https://github.com/DanielRuf) and [Jonas Geiler](https://github.com/jonasgeiler).

package/cli.js

@@ -247,6 +247,14 @@ function normalizeConfig(config) {
     }
   }
 
+  // Handle `ignoreDir` in config file
+  if ('ignoreDir' in normalized) {
+    // Support both string (`libs,vendor`) and array (`["libs", "vendor"]`) formats
+    if (Array.isArray(normalized.ignoreDir)) {
+      normalized.ignoreDir = normalized.ignoreDir.join(',');
+    }
+  }
+
   return normalized;
 }
 
@@ -254,8 +262,9 @@ let config = {};
 program.option('-c --config-file <file>', 'Use config file');
 program.option('--preset <name>', `Use a preset configuration (${getPresetNames().join(', ')})`);
 program.option('--input-dir <dir>', 'Specify an input directory');
+program.option('--ignore-dir <patterns>', 'Exclude directories—relative to input directory—from processing (comma-separated), e.g., “libs” or “libs,vendor,node_modules”');
 program.option('--output-dir <dir>', 'Specify an output directory');
-program.option('--file-ext <extensions>', 'Specify file extension(s) to process (comma-separated), e.g., "html" or "html,htm,php"');
+program.option('--file-ext <extensions>', 'Specify file extension(s) to process (comma-separated), e.g., “html” or “html,htm,php”');
 
 (async () => {
   let content;
@@ -375,7 +384,42 @@ program.option('--file-ext <extensions>', 'Specify file extension(s) to process
     return fileExtensions.includes(fileExt);
   }
 
-  async function countFiles(dir, extensions, skipRootAbs) {
+  /**
+   * Parse comma-separated ignore patterns into an array
+   * @param {string} patterns - Comma-separated directory patterns (e.g., "libs,vendor")
+   * @returns {string[]} Array of trimmed pattern strings with normalized separators
+   */
+  function parseIgnorePatterns(patterns) {
+    if (!patterns) return [];
+    return patterns
+      .split(',')
+      .map(p => p.trim().replace(/\\/g, '/').replace(/\/+$/, ''))
+      .filter(p => p.length > 0);
+  }
+
+  /**
+   * Check if a directory should be ignored based on ignore patterns
+   * Supports matching by directory name or relative path
+   * @param {string} dirPath - Absolute path to the directory
+   * @param {string[]} ignorePatterns - Array of patterns to match against (with forward slashes)
+   * @param {string} baseDir - Base directory for relative path calculation
+   * @returns {boolean} True if directory should be ignored
+   */
+  function shouldIgnoreDirectory(dirPath, ignorePatterns, baseDir) {
+    if (!ignorePatterns || ignorePatterns.length === 0) return false;
+
+    // Normalize to forward slashes for cross-platform comparison
+    const relativePath = path.relative(baseDir, dirPath).replace(/\\/g, '/');
+    const dirName = path.basename(dirPath);
+
+    return ignorePatterns.some(pattern => {
+      // Support both exact directory names and relative paths
+      return dirName === pattern || relativePath === pattern ||
+             relativePath.startsWith(pattern + '/');
+    });
+  }
+
+  async function countFiles(dir, extensions, skipRootAbs, ignorePatterns, baseDir) {
     let count = 0;
 
     const files = await fs.promises.readdir(dir).catch(() => []);
@@ -397,7 +441,11 @@ program.option('--file-ext <extensions>', 'Specify file extension(s) to process
       }
 
       if (lst.isDirectory()) {
-        count += await countFiles(filePath, extensions, skipRootAbs);
+        // Skip ignored directories
+        if (shouldIgnoreDirectory(filePath, ignorePatterns, baseDir)) {
+          continue;
+        }
+        count += await countFiles(filePath, extensions, skipRootAbs, ignorePatterns, baseDir);
       } else if (shouldProcessFile(file, extensions)) {
         count++;
       }
@@ -423,12 +471,17 @@ program.option('--file-ext <extensions>', 'Specify file extension(s) to process
     process.stderr.write('\r\x1b[K'); // Clear the line
   }
 
-  async function processDirectory(inputDir, outputDir, extensions, isDryRun = false, isVerbose = false, skipRootAbs, progress = null) {
+  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') {
       extensions = parseFileExtensions(extensions);
     }
 
+    // Set `baseDir` on first call
+    if (baseDir === null) {
+      baseDir = inputDir;
+    }
+
     const files = await fs.promises.readdir(inputDir).catch(err => {
       fatal('Cannot read directory ' + inputDir + '\n' + err.message);
     });
@@ -456,7 +509,11 @@ program.option('--file-ext <extensions>', 'Specify file extension(s) to process
       }
 
       if (lst.isDirectory()) {
-        const dirStats = await processDirectory(inputFile, outputFile, extensions, isDryRun, isVerbose, skipRootAbs, progress);
+        // 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);
         }
@@ -535,12 +592,16 @@ program.option('--file-ext <extensions>', 'Specify file extension(s) to process
     process.stdout.write(minified);
   };
 
-  const { inputDir, outputDir, fileExt } = programOptions;
+  const { inputDir, outputDir, fileExt, ignoreDir } = programOptions;
 
   // Resolve file extensions: CLI argument takes priority over config file, even if empty string
   const hasCliFileExt = program.getOptionValueSource('fileExt') === 'cli';
   const resolvedFileExt = hasCliFileExt ? fileExt : config.fileExt;
 
+  // Resolve ignore patterns: CLI argument takes priority over config file
+  const hasCliIgnoreDir = program.getOptionValueSource('ignoreDir') === 'cli';
+  const resolvedIgnoreDir = hasCliIgnoreDir ? ignoreDir : config.ignoreDir;
+
   if (inputDir || outputDir) {
     if (!inputDir) {
       fatal('The option `output-dir` needs to be used with the option `input-dir`—if you are working with a single file, use `-o`');
@@ -581,6 +642,12 @@ program.option('--file-ext <extensions>', 'Specify file extension(s) to process
       const showProgress = process.stderr.isTTY && !isVerbose;
       let progress = null;
 
+      // Parse ignore patterns
+      const ignorePatterns = parseIgnorePatterns(resolvedIgnoreDir);
+
+      // Resolve base directory for consistent path comparisons
+      const inputDirResolved = await fs.promises.realpath(inputDir).catch(() => inputDir);
+
       if (showProgress) {
         // Start with indeterminate progress, count in background
         progress = {current: 0, total: null};
@@ -591,7 +658,7 @@ program.option('--file-ext <extensions>', 'Specify file extension(s) to process
         // then see the updated value once `countFiles` resolves,
         // transitioning the indicator from indeterminate to determinate progress without race conditions.
         const extensions = typeof resolvedFileExt === 'string' ? parseFileExtensions(resolvedFileExt) : resolvedFileExt;
-        countFiles(inputDir, extensions, skipRootAbs).then(total => {
+        countFiles(inputDir, extensions, skipRootAbs, ignorePatterns, inputDirResolved).then(total => {
           if (progress) {
             progress.total = total;
           }
@@ -600,7 +667,7 @@ program.option('--file-ext <extensions>', 'Specify file extension(s) to process
         });
       }
 
-      const stats = await processDirectory(inputDir, outputDir, resolvedFileExt, programOptions.dry, isVerbose, skipRootAbs, progress);
+      const stats = await processDirectory(inputDir, outputDir, resolvedFileExt, programOptions.dry, isVerbose, skipRootAbs, progress, ignorePatterns, inputDirResolved);
 
       // Show completion message and clear progress indicator
       if (progress) {

package/dist/htmlminifier.cjs

@@ -2363,6 +2363,7 @@ async function minifyHTML(value, options, partialMarkup) {
   const ignoredMarkupChunks = [];
   const ignoredCustomMarkupChunks = [];
   let uidIgnore;
+  let uidIgnorePlaceholderPattern;
   let uidAttr;
   let uidPattern;
   // Create inline tags/text sets with custom elements
@@ -2396,6 +2397,7 @@ async function minifyHTML(value, options, partialMarkup) {
     if (!uidIgnore) {
       uidIgnore = uniqueId(value);
       const pattern = new RegExp('^' + uidIgnore + '([0-9]+)$');
+      uidIgnorePlaceholderPattern = new RegExp('^<!--' + uidIgnore + '(\\d+)-->$');
       if (options.ignoreCustomComments) {
         options.ignoreCustomComments = options.ignoreCustomComments.slice();
       } else {
@@ -2820,6 +2822,79 @@ async function minifyHTML(value, options, partialMarkup) {
         optionalStartTag = '';
         optionalEndTag = '';
       }
+
+      // Optimize whitespace collapsing between consecutive `htmlmin:ignore` placeholder comments
+      if (options.collapseWhitespace && text && uidIgnorePlaceholderPattern) {
+        if (uidIgnorePlaceholderPattern.test(text)) {
+          // Check if previous buffer items are: [ignore-placeholder, whitespace-only text]
+          if (buffer.length >= 2) {
+            const prevText = buffer[buffer.length - 1];
+            const prevComment = buffer[buffer.length - 2];
+
+            // Check if previous item is whitespace-only and item before that is ignore-placeholder
+            if (prevText && /^\s+$/.test(prevText) &&
+                prevComment && uidIgnorePlaceholderPattern.test(prevComment)) {
+              // Extract the index from both placeholders to check their content
+              const currentMatch = text.match(uidIgnorePlaceholderPattern);
+              const prevMatch = prevComment.match(uidIgnorePlaceholderPattern);
+
+              if (currentMatch && prevMatch) {
+                const currentIndex = +currentMatch[1];
+                const prevIndex = +prevMatch[1];
+
+                // Defensive bounds check to ensure indices are valid
+                if (currentIndex < ignoredMarkupChunks.length && prevIndex < ignoredMarkupChunks.length) {
+                  const currentContent = ignoredMarkupChunks[currentIndex];
+                  const prevContent = ignoredMarkupChunks[prevIndex];
+
+                  // Only collapse whitespace if both blocks contain HTML (start with `<`)
+                  // Don’t collapse if either contains plain text, as that would change meaning
+                  // Note: This check will match HTML comments (`<!-- … -->`), but the tag-name
+                  // regex below requires starting with a letter, so comments are intentionally
+                  // excluded by the `currentTagMatch && prevTagMatch` guard
+                  if (currentContent && prevContent && /^\s*</.test(currentContent) && /^\s*</.test(prevContent)) {
+                    // Extract tag names from the HTML content (excludes comments, processing instructions, etc.)
+                    const currentTagMatch = currentContent.match(/^\s*<([a-zA-Z][\w:-]*)/);
+                    const prevTagMatch = prevContent.match(/^\s*<([a-zA-Z][\w:-]*)/);
+
+                    // Only collapse if both matched valid element tags (not comments/text)
+                    // and both tags are block-level (inline elements need whitespace preserved)
+                    if (currentTagMatch && prevTagMatch) {
+                      const currentTag = options.name(currentTagMatch[1]);
+                      const prevTag = options.name(prevTagMatch[1]);
+
+                      // Don’t collapse between inline elements
+                      if (!inlineElements.has(currentTag) && !inlineElements.has(prevTag)) {
+                        // Collapse whitespace respecting context rules
+                        let collapsedText = prevText;
+
+                        // Apply `collapseWhitespace` with appropriate context
+                        if (!stackNoTrimWhitespace.length && !stackNoCollapseWhitespace.length) {
+                          // Not in pre or other no-collapse context
+                          if (options.preserveLineBreaks && /[\n\r]/.test(prevText)) {
+                            // Preserve line break as single newline
+                            collapsedText = '\n';
+                          } else if (options.conservativeCollapse) {
+                            // Conservative mode: keep single space
+                            collapsedText = ' ';
+                          } else {
+                            // Aggressive mode: remove all whitespace
+                            collapsedText = '';
+                          }
+                        }
+
+                        // Replace the whitespace in buffer
+                        buffer[buffer.length - 1] = collapsedText;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
       buffer.push(text);
     },
     doctype: function (doctype) {

package/dist/htmlminifier.esm.bundle.js

@@ -7505,6 +7505,7 @@ async function minifyHTML(value, options, partialMarkup) {
   const ignoredMarkupChunks = [];
   const ignoredCustomMarkupChunks = [];
   let uidIgnore;
+  let uidIgnorePlaceholderPattern;
   let uidAttr;
   let uidPattern;
   // Create inline tags/text sets with custom elements
@@ -7538,6 +7539,7 @@ async function minifyHTML(value, options, partialMarkup) {
     if (!uidIgnore) {
       uidIgnore = uniqueId(value);
       const pattern = new RegExp('^' + uidIgnore + '([0-9]+)$');
+      uidIgnorePlaceholderPattern = new RegExp('^<!--' + uidIgnore + '(\\d+)-->$');
       if (options.ignoreCustomComments) {
         options.ignoreCustomComments = options.ignoreCustomComments.slice();
       } else {
@@ -7962,6 +7964,79 @@ async function minifyHTML(value, options, partialMarkup) {
         optionalStartTag = '';
         optionalEndTag = '';
       }
+
+      // Optimize whitespace collapsing between consecutive `htmlmin:ignore` placeholder comments
+      if (options.collapseWhitespace && text && uidIgnorePlaceholderPattern) {
+        if (uidIgnorePlaceholderPattern.test(text)) {
+          // Check if previous buffer items are: [ignore-placeholder, whitespace-only text]
+          if (buffer.length >= 2) {
+            const prevText = buffer[buffer.length - 1];
+            const prevComment = buffer[buffer.length - 2];
+
+            // Check if previous item is whitespace-only and item before that is ignore-placeholder
+            if (prevText && /^\s+$/.test(prevText) &&
+                prevComment && uidIgnorePlaceholderPattern.test(prevComment)) {
+              // Extract the index from both placeholders to check their content
+              const currentMatch = text.match(uidIgnorePlaceholderPattern);
+              const prevMatch = prevComment.match(uidIgnorePlaceholderPattern);
+
+              if (currentMatch && prevMatch) {
+                const currentIndex = +currentMatch[1];
+                const prevIndex = +prevMatch[1];
+
+                // Defensive bounds check to ensure indices are valid
+                if (currentIndex < ignoredMarkupChunks.length && prevIndex < ignoredMarkupChunks.length) {
+                  const currentContent = ignoredMarkupChunks[currentIndex];
+                  const prevContent = ignoredMarkupChunks[prevIndex];
+
+                  // Only collapse whitespace if both blocks contain HTML (start with `<`)
+                  // Don’t collapse if either contains plain text, as that would change meaning
+                  // Note: This check will match HTML comments (`<!-- … -->`), but the tag-name
+                  // regex below requires starting with a letter, so comments are intentionally
+                  // excluded by the `currentTagMatch && prevTagMatch` guard
+                  if (currentContent && prevContent && /^\s*</.test(currentContent) && /^\s*</.test(prevContent)) {
+                    // Extract tag names from the HTML content (excludes comments, processing instructions, etc.)
+                    const currentTagMatch = currentContent.match(/^\s*<([a-zA-Z][\w:-]*)/);
+                    const prevTagMatch = prevContent.match(/^\s*<([a-zA-Z][\w:-]*)/);
+
+                    // Only collapse if both matched valid element tags (not comments/text)
+                    // and both tags are block-level (inline elements need whitespace preserved)
+                    if (currentTagMatch && prevTagMatch) {
+                      const currentTag = options.name(currentTagMatch[1]);
+                      const prevTag = options.name(prevTagMatch[1]);
+
+                      // Don’t collapse between inline elements
+                      if (!inlineElements.has(currentTag) && !inlineElements.has(prevTag)) {
+                        // Collapse whitespace respecting context rules
+                        let collapsedText = prevText;
+
+                        // Apply `collapseWhitespace` with appropriate context
+                        if (!stackNoTrimWhitespace.length && !stackNoCollapseWhitespace.length) {
+                          // Not in pre or other no-collapse context
+                          if (options.preserveLineBreaks && /[\n\r]/.test(prevText)) {
+                            // Preserve line break as single newline
+                            collapsedText = '\n';
+                          } else if (options.conservativeCollapse) {
+                            // Conservative mode: keep single space
+                            collapsedText = ' ';
+                          } else {
+                            // Aggressive mode: remove all whitespace
+                            collapsedText = '';
+                          }
+                        }
+
+                        // Replace the whitespace in buffer
+                        buffer[buffer.length - 1] = collapsedText;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
       buffer.push(text);
     },
     doctype: function (doctype) {

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

@@ -1 +1 @@
-{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"AAqqEO,8BAJI,MAAM,YACN,eAAe,GACb,OAAO,CAAC,MAAM,CAAC,CAQ3B;;;;;;;;;;;;UA5oES,MAAM;YACN,MAAM;YACN,MAAM;mBACN,MAAM;iBACN,MAAM;kBACN,MAAM;;;;;;;;;;;;;4BAQN,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE,qBAAqB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO;;;;;;;wBAMjG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,SAAS,EAAE,iBAAiB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO;;;;;;;;oBAMhH,OAAO;;;;;;;;gCAOP,OAAO;;;;;;;;kCAOP,OAAO;;;;;;;;yBAOP,OAAO;;;;;;;;2BAOP,OAAO;;;;;;;;4BAOP,OAAO;;;;;;;2BAOP,OAAO;;;;;;;;uBAMP,MAAM,EAAE;;;;;;yBAOR,MAAM;;;;;;yBAKN,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE;;;;;;;4BAKlB,MAAM,EAAE;;;;;;;oCAMR,MAAM;;;;;;;qBAMN,OAAO;;;;;;;YAMP,OAAO;;;;;;;;2BAMP,MAAM,EAAE;;;;;;;;;4BAOR,MAAM,EAAE;;;;;;;+BAQR,OAAO;;;;;;;2BAMP,SAAS,CAAC,MAAM,CAAC;;;;;;uBAMjB,OAAO;;;;;;;;UAKP,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI;;;;;;;;qBAO1B,MAAM;;;;;;;oBAON,MAAM;;;;;;;;;;gBAMN,OAAO,GAAG,OAAO,CAAC,OAAO,cAAc,EAAE,gBAAgB,CAAC,OAAO,cAAc,EAAE,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;;;eAS9J,OAAO,GAAG,OAAO,QAAQ,EAAE,aAAa,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;;;iBASzG,OAAO,GAAG,MAAM,GAAG,OAAO,WAAW,EAAE,OAAO,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;WAS7F,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM;;;;;;;+BAOxB,OAAO;;;;;;;;;;oBAMP,OAAO;;;;;;;;yBASP,OAAO;;;;;;;gCAOP,OAAO;;;;;;;;iCAMP,OAAO;;;;;;;;;;qBAOP,MAAM,EAAE;;;;;;;qBASR,IAAI,GAAG,GAAG;;;;;;;4BAMV,OAAO;;;;;;;;qBAMP,OAAO;;;;;;;;;4BAOP,OAAO,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;;;;;;;;0BAQtD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;gCAOP,MAAM,EAAE;;;;;;;;yBAyBR,OAAO;;;;;;;;gCAOP,OAAO;;;;;;;iCAOP,OAAO;;;;;;;oCAMP,OAAO;;;;;;;;;;0BAMP,OAAO;;;;;;;;;qBASP,OAAO,GAAG,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,IAAI,CAAC;;;;;;;;;oBAQzD,OAAO,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;;;;;;;;0BAQrC,OAAO;;;;;;;sBAOP,OAAO;;wBAnYkC,cAAc;0BAAd,cAAc;+BAAd,cAAc"}
+{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"AAgvEO,8BAJI,MAAM,YACN,eAAe,GACb,OAAO,CAAC,MAAM,CAAC,CAQ3B;;;;;;;;;;;;UAvtES,MAAM;YACN,MAAM;YACN,MAAM;mBACN,MAAM;iBACN,MAAM;kBACN,MAAM;;;;;;;;;;;;;4BAQN,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE,qBAAqB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO;;;;;;;wBAMjG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,SAAS,EAAE,iBAAiB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO;;;;;;;;oBAMhH,OAAO;;;;;;;;gCAOP,OAAO;;;;;;;;kCAOP,OAAO;;;;;;;;yBAOP,OAAO;;;;;;;;2BAOP,OAAO;;;;;;;;4BAOP,OAAO;;;;;;;2BAOP,OAAO;;;;;;;;uBAMP,MAAM,EAAE;;;;;;yBAOR,MAAM;;;;;;yBAKN,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE;;;;;;;4BAKlB,MAAM,EAAE;;;;;;;oCAMR,MAAM;;;;;;;qBAMN,OAAO;;;;;;;YAMP,OAAO;;;;;;;;2BAMP,MAAM,EAAE;;;;;;;;;4BAOR,MAAM,EAAE;;;;;;;+BAQR,OAAO;;;;;;;2BAMP,SAAS,CAAC,MAAM,CAAC;;;;;;uBAMjB,OAAO;;;;;;;;UAKP,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI;;;;;;;;qBAO1B,MAAM;;;;;;;oBAON,MAAM;;;;;;;;;;gBAMN,OAAO,GAAG,OAAO,CAAC,OAAO,cAAc,EAAE,gBAAgB,CAAC,OAAO,cAAc,EAAE,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;;;eAS9J,OAAO,GAAG,OAAO,QAAQ,EAAE,aAAa,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;;;iBASzG,OAAO,GAAG,MAAM,GAAG,OAAO,WAAW,EAAE,OAAO,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;WAS7F,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM;;;;;;;+BAOxB,OAAO;;;;;;;;;;oBAMP,OAAO;;;;;;;;yBASP,OAAO;;;;;;;gCAOP,OAAO;;;;;;;;iCAMP,OAAO;;;;;;;;;;qBAOP,MAAM,EAAE;;;;;;;qBASR,IAAI,GAAG,GAAG;;;;;;;4BAMV,OAAO;;;;;;;;qBAMP,OAAO;;;;;;;;;4BAOP,OAAO,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;;;;;;;;0BAQtD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;gCAOP,MAAM,EAAE;;;;;;;;yBAyBR,OAAO;;;;;;;;gCAOP,OAAO;;;;;;;iCAOP,OAAO;;;;;;;oCAMP,OAAO;;;;;;;;;;0BAMP,OAAO;;;;;;;;;qBASP,OAAO,GAAG,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,IAAI,CAAC;;;;;;;;;oBAQzD,OAAO,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;;;;;;;;0BAQrC,OAAO;;;;;;;sBAOP,OAAO;;wBAnYkC,cAAc;0BAAd,cAAc;+BAAd,cAAc"}

package/package.json

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

package/src/htmlminifier.js

@@ -1657,6 +1657,7 @@ async function minifyHTML(value, options, partialMarkup) {
   const ignoredMarkupChunks = [];
   const ignoredCustomMarkupChunks = [];
   let uidIgnore;
+  let uidIgnorePlaceholderPattern;
   let uidAttr;
   let uidPattern;
   // Create inline tags/text sets with custom elements
@@ -1690,6 +1691,7 @@ async function minifyHTML(value, options, partialMarkup) {
     if (!uidIgnore) {
       uidIgnore = uniqueId(value);
       const pattern = new RegExp('^' + uidIgnore + '([0-9]+)$');
+      uidIgnorePlaceholderPattern = new RegExp('^<!--' + uidIgnore + '(\\d+)-->$');
       if (options.ignoreCustomComments) {
         options.ignoreCustomComments = options.ignoreCustomComments.slice();
       } else {
@@ -2114,6 +2116,79 @@ async function minifyHTML(value, options, partialMarkup) {
         optionalStartTag = '';
         optionalEndTag = '';
       }
+
+      // Optimize whitespace collapsing between consecutive `htmlmin:ignore` placeholder comments
+      if (options.collapseWhitespace && text && uidIgnorePlaceholderPattern) {
+        if (uidIgnorePlaceholderPattern.test(text)) {
+          // Check if previous buffer items are: [ignore-placeholder, whitespace-only text]
+          if (buffer.length >= 2) {
+            const prevText = buffer[buffer.length - 1];
+            const prevComment = buffer[buffer.length - 2];
+
+            // Check if previous item is whitespace-only and item before that is ignore-placeholder
+            if (prevText && /^\s+$/.test(prevText) &&
+                prevComment && uidIgnorePlaceholderPattern.test(prevComment)) {
+              // Extract the index from both placeholders to check their content
+              const currentMatch = text.match(uidIgnorePlaceholderPattern);
+              const prevMatch = prevComment.match(uidIgnorePlaceholderPattern);
+
+              if (currentMatch && prevMatch) {
+                const currentIndex = +currentMatch[1];
+                const prevIndex = +prevMatch[1];
+
+                // Defensive bounds check to ensure indices are valid
+                if (currentIndex < ignoredMarkupChunks.length && prevIndex < ignoredMarkupChunks.length) {
+                  const currentContent = ignoredMarkupChunks[currentIndex];
+                  const prevContent = ignoredMarkupChunks[prevIndex];
+
+                  // Only collapse whitespace if both blocks contain HTML (start with `<`)
+                  // Don’t collapse if either contains plain text, as that would change meaning
+                  // Note: This check will match HTML comments (`<!-- … -->`), but the tag-name
+                  // regex below requires starting with a letter, so comments are intentionally
+                  // excluded by the `currentTagMatch && prevTagMatch` guard
+                  if (currentContent && prevContent && /^\s*</.test(currentContent) && /^\s*</.test(prevContent)) {
+                    // Extract tag names from the HTML content (excludes comments, processing instructions, etc.)
+                    const currentTagMatch = currentContent.match(/^\s*<([a-zA-Z][\w:-]*)/);
+                    const prevTagMatch = prevContent.match(/^\s*<([a-zA-Z][\w:-]*)/);
+
+                    // Only collapse if both matched valid element tags (not comments/text)
+                    // and both tags are block-level (inline elements need whitespace preserved)
+                    if (currentTagMatch && prevTagMatch) {
+                      const currentTag = options.name(currentTagMatch[1]);
+                      const prevTag = options.name(prevTagMatch[1]);
+
+                      // Don’t collapse between inline elements
+                      if (!inlineElements.has(currentTag) && !inlineElements.has(prevTag)) {
+                        // Collapse whitespace respecting context rules
+                        let collapsedText = prevText;
+
+                        // Apply `collapseWhitespace` with appropriate context
+                        if (!stackNoTrimWhitespace.length && !stackNoCollapseWhitespace.length) {
+                          // Not in pre or other no-collapse context
+                          if (options.preserveLineBreaks && /[\n\r]/.test(prevText)) {
+                            // Preserve line break as single newline
+                            collapsedText = '\n';
+                          } else if (options.conservativeCollapse) {
+                            // Conservative mode: keep single space
+                            collapsedText = ' ';
+                          } else {
+                            // Aggressive mode: remove all whitespace
+                            collapsedText = '';
+                          }
+                        }
+
+                        // Replace the whitespace in buffer
+                        buffer[buffer.length - 1] = collapsedText;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
       buffer.push(text);
     },
     doctype: function (doctype) {