html-minifier-next 6.2.6 → 6.2.8

package/README.md

@@ -4,17 +4,11 @@
 
 Your web page optimization precision tool: HTML Minifier Next (HMN) is a **super-configurable, well-tested, JavaScript-based HTML minifier** able to also handle in-document CSS, JavaScript, and SVG minification.
 
-The project was based on [HTML Minifier Terser (HMT)](https://github.com/terser/html-minifier-terser), which in turn had been based on [Juriy “kangax” Zaytsev’s HTML Minifier (HM)](https://github.com/kangax/html-minifier); as of 2025, both HTML Minifier Terser and HTML Minifier had been unmaintained for several years. HMN offers additional features and has been optimized for speed. While an independent project, it is still backwards-compatible with HMT and HM.
+The project was based on [HTML Minifier Terser (HMT)](https://github.com/terser/html-minifier-terser), which in turn had been based on [Juriy “kangax” Zaytsev’s HTML Minifier (HM)](https://github.com/kangax/html-minifier). It is now **the official successor to HTML Minifier**. HMN is maintained, easier to use, offers new features, and has been optimized for speed.
 
 ## Installation
 
-From npm for use as a command-line app:
-
-```shell
-npm i -g html-minifier-next
-```
-
-Directly with npx:
+For use as a command-line app, use npx:
 
 ```shell
 npx html-minifier-next --help
@@ -22,30 +16,30 @@ npx html-minifier-next --help
 
 (For immediate, zero-config use in the current folder: `npx html-minifier-next --zero`)
 
-From npm for programmatic use:
+For programmatic use, install as a development dependency:
 
 ```shell
-npm i html-minifier-next
+npm i -D html-minifier-next
 ```
 
 ## General usage
 
 ### CLI
 
-Use `html-minifier-next --help` to check all available options:
+Use `npx html-minifier-next --help` to check all available options:
 
 | Option | Description | Example |
 | --- | --- | --- |
-| `--zero`, `-z` | Minify all HTML files in the current folder and its subfolders in place (except node_modules), using comprehensive settings (standalone—flag is ignored when combined with other options) | `html-minifier-next --zero` |
+| `--zero`, `-z` | Minify all HTML files in the current folder and its subfolders in place (except node_modules), using comprehensive settings (standalone—flag is ignored when combined with other options) | `npx html-minifier-next --zero` |
 | `--input-dir <dir>`, `-I <dir>` | Specify an input directory | `--input-dir=src` |
 | `--ignore-dir <patterns>`, `-X <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>`, `-O <dir>` | Specify an output directory | `--output-dir=dist` |
-| `--output <file>`, `-o <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` |
+| `--output <file>`, `-o <file>` | Specify output file (reads from file arguments or STDIN) | File to file: `npx html-minifier-next input.html -o output.html`<br>Pipe to file: `cat input.html \| npx html-minifier-next -o output.html`<br>File to STDOUT: `npx html-minifier-next input.html` |
 | `--file-ext <extensions>`, `-f <extensions>` | Specify file extension(s) to process (comma-separated, overrides config file setting); defaults to `html,htm,shtml,shtm`; use `*` for all files | `--file-ext=html,php`, `--file-ext='*'` |
 | `--preset <name>`, `-p <name>` | Use a preset configuration (conservative or comprehensive) | `--preset=conservative` |
 | `--config-file <file>`, `-c <file>` | Use a configuration file | `--config-file=html-minifier.json` |
-| `--verbose`, `-v` | Show detailed processing information (active options, file statistics) | `html-minifier-next --input-dir=src --output-dir=dist --verbose --collapse-whitespace` |
-| `--dry`, `-d` | Dry run: Process and report statistics without writing output | `html-minifier-next input.html --dry --collapse-whitespace` |
+| `--verbose`, `-v` | Show detailed processing information (active options, file statistics) | `npx html-minifier-next --input-dir=src --output-dir=dist --verbose --collapse-whitespace` |
+| `--dry`, `-d` | Dry run: Process and report statistics without writing output | `npx html-minifier-next input.html --dry --collapse-whitespace` |
 
 ### Configuration file
 
@@ -113,14 +107,14 @@ To review the specific options set, [presets.js](https://github.com/j9t/html-min
 
 ```shell
 # Via CLI flag
-html-minifier-next --preset conservative input.html
+npx html-minifier-next --preset conservative input.html
 
 # Via config file
-html-minifier-next --config-file=html-minifier.json input.html
+npx html-minifier-next --config-file=html-minifier.json input.html
 # where html-minifier.json contains: { "preset": "conservative" }
 
 # Override preset options
-html-minifier-next --preset conservative --remove-empty-attributes input.html
+npx html-minifier-next --preset conservative --remove-empty-attributes input.html
 ```
 
 **Priority order:** Presets are applied first, then config file options, then CLI flags. This allows you to start with a preset and customize as needed.
@@ -246,14 +240,12 @@ const result = await minify(html, {
 * `terser` (default): The standard JavaScript minifier with excellent compression
 * [`swc`](https://swc.rs/): Rust-based minifier that’s significantly faster than Terser (requires separate installation)
 
-**To use SWC**, install it as a dependency:
+**To use SWC**, install it as a development dependency:
 
 ```shell
-npm i @swc/core
+npm i -D @swc/core
 ```
 
-(Build-only users may want to install it as a dev dependency: `npm i -D @swc/core`.)
-
 **Important:** Inline event handlers (e.g., `onclick="return false"`) always use Terser regardless of the `engine` setting, as SWC doesn’t support bare return statements. This is handled automatically—you don’t need to do anything special.
 
 You can pass engine-specific configuration options:
@@ -340,7 +332,7 @@ const result = await minify(html, {
 **Via CLI flags:**
 
 ```shell
-html-minifier-next --minify-css --cache-css 750 --minify-js --cache-js 250 --minify-svg --cache-svg 100 input.html
+npx html-minifier-next --minify-css --cache-css 750 --minify-js --cache-js 250 --minify-svg --cache-svg 100 input.html
 ```
 
 **Via environment variables:**
@@ -349,7 +341,7 @@ html-minifier-next --minify-css --cache-css 750 --minify-js --cache-js 250 --min
 export HMN_CACHE_CSS=750
 export HMN_CACHE_JS=250
 export HMN_CACHE_SVG=100
-html-minifier-next --minify-css --minify-js --minify-svg input.html
+npx html-minifier-next --minify-css --minify-js --minify-svg input.html
 ```
 
 **Configuration file:**
@@ -390,12 +382,8 @@ Please see [**the Minifier Benchmarks project**](https://github.com/j9t/minifier
 **Sample command line:**
 
 ```shell
-html-minifier-next --collapse-whitespace --remove-comments --minify-js --input-dir=. --output-dir=example
-```
+npx html-minifier-next --collapse-whitespace --remove-comments --minify-js --input-dir=. --output-dir=example
 
-Example using npx:
-
-```shell
 npx html-minifier-next --input-dir=test --preset comprehensive --output-dir example
 ```
 
@@ -403,39 +391,39 @@ npx html-minifier-next --input-dir=test --preset comprehensive --output-dir exam
 
 ```shell
 # Process default extensions (html, htm, shtml, shtm)
-html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist
+npx html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist
 
 # Process only specific extensions
-html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist --file-ext=html,php
+npx html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist --file-ext=html,php
 
 # Using configuration file that sets `fileExt` (e.g., `"fileExt": "html,php"`)
-html-minifier-next --config-file=html-minifier.json --input-dir=src --output-dir=dist
+npx html-minifier-next --config-file=html-minifier.json --input-dir=src --output-dir=dist
 
 # Process all files (explicit wildcard)
-html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist --file-ext='*'
+npx html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist --file-ext='*'
 ```
 
 **Exclude directories from processing:**
 
 ```shell
 # Ignore a single directory
-html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist --ignore-dir=libs
+npx 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
+npx 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
+npx html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist --ignore-dir=static/libs
 ```
 
 **Dry run mode (preview outcome without writing files):**
 
 ```shell
 # Preview with output file
-html-minifier-next input.html -o output.html --dry --collapse-whitespace
+npx html-minifier-next input.html -o output.html --dry --collapse-whitespace
 
 # Preview directory processing with statistics per file and total
-html-minifier-next --input-dir=src --output-dir=dist --dry --collapse-whitespace
+npx html-minifier-next --input-dir=src --output-dir=dist --dry --collapse-whitespace
 # Output: [DRY RUN] Would process directory: src → dist
 #   index.html: 1,234 → 892 bytes (-342, 27.7%)
 #   about.html: 2,100 → 1,654 bytes (-446, 21.2%)
@@ -447,7 +435,7 @@ html-minifier-next --input-dir=src --output-dir=dist --dry --collapse-whitespace
 
 ```shell
 # Show processing details while minifying
-html-minifier-next --input-dir=src --output-dir=dist --verbose --collapse-whitespace
+npx html-minifier-next --input-dir=src --output-dir=dist --verbose --collapse-whitespace
 # Output: CLI options: collapseWhitespace
 #   ✓ src/index.html: 1,234 → 892 bytes (-342, 27.7%)
 #   ✓ src/about.html: 2,100 → 1,654 bytes (-446, 21.2%)
@@ -455,7 +443,7 @@ html-minifier-next --input-dir=src --output-dir=dist --verbose --collapse-whites
 # Total: 3,334 → 2,546 bytes (-788, 23.6%)
 
 # `--dry` automatically enables verbose output
-html-minifier-next --input-dir=src --output-dir=dist --dry --collapse-whitespace
+npx html-minifier-next --input-dir=src --output-dir=dist --dry --collapse-whitespace
 ```
 
 ## Special cases
@@ -560,13 +548,13 @@ ignoreCustomFragments: [/\{%[\s\S]{0,1000}?%\}/, /\{\{[\s\S]{0,500}?\}\}/]
 **CLI (via config file—recommended):**
 
 ```shell
-html-minifier-next --config-file=config.json input.html
+npx html-minifier-next --config-file=config.json input.html
 ```
 
 **CLI (inline—not recommended due to complex escaping):**
 
 ```shell
-html-minifier-next --ignore-custom-fragments '[\\\"\\\\{%[\\\\s\\\\S]{0,1000}?%\\\\}\\\"]' input.html
+npx html-minifier-next --ignore-custom-fragments '[\\\"\\\\{%[\\\\s\\\\S]{0,1000}?%\\\\}\\\"]' input.html
 ```
 
 For CLI usage, using a config file is strongly recommended to avoid complex shell and JSON escaping.
@@ -577,7 +565,7 @@ For CLI usage, using a config file is strongly recommended to avoid complex shel
 \{%[\s\S]{0,1000}?%\} \{\{[\s\S]{0,500}?\}\}
 ```
 
-## Running HTML Minifier Next locally
+## Working on HTML Minifier Next
 
 ### Local server
 
@@ -609,6 +597,6 @@ With many thanks to the previous authors of and contributors to HTML Minifier, e
 
 You might like some of my other work:
 
-* Optimization tools: HTML Minifier Next · [ObsoHTML](https://github.com/j9t/obsohtml) · [Image Guard](https://github.com/j9t/image-guard) · [Compressor.js Next](https://github.com/j9t/compressorjs-next) · [.htaccess Punk](https://github.com/j9t/htaccess-punk)
+* Optimization tools: [hihtml](https://github.com/j9t/hihtml) · HTML Minifier Next · [ObsoHTML](https://github.com/j9t/obsohtml) · [Image Guard](https://github.com/j9t/image-guard) · [Compressor.js Next](https://github.com/j9t/compressorjs-next) · [.htaccess Punk](https://github.com/j9t/htaccess-punk)
 * Defense tools: [IA Defensa](https://iadefensa.com/solutions/)
 * Resources for quality web development: [Articles](https://meiert.com/topics/development/) · [Books](https://meiert.com/topics/books/) (including [_On Web Development_](https://meiert.com/blog/on-web-development-2/)) · [News](https://frontenddogma.com/) · [Terminology](https://webglossary.info/)

package/cli.js

@@ -3,7 +3,7 @@
 /**
  * html-minifier-next CLI tool
  *
- * The MIT License (MIT)
+ * MIT License
  *
  *  Copyright 2014–2016 Zoltan Frombach
  *  Copyright Juriy “kangax” Zaytsev

package/dist/htmlminifier.cjs

@@ -3891,6 +3891,7 @@ async function minifyHTML(value, options, partialMarkup) {
   let uidIgnorePlaceholderPattern;
   let uidAttr;
   let uidPattern;
+  let uidAttrLeadingPattern;
   // Create inline tags/text sets with custom elements
   const customElementsInput = options.inlineCustomElements ?? [];
   const customElementsArr = Array.isArray(customElementsInput) ? customElementsInput : Array.from(customElementsInput);
@@ -3972,46 +3973,55 @@ async function minifyHTML(value, options, partialMarkup) {
     const maxQuantifier = options.customFragmentQuantifierLimit || 200;
     const whitespacePattern = `\\s{0,${maxQuantifier}}`;
 
-    // Use bounded quantifiers to prevent ReDoS—this approach prevents exponential backtracking
-    const reCustomIgnore = new RegExp(
-      whitespacePattern + '(?:' + customFragments.join('|') + '){1,' + maxQuantifier + '}' + whitespacePattern,
-      'g'
-    );
-    // Temporarily replace custom ignored fragments with unique attributes
-    value = value.replace(reCustomIgnore, function (match) {
-      if (!uidAttr) {
-        uidAttr = uniqueId(value);
-        uidPattern = new RegExp('(\\s*)' + uidAttr + '([0-9]+)' + uidAttr + '(\\s*)', 'g');
-
-        if (options.minifyCSS) {
-          options.minifyCSS = (function (fn) {
-            return function (text, type) {
-              text = text.replace(uidPattern, function (match, prefix, index) {
-                const chunks = ignoredCustomMarkupChunks[+index];
-                return chunks[1] + uidAttr + index + uidAttr + chunks[2];
-              });
-
-              return fn(text, type);
-            };
-          })(options.minifyCSS);
-        }
+    // Fast path: The padded replace below is costly on large inputs because the
+    // `\s{0,N}` padding makes the regex engine consume and backtrack at every
+    // whitespace run; since the padding is optional and the fragment group requires
+    // at least one match, a single unpadded probe that finds nothing proves the
+    // replace would be a no-op—so skip it entirely
+    const reFragmentProbe = new RegExp('(?:' + customFragments.join('|') + ')');
+    if (reFragmentProbe.test(value)) {
+      // Use bounded quantifiers to prevent ReDoS—this approach prevents exponential backtracking
+      const reCustomIgnore = new RegExp(
+        whitespacePattern + '(?:' + customFragments.join('|') + '){1,' + maxQuantifier + '}' + whitespacePattern,
+        'g'
+      );
+      // Temporarily replace custom ignored fragments with unique attributes
+      value = value.replace(reCustomIgnore, function (match) {
+        if (!uidAttr) {
+          uidAttr = uniqueId(value);
+          uidPattern = new RegExp('(\\s*)' + uidAttr + '([0-9]+)' + uidAttr + '(\\s*)', 'g');
+          uidAttrLeadingPattern = new RegExp('^\\s*' + uidAttr + '(\\d+)' + uidAttr);
+
+          if (options.minifyCSS) {
+            options.minifyCSS = (function (fn) {
+              return function (text, type) {
+                text = text.replace(uidPattern, function (match, prefix, index) {
+                  const chunks = ignoredCustomMarkupChunks[+index];
+                  return chunks[1] + uidAttr + index + uidAttr + chunks[2];
+                });
+
+                return fn(text, type);
+              };
+            })(options.minifyCSS);
+          }
 
-        if (options.minifyJS) {
-          options.minifyJS = (function (fn) {
-            return function (text, inline, isModule) {
-              return fn(text.replace(uidPattern, function (match, prefix, index) {
-                const chunks = ignoredCustomMarkupChunks[+index];
-                return chunks[1] + uidAttr + index + uidAttr + chunks[2];
-              }), inline, isModule);
-            };
-          })(options.minifyJS);
+          if (options.minifyJS) {
+            options.minifyJS = (function (fn) {
+              return function (text, inline, isModule) {
+                return fn(text.replace(uidPattern, function (match, prefix, index) {
+                  const chunks = ignoredCustomMarkupChunks[+index];
+                  return chunks[1] + uidAttr + index + uidAttr + chunks[2];
+                }), inline, isModule);
+              };
+            })(options.minifyJS);
+          }
         }
-      }
 
-      const token = uidAttr + ignoredCustomMarkupChunks.length + uidAttr;
-      ignoredCustomMarkupChunks.push(/^(\s*)[\s\S]*?(\s*)$/.exec(match));
-      return '\t' + token + '\t';
-    });
+        const token = uidAttr + ignoredCustomMarkupChunks.length + uidAttr;
+        ignoredCustomMarkupChunks.push(/^(\s*)[\s\S]*?(\s*)$/.exec(match));
+        return '\t' + token + '\t';
+      });
+    }
   }
 
   function canCollapseWhitespace$1(tag, attrs) {
@@ -4417,15 +4427,28 @@ async function minifyHTML(value, options, partialMarkup) {
       // Finalization phase (sync): Optional tag handling, entity re-encoding, buffer push
       function charsFinalize(text) {
         if (options.removeOptionalTags && text) {
+          // UID-attr tokens are padded with `\t`, which would falsely look like leading whitespace;
+          // resolve single-token text to its actual content for the space/comment checks below
+          let effectiveText = text;
+          if (uidAttrLeadingPattern && text.includes(uidAttr)) {
+            const uidMatch = uidAttrLeadingPattern.exec(text);
+            if (uidMatch) {
+              const idx = +uidMatch[1];
+              const chunks = idx < ignoredCustomMarkupChunks.length ? ignoredCustomMarkupChunks[idx] : null;
+              if (chunks != null) {
+                effectiveText = chunks[0];
+              }
+            }
+          }
           // `<html>` may be omitted if first thing inside is not a comment
           // `<body>` may be omitted if first thing inside is not space, comment, `<meta>`, `<link>`, `<script>`, `<style>`, or `<template>`
-          if (optionalStartTag === 'html' || (optionalStartTag === 'body' && !/^\s/.test(text))) {
+          if (optionalStartTag === 'html' || (optionalStartTag === 'body' && !/^\s/.test(effectiveText))) {
             removeStartTag();
           }
           optionalStartTag = '';
           // `</html>` or `</body>` may be omitted if not followed by comment
           // `</head>`, `</colgroup>`, or `</caption>` may be omitted if not followed by space or comment
-          if (optionalEndTagEmitted && (compactElements.has(optionalEndTag) || (looseElements.has(optionalEndTag) && !/^\s/.test(text)))) {
+          if (optionalEndTagEmitted && (compactElements.has(optionalEndTag) || (looseElements.has(optionalEndTag) && !/^\s/.test(effectiveText)))) {
             removeEndTag();
           }
           // Don’t reset `optionalEndTag` if text is only whitespace and will be collapsed (not conservatively)
@@ -4491,7 +4514,25 @@ async function minifyHTML(value, options, partialMarkup) {
       // Finalization phase (sync): Optional tag handling, `htmlmin:ignore` whitespace collapsing, buffer push
       function commentFinalize(comment) {
         if (options.removeOptionalTags && comment) {
-          // Preceding comments suppress tag omissions
+          if (uidIgnorePlaceholderPattern) {
+            const match = uidIgnorePlaceholderPattern.exec(comment);
+            if (match) {
+              // UID placeholders represent real HTML content, not true HTML comments;
+              // if there’s a pending optional end tag and the ignored content isn’t itself
+              // a comment (which per the HTML spec prevents omission), resolve it now,
+              // before the UID is pushed to the buffer
+              const idx = +match[1];
+              const content = idx < ignoredMarkupChunks.length ? ignoredMarkupChunks[idx] : null;
+              if (optionalEndTag && optionalEndTagEmitted && content != null && !/^\s*<!--/.test(content)) {
+                const firstTagMatch = content.match(/^\s*<([a-zA-Z][^\s/>]*)/);
+                const firstTag = firstTagMatch ? options.name(firstTagMatch[1]) : '';
+                if (canRemovePrecedingTag(optionalEndTag, firstTag)) {
+                  removeEndTag();
+                }
+              }
+            }
+          }
+          // Comments (real or placeholder) always suppress optional start tag omissions
           optionalStartTag = '';
           optionalEndTag = '';
           optionalEndTagEmitted = false;

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

@@ -1 +1 @@
-{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"AA2wDO,8BAJI,MAAM,YACN,eAAe,GACb,OAAO,CAAC,MAAM,CAAC,CAwB3B;;;;;;;;;;;;UA3/CS,MAAM;;;;;;;;;;;;;;;;;;mCAaA,MAAM,SAAS,aAAa,EAAE,yBAAyB,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO;;;;;;;+BAM3F,MAAM,GAAG,IAAI,SAAS,aAAa,EAAE,GAAG,SAAS,qBAAqB,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6JtG,OAAO,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2HA2BiF,MAAM,SAAS,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM;;;;;;;;;;;;;;;;iBASxG,QAAQ,GAAG,KAAK;gBAAgC,MAAM,WAAW,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM;;;;;;;;;;;eAa/H,MAAM;gBAAY,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM;;;;;;;;;;;;;;;;;mBAiBzE,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDA+DF,MAAM,OAAO,MAAM,KAAK,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCA2EpC,MAAM,SAAS,aAAa,EAAE,KAAK,IAAI;;;;;;;;;wCAQrC,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;wBAtqBK,cAAc;0BAAd,cAAc;+BAAd,cAAc"}
+{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"AAozDO,8BAJI,MAAM,YACN,eAAe,GACb,OAAO,CAAC,MAAM,CAAC,CAwB3B;;;;;;;;;;;;UApiDS,MAAM;;;;;;;;;;;;;;;;;;mCAaA,MAAM,SAAS,aAAa,EAAE,yBAAyB,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO;;;;;;;+BAM3F,MAAM,GAAG,IAAI,SAAS,aAAa,EAAE,GAAG,SAAS,qBAAqB,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6JtG,OAAO,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2HA2BiF,MAAM,SAAS,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM;;;;;;;;;;;;;;;;iBASxG,QAAQ,GAAG,KAAK;gBAAgC,MAAM,WAAW,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM;;;;;;;;;;;eAa/H,MAAM;gBAAY,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM;;;;;;;;;;;;;;;;;mBAiBzE,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDA+DF,MAAM,OAAO,MAAM,KAAK,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCA2EpC,MAAM,SAAS,aAAa,EAAE,KAAK,IAAI;;;;;;;;;wCAQrC,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;wBAtqBK,cAAc;0BAAd,cAAc;+BAAd,cAAc"}

package/package.json

@@ -10,21 +10,21 @@
     "entities": "^8.0.0",
     "lightningcss": "^1.32.0",
     "svgo": "^4.0.1",
-    "terser": "^5.46.2"
+    "terser": "^5.47.1"
   },
   "description": "Super-configurable and well-tested web page minifier (enhanced successor of HTML Minifier)",
   "devDependencies": {
-    "@commitlint/cli": "^20.5.3",
+    "@commitlint/cli": "^21.0.1",
     "@eslint/js": "^10.0.1",
     "@rollup/plugin-commonjs": "^29.0.2",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
-    "@swc/core": "^1.15.33",
-    "eslint": "^10.3.0",
-    "rollup": "^4.60.2",
+    "@swc/core": "^1.15.40",
+    "eslint": "^10.4.0",
+    "rollup": "^4.60.4",
     "rollup-plugin-polyfill-node": "^0.13.0",
     "typescript": "^6.0.3",
-    "vite": "^8.0.10"
+    "vite": "^8.0.14"
   },
   "exports": {
     ".": {
@@ -97,5 +97,5 @@
   },
   "type": "module",
   "types": "./dist/types/htmlminifier.d.ts",
-  "version": "6.2.6"
+  "version": "6.2.8"
 }

package/src/htmlminifier.js

@@ -949,6 +949,7 @@ async function minifyHTML(value, options, partialMarkup) {
   let uidIgnorePlaceholderPattern;
   let uidAttr;
   let uidPattern;
+  let uidAttrLeadingPattern;
   // Create inline tags/text sets with custom elements
   const customElementsInput = options.inlineCustomElements ?? [];
   const customElementsArr = Array.isArray(customElementsInput) ? customElementsInput : Array.from(customElementsInput);
@@ -1030,46 +1031,55 @@ async function minifyHTML(value, options, partialMarkup) {
     const maxQuantifier = options.customFragmentQuantifierLimit || 200;
     const whitespacePattern = `\\s{0,${maxQuantifier}}`;
 
-    // Use bounded quantifiers to prevent ReDoS—this approach prevents exponential backtracking
-    const reCustomIgnore = new RegExp(
-      whitespacePattern + '(?:' + customFragments.join('|') + '){1,' + maxQuantifier + '}' + whitespacePattern,
-      'g'
-    );
-    // Temporarily replace custom ignored fragments with unique attributes
-    value = value.replace(reCustomIgnore, function (match) {
-      if (!uidAttr) {
-        uidAttr = uniqueId(value);
-        uidPattern = new RegExp('(\\s*)' + uidAttr + '([0-9]+)' + uidAttr + '(\\s*)', 'g');
-
-        if (options.minifyCSS) {
-          options.minifyCSS = (function (fn) {
-            return function (text, type) {
-              text = text.replace(uidPattern, function (match, prefix, index) {
-                const chunks = ignoredCustomMarkupChunks[+index];
-                return chunks[1] + uidAttr + index + uidAttr + chunks[2];
-              });
-
-              return fn(text, type);
-            };
-          })(options.minifyCSS);
-        }
+    // Fast path: The padded replace below is costly on large inputs because the
+    // `\s{0,N}` padding makes the regex engine consume and backtrack at every
+    // whitespace run; since the padding is optional and the fragment group requires
+    // at least one match, a single unpadded probe that finds nothing proves the
+    // replace would be a no-op—so skip it entirely
+    const reFragmentProbe = new RegExp('(?:' + customFragments.join('|') + ')');
+    if (reFragmentProbe.test(value)) {
+      // Use bounded quantifiers to prevent ReDoS—this approach prevents exponential backtracking
+      const reCustomIgnore = new RegExp(
+        whitespacePattern + '(?:' + customFragments.join('|') + '){1,' + maxQuantifier + '}' + whitespacePattern,
+        'g'
+      );
+      // Temporarily replace custom ignored fragments with unique attributes
+      value = value.replace(reCustomIgnore, function (match) {
+        if (!uidAttr) {
+          uidAttr = uniqueId(value);
+          uidPattern = new RegExp('(\\s*)' + uidAttr + '([0-9]+)' + uidAttr + '(\\s*)', 'g');
+          uidAttrLeadingPattern = new RegExp('^\\s*' + uidAttr + '(\\d+)' + uidAttr);
+
+          if (options.minifyCSS) {
+            options.minifyCSS = (function (fn) {
+              return function (text, type) {
+                text = text.replace(uidPattern, function (match, prefix, index) {
+                  const chunks = ignoredCustomMarkupChunks[+index];
+                  return chunks[1] + uidAttr + index + uidAttr + chunks[2];
+                });
+
+                return fn(text, type);
+              };
+            })(options.minifyCSS);
+          }
 
-        if (options.minifyJS) {
-          options.minifyJS = (function (fn) {
-            return function (text, inline, isModule) {
-              return fn(text.replace(uidPattern, function (match, prefix, index) {
-                const chunks = ignoredCustomMarkupChunks[+index];
-                return chunks[1] + uidAttr + index + uidAttr + chunks[2];
-              }), inline, isModule);
-            };
-          })(options.minifyJS);
+          if (options.minifyJS) {
+            options.minifyJS = (function (fn) {
+              return function (text, inline, isModule) {
+                return fn(text.replace(uidPattern, function (match, prefix, index) {
+                  const chunks = ignoredCustomMarkupChunks[+index];
+                  return chunks[1] + uidAttr + index + uidAttr + chunks[2];
+                }), inline, isModule);
+              };
+            })(options.minifyJS);
+          }
         }
-      }
 
-      const token = uidAttr + ignoredCustomMarkupChunks.length + uidAttr;
-      ignoredCustomMarkupChunks.push(/^(\s*)[\s\S]*?(\s*)$/.exec(match));
-      return '\t' + token + '\t';
-    });
+        const token = uidAttr + ignoredCustomMarkupChunks.length + uidAttr;
+        ignoredCustomMarkupChunks.push(/^(\s*)[\s\S]*?(\s*)$/.exec(match));
+        return '\t' + token + '\t';
+      });
+    }
   }
 
   function canCollapseWhitespace(tag, attrs) {
@@ -1475,15 +1485,28 @@ async function minifyHTML(value, options, partialMarkup) {
       // Finalization phase (sync): Optional tag handling, entity re-encoding, buffer push
       function charsFinalize(text) {
         if (options.removeOptionalTags && text) {
+          // UID-attr tokens are padded with `\t`, which would falsely look like leading whitespace;
+          // resolve single-token text to its actual content for the space/comment checks below
+          let effectiveText = text;
+          if (uidAttrLeadingPattern && text.includes(uidAttr)) {
+            const uidMatch = uidAttrLeadingPattern.exec(text);
+            if (uidMatch) {
+              const idx = +uidMatch[1];
+              const chunks = idx < ignoredCustomMarkupChunks.length ? ignoredCustomMarkupChunks[idx] : null;
+              if (chunks != null) {
+                effectiveText = chunks[0];
+              }
+            }
+          }
           // `<html>` may be omitted if first thing inside is not a comment
           // `<body>` may be omitted if first thing inside is not space, comment, `<meta>`, `<link>`, `<script>`, `<style>`, or `<template>`
-          if (optionalStartTag === 'html' || (optionalStartTag === 'body' && !/^\s/.test(text))) {
+          if (optionalStartTag === 'html' || (optionalStartTag === 'body' && !/^\s/.test(effectiveText))) {
             removeStartTag();
           }
           optionalStartTag = '';
           // `</html>` or `</body>` may be omitted if not followed by comment
           // `</head>`, `</colgroup>`, or `</caption>` may be omitted if not followed by space or comment
-          if (optionalEndTagEmitted && (compactElements.has(optionalEndTag) || (looseElements.has(optionalEndTag) && !/^\s/.test(text)))) {
+          if (optionalEndTagEmitted && (compactElements.has(optionalEndTag) || (looseElements.has(optionalEndTag) && !/^\s/.test(effectiveText)))) {
             removeEndTag();
           }
           // Don’t reset `optionalEndTag` if text is only whitespace and will be collapsed (not conservatively)
@@ -1549,7 +1572,25 @@ async function minifyHTML(value, options, partialMarkup) {
       // Finalization phase (sync): Optional tag handling, `htmlmin:ignore` whitespace collapsing, buffer push
       function commentFinalize(comment) {
         if (options.removeOptionalTags && comment) {
-          // Preceding comments suppress tag omissions
+          if (uidIgnorePlaceholderPattern) {
+            const match = uidIgnorePlaceholderPattern.exec(comment);
+            if (match) {
+              // UID placeholders represent real HTML content, not true HTML comments;
+              // if there’s a pending optional end tag and the ignored content isn’t itself
+              // a comment (which per the HTML spec prevents omission), resolve it now,
+              // before the UID is pushed to the buffer
+              const idx = +match[1];
+              const content = idx < ignoredMarkupChunks.length ? ignoredMarkupChunks[idx] : null;
+              if (optionalEndTag && optionalEndTagEmitted && content != null && !/^\s*<!--/.test(content)) {
+                const firstTagMatch = content.match(/^\s*<([a-zA-Z][^\s/>]*)/);
+                const firstTag = firstTagMatch ? options.name(firstTagMatch[1]) : '';
+                if (canRemovePrecedingTag(optionalEndTag, firstTag)) {
+                  removeEndTag();
+                }
+              }
+            }
+          }
+          // Comments (real or placeholder) always suppress optional start tag omissions
           optionalStartTag = '';
           optionalEndTag = '';
           optionalEndTagEmitted = false;