html-minifier-next 4.9.2 → 4.11.0

package/README.md

@@ -112,6 +112,8 @@ HTML Minifier Next provides presets for common use cases. Presets are pre-config
 * `conservative`: Safe minification suitable for most projects. Includes whitespace collapsing, comment removal, and doctype normalization.
 * `comprehensive`: Aggressive minification for maximum file size reduction. Includes relevant conservative options plus attribute quote removal, optional tag removal, and more.
 
+To review the specific options set, [presets.js](https://github.com/j9t/html-minifier-next/blob/main/src/presets.js) lists them in an accessible manner.
+
 **Using presets:**
 
 ```bash
@@ -137,10 +139,11 @@ Options can be used in config files (camelCase) or via CLI flags (kebab-case wit
 | Option (config/CLI) | Description | Default |
 | --- | --- | --- |
 | `caseSensitive`<br>`--case-sensitive` | Treat attributes in case-sensitive manner (useful for custom HTML elements) | `false` |
+| `collapseAttributeWhitespace`<br>`--collapse-attribute-whitespace` | Trim and collapse whitespace characters within attribute values | `false` |
 | `collapseBooleanAttributes`<br>`--collapse-boolean-attributes` | [Omit attribute values from boolean attributes](https://perfectionkills.com/experimenting-with-html-minifier#collapse_boolean_attributes) | `false` |
 | `collapseInlineTagWhitespace`<br>`--collapse-inline-tag-whitespace` | Don’t leave any spaces between `display: inline;` elements when collapsing—use with `collapseWhitespace: true` | `false` |
 | `collapseWhitespace`<br>`--collapse-whitespace` | [Collapse whitespace that contributes to text nodes in a document tree](https://perfectionkills.com/experimenting-with-html-minifier#collapse_whitespace) | `false` |
-| `conservativeCollapse`<br>`--conservative-collapse` | Always collapse to 1 space (never remove it entirely)—use with `collapseWhitespace: true` | `false` |
+| `conservativeCollapse`<br>`--conservative-collapse` | Always collapse to one space (never remove it entirely)—use with `collapseWhitespace: true` | `false` |
 | `continueOnMinifyError`<br>`--no-continue-on-minify-error` | Continue on minification errors; when `false`, minification errors throw and abort processing | `true` |
 | `continueOnParseError`<br>`--continue-on-parse-error` | [Handle parse errors](https://html.spec.whatwg.org/multipage/parsing.html#parse-errors) instead of aborting | `false` |
 | `customAttrAssign`<br>`--custom-attr-assign` | Arrays of regexes that allow to support custom attribute assign expressions (e.g., `<div flex?="{{mode != cover}}"></div>`) | `[]` |
@@ -233,32 +236,34 @@ How does HTML Minifier Next compare to other minifiers? (All with the most aggre
 | Site | Original Size (KB) | [HTML Minifier Next](https://github.com/j9t/html-minifier-next)<br>[![npm last update](https://img.shields.io/npm/last-update/html-minifier-next)](https://socket.dev/npm/package/html-minifier-next) | [HTML Minifier Terser](https://github.com/terser/html-minifier-terser)<br>[![npm last update](https://img.shields.io/npm/last-update/html-minifier-terser)](https://socket.dev/npm/package/html-minifier-terser) | [htmlnano](https://github.com/posthtml/htmlnano)<br>[![npm last update](https://img.shields.io/npm/last-update/htmlnano)](https://socket.dev/npm/package/htmlnano) | [@swc/html](https://github.com/swc-project/swc)<br>[![npm last update](https://img.shields.io/npm/last-update/@swc/html)](https://socket.dev/npm/package/@swc/html) | [minify-html](https://github.com/wilsonzlin/minify-html)<br>[![npm last update](https://img.shields.io/npm/last-update/@minify-html/node)](https://socket.dev/npm/package/@minify-html/node) | [minimize](https://github.com/Swaagie/minimize)<br>[![npm last update](https://img.shields.io/npm/last-update/minimize)](https://socket.dev/npm/package/minimize) | [html­com­pressor.­com](https://htmlcompressor.com/) |
 | --- | --- | --- | --- | --- | --- | --- | --- | --- |
 | [A List Apart](https://alistapart.com/) | 59 | **49** | 50 | 51 | 52 | 51 | 54 | 52 |
-| [Apple](https://www.apple.com/) | 260 | **203** | **203** | 231 | 235 | 236 | 237 | 238 |
-| [BBC](https://www.bbc.co.uk/) | 904 | **772** | 783 | 840 | 852 | 855 | 896 | n/a |
-| [CSS-Tricks](https://css-tricks.com/) | 160 | 120 | **119** | 126 | 141 | 141 | 146 | 143 |
+| [Apple](https://www.apple.com/) | 260 | **203** | 204 | 231 | 235 | 236 | 238 | 238 |
+| [BBC](https://www.bbc.co.uk/) | 720 | **655** | 665 | 677 | 677 | 678 | 714 | n/a |
+| [CERN](https://home.cern/) | 156 | **87** | **87** | 95 | 95 | 95 | 97 | 100 |
+| [CSS-Tricks](https://css-tricks.com/) | 163 | 122 | **120** | 128 | 143 | 144 | 149 | 145 |
 | [ECMAScript](https://tc39.es/ecma262/) | 7238 | **6341** | **6341** | 6561 | 6444 | 6567 | 6614 | n/a |
 | [EDRi](https://edri.org/) | 80 | **59** | 60 | 70 | 70 | 71 | 75 | 73 |
-| [EFF](https://www.eff.org/) | 56 | **47** | **47** | 50 | 49 | 49 | 51 | 50 |
+| [EFF](https://www.eff.org/) | 56 | **48** | **48** | 50 | 49 | 49 | 51 | 51 |
 | [European Alternatives](https://european-alternatives.eu/) | 48 | **30** | **30** | 32 | 32 | 32 | 32 | 32 |
-| [FAZ](https://www.faz.net/aktuell/) | 1559 | 1452 | 1457 | **1397** | 1484 | 1495 | 1506 | n/a |
-| [Frontend Dogma](https://frontenddogma.com/) | 221 | **211** | 213 | 234 | 219 | 221 | 239 | 220 |
+| [FAZ](https://www.faz.net/aktuell/) | 1562 | 1455 | 1460 | **1400** | 1487 | 1498 | 1509 | n/a |
+| [French Tech](https://lafrenchtech.gouv.fr/) | 152 | **121** | 122 | 125 | 125 | 125 | 132 | 126 |
+| [Frontend Dogma](https://frontenddogma.com/) | 222 | **213** | 215 | 236 | 221 | 222 | 241 | 222 |
 | [Google](https://www.google.com/) | 18 | **17** | **17** | **17** | **17** | **17** | 18 | 18 |
-| [Ground News](https://ground.news/) | 1967 | **1707** | 1710 | 1810 | 1835 | 1840 | 1954 | n/a |
+| [Ground News](https://ground.news/) | 2339 | **2052** | 2056 | 2151 | 2179 | 2182 | 2326 | 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** | 36 | 35 | 36 | 36 | 36 |
-| [Leanpub](https://leanpub.com/) | 1268 | **1071** | **1071** | 1078 | 1076 | 1072 | 1263 | n/a |
-| [Mastodon](https://mastodon.social/explore) | 36 | **27** | **27** | 31 | 34 | 34 | 35 | 35 |
+| [Igalia](https://www.igalia.com/) | 50 | **33** | **33** | 36 | 36 | 36 | 37 | 36 |
+| [Leanpub](https://leanpub.com/) | 1204 | **997** | **997** | 1004 | 1003 | 1001 | 1198 | n/a |
+| [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 | **195** | **195** | 202 | 200 | 200 | 202 | 203 |
-| [Nielsen Norman Group](https://www.nngroup.com/) | 84 | 71 | 72 | **53** | 71 | 73 | 74 | 73 |
-| [SitePoint](https://www.sitepoint.com/) | 487 | **346** | **346** | 424 | 461 | 466 | 484 | n/a |
+| [Middle East Eye](https://www.middleeasteye.net/) | 222 | **195** | 196 | 202 | 200 | 200 | 202 | 203 |
+| [Nielsen Norman Group](https://www.nngroup.com/) | 84 | 71 | 71 | **53** | 71 | 73 | 74 | 73 |
+| [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/) | 176 | **160** | 162 | **160** | 165 | 166 | 173 | 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** |  | 313 ms (24/24) | 367 ms (24/24) | 184 ms (24/24) | 62 ms (24/24) | **18 ms (24/24)** | 336 ms (24/24) | 1392 ms (18/24) |
+| [TPGi](https://www.tpgi.com/) | 175 | **159** | 161 | 160 | 164 | 165 | 172 | 171 |
+| [United Nations](https://www.un.org/en/) | 151 | **112** | 114 | 121 | 125 | 124 | 130 | 123 |
+| [W3C](https://www.w3.org/) | 50 | **36** | **36** | 38 | 38 | 38 | 40 | 38 |
+| **Average processing time** |  | 302 ms (26/26) | 356 ms (26/26) | 178 ms (26/26) | 59 ms (26/26) | **16 ms (26/26)** | 329 ms (26/26) | 1468 ms (20/26) |
 
-(Last updated: Dec 14, 2025)
+(Last updated: Dec 16, 2025)
 <!-- End auto-generated -->
 
 ## Examples

package/cli.js

@@ -117,17 +117,18 @@ const parseValidInt = (optionName) => (value) => {
 
 const mainOptions = {
   caseSensitive: 'Treat attributes in case-sensitive manner (useful for custom HTML elements)',
+  collapseAttributeWhitespace: 'Trim and collapse whitespace characters within attribute values',
   collapseBooleanAttributes: 'Omit attribute values from boolean attributes',
-  customFragmentQuantifierLimit: ['Set maximum quantifier limit for custom fragments to prevent ReDoS attacks (default: 200)', parseValidInt('customFragmentQuantifierLimit')],
   collapseInlineTagWhitespace: 'Don’t leave any spaces between “display: inline;” elements when collapsing—use with “--collapse-whitespace”',
   collapseWhitespace: 'Collapse whitespace that contributes to text nodes in a document tree',
-  conservativeCollapse: 'Always collapse to 1 space (never remove it entirely)—use with “--collapse-whitespace”',
+  conservativeCollapse: 'Always collapse to one space (never remove it entirely)—use with “--collapse-whitespace”',
   continueOnMinifyError: 'Abort on minification errors',
   continueOnParseError: 'Handle parse errors instead of aborting',
   customAttrAssign: ['Arrays of regexes that allow to support custom attribute assign expressions (e.g., “<div flex?="{{mode != cover}}"></div>”)', parseJSONRegExpArray],
   customAttrCollapse: ['Regex that specifies custom attribute to strip newlines from (e.g., /ng-class/)', parseRegExp],
   customAttrSurround: ['Arrays of regexes that allow to support custom attribute surround expressions (e.g., “<input {{#if value}}checked="checked"{{/if}}>”)', parseJSONRegExpArray],
   customEventAttributes: ['Arrays of regexes that allow to support custom event attributes for minifyJS (e.g., “ng-click”)', parseJSONRegExpArray],
+  customFragmentQuantifierLimit: ['Set maximum quantifier limit for custom fragments to prevent ReDoS attacks (default: 200)', parseValidInt('customFragmentQuantifierLimit')],
   decodeEntities: 'Use direct Unicode characters whenever possible',
   html5: 'Don’t parse input according to the HTML specification (not recommended for modern HTML)',
   ignoreCustomComments: ['Array of regexes that allow to ignore certain comments, when matched', parseJSONRegExpArray],

package/dist/htmlminifier.cjs

@@ -89,6 +89,9 @@ const preCompiledStackedTags = {
   'noscript': /([\s\S]*?)<\/noscript[^>]*>/i
 };
 
+// Cache for compiled attribute regexes per handler configuration
+const attrRegexCache = new WeakMap();
+
 function attrForHandler(handler) {
   let pattern = singleAttrIdentifier.source +
     '(?:\\s*(' + joinSingleAttrAssigns(handler) + ')' +
@@ -126,22 +129,47 @@ class HTMLParser {
   }
 
   async parse() {
-    let html = this.html;
     const handler = this.handler;
+    const fullHtml = this.html;
+    const fullLength = fullHtml.length;
 
     const stack = []; let lastTag;
-    const attribute = attrForHandler(handler);
-    let last, prevTag = undefined, nextTag = undefined;
-
-    // Track position for better error messages
-    let position = 0;
-    const getLineColumn = (pos) => {
-      const lines = this.html.slice(0, pos).split('\n');
-      return { line: lines.length, column: lines[lines.length - 1].length + 1 };
+    // Use cached attribute regex if available
+    let attribute = attrRegexCache.get(handler);
+    if (!attribute) {
+      attribute = attrForHandler(handler);
+      attrRegexCache.set(handler, attribute);
+    }
+    let prevTag = undefined, nextTag = undefined;
+
+    // Index-based parsing
+    let pos = 0;
+    let lastPos;
+
+    // Helper to get remaining HTML from current position
+    const remaining = () => fullHtml.slice(pos);
+
+    // Helper to advance position
+    const advance = (n) => { pos += n; };
+
+    // Lazy line/column calculation—only compute on actual errors
+    const getLineColumn = (position) => {
+      let line = 1;
+      let column = 1;
+      for (let i = 0; i < position; i++) {
+        if (fullHtml[i] === '\n') {
+          line++;
+          column = 1;
+        } else {
+          column++;
+        }
+      }
+      return { line, column };
     };
 
-    while (html) {
-      last = html;
+    while (pos < fullLength) {
+      lastPos = pos;
+      const html = remaining();
       // Make sure we’re not in a `script` or `style` element
       if (!lastTag || !special.has(lastTag)) {
         let textEnd = html.indexOf('<');
@@ -154,7 +182,7 @@ class HTMLParser {
               if (handler.comment) {
                 await handler.comment(html.substring(4, commentEnd));
               }
-              html = html.substring(commentEnd + 3);
+              advance(commentEnd + 3);
               prevTag = '';
               continue;
             }
@@ -168,7 +196,7 @@ class HTMLParser {
               if (handler.comment) {
                 await handler.comment(html.substring(2, conditionalEnd + 1), true /* non-standard */);
               }
-              html = html.substring(conditionalEnd + 2);
+              advance(conditionalEnd + 2);
               prevTag = '';
               continue;
             }
@@ -180,7 +208,7 @@ class HTMLParser {
             if (handler.doctype) {
               handler.doctype(doctypeMatch[0]);
             }
-            html = html.substring(doctypeMatch[0].length);
+            advance(doctypeMatch[0].length);
             prevTag = '';
             continue;
           }
@@ -188,7 +216,7 @@ class HTMLParser {
           // End tag
           const endTagMatch = html.match(endTag);
           if (endTagMatch) {
-            html = html.substring(endTagMatch[0].length);
+            advance(endTagMatch[0].length);
             await parseEndTag(endTagMatch[0], endTagMatch[1]);
             prevTag = '/' + endTagMatch[1].toLowerCase();
             continue;
@@ -197,7 +225,7 @@ class HTMLParser {
           // Start tag
           const startTagMatch = parseStartTag(html);
           if (startTagMatch) {
-            html = startTagMatch.rest;
+            advance(startTagMatch.advance);
             await handleStartTag(startTagMatch);
             prevTag = startTagMatch.tagName.toLowerCase();
             continue;
@@ -212,18 +240,19 @@ class HTMLParser {
         let text;
         if (textEnd >= 0) {
           text = html.substring(0, textEnd);
-          html = html.substring(textEnd);
+          advance(textEnd);
         } else {
           text = html;
-          html = '';
+          advance(html.length);
         }
 
         // Next tag
-        let nextTagMatch = parseStartTag(html);
+        const nextHtml = remaining();
+        let nextTagMatch = parseStartTag(nextHtml);
         if (nextTagMatch) {
           nextTag = nextTagMatch.tagName;
         } else {
-          nextTagMatch = html.match(endTag);
+          nextTagMatch = nextHtml.match(endTag);
           if (nextTagMatch) {
             nextTag = '/' + nextTagMatch[1];
           } else {
@@ -252,41 +281,38 @@ class HTMLParser {
             await handler.chars(text);
           }
           // Advance HTML past the matched special tag content and its closing tag
-          html = html.slice(m.index + m[0].length);
+          advance(m.index + m[0].length);
           await parseEndTag('</' + stackedTag + '>', stackedTag);
         } else {
           // No closing tag found; to avoid infinite loop, break similarly to previous behavior
           if (handler.continueOnParseError && handler.chars && html) {
             await handler.chars(html[0], prevTag, '');
-            html = html.substring(1);
+            advance(1);
           } else {
             break;
           }
         }
       }
 
-      if (html === last) {
+      if (pos === lastPos) {
         if (handler.continueOnParseError) {
           // Skip the problematic character and continue
           if (handler.chars) {
-            await handler.chars(html[0], prevTag, '');
+            await handler.chars(fullHtml[pos], prevTag, '');
           }
-          html = html.substring(1);
-          position++;
+          advance(1);
           prevTag = '';
           continue;
         }
-        const loc = getLineColumn(position);
-        // Include some context before the error position so the snippet contains
-        // the offending markup plus preceding characters (e.g. "invalid<tag").
+        const loc = getLineColumn(pos);
+        // Include some context before the error position so the snippet contains the offending markup plus preceding characters (e.g., “invalid<tag”)
         const CONTEXT_BEFORE = 50;
-        const startPos = Math.max(0, position - CONTEXT_BEFORE);
-        const snippet = this.html.slice(startPos, startPos + 200).replace(/\n/g, ' ');
+        const startPos = Math.max(0, pos - CONTEXT_BEFORE);
+        const snippet = fullHtml.slice(startPos, startPos + 200).replace(/\n/g, ' ');
         throw new Error(
-          `Parse error at line ${loc.line}, column ${loc.column}:\n${snippet}${this.html.length > startPos + 200 ? '…' : ''}`
+          `Parse error at line ${loc.line}, column ${loc.column}:\n${snippet}${fullHtml.length > startPos + 200 ? '…' : ''}`
         );
       }
-      position = this.html.length - html.length;
     }
 
     if (!handler.partialMarkup) {
@@ -299,9 +325,11 @@ class HTMLParser {
       if (start) {
         const match = {
           tagName: start[1],
-          attrs: []
+          attrs: [],
+          advance: 0
         };
-        input = input.slice(start[0].length);
+        let consumed = start[0].length;
+        input = input.slice(consumed);
         let end, attr;
 
         // Safety limit: max length of input to check for attributes
@@ -351,7 +379,9 @@ class HTMLParser {
                     } else {
                       attr[baseIndex + 3] = value; // Single-quoted value
                     }
-                    input = input.slice(fullAttr.length);
+                    const attrLen = fullAttr.length;
+                    input = input.slice(attrLen);
+                    consumed += attrLen;
                     match.attrs.push(attr);
                     continue;
                   }
@@ -368,7 +398,9 @@ class HTMLParser {
             break;
           }
 
-          input = input.slice(attr[0].length);
+          const attrLen = attr[0].length;
+          input = input.slice(attrLen);
+          consumed += attrLen;
           match.attrs.push(attr);
         }
 
@@ -376,7 +408,8 @@ class HTMLParser {
         end = input.match(startTagClose);
         if (end) {
           match.unarySlash = end[1];
-          match.rest = input.slice(end[0].length);
+          consumed += end[0].length;
+          match.advance = consumed;
           return match;
         }
       }
@@ -386,7 +419,7 @@ class HTMLParser {
       let pos;
       const needle = tagName.toLowerCase();
       for (pos = stack.length - 1; pos >= 0; pos--) {
-        const currentTag = stack[pos].tag.toLowerCase();
+        const currentTag = stack[pos].lowerTag;
         if (currentTag === needle) {
           return pos;
         }
@@ -440,7 +473,7 @@ class HTMLParser {
         }
         if (tagName === 'col' && findTag('colgroup') < 0) {
           lastTag = 'colgroup';
-          stack.push({ tag: lastTag, attrs: [] });
+          stack.push({ tag: lastTag, lowerTag: 'colgroup', attrs: [] });
           if (handler.start) {
             await handler.start(lastTag, [], false, '');
           }
@@ -519,7 +552,7 @@ class HTMLParser {
       });
 
       if (!unary) {
-        stack.push({ tag: tagName, attrs });
+        stack.push({ tag: tagName, lowerTag: tagName.toLowerCase(), attrs });
         lastTag = tagName;
         unarySlash = '';
       }
@@ -533,7 +566,7 @@ class HTMLParser {
       let pos;
       const needle = tagName.toLowerCase();
       for (pos = stack.length - 1; pos >= 0; pos--) {
-        if (stack[pos].tag.toLowerCase() === needle) {
+        if (stack[pos].lowerTag === needle) {
           break;
         }
       }
@@ -585,21 +618,40 @@ class HTMLParser {
 class Sorter {
   sort(tokens, fromIndex = 0) {
     for (let i = 0, len = this.keys.length; i < len; i++) {
-      const key = this.keys[i];
-      const token = key.slice(1);
+      const token = this.keys[i];
+
+      // Build position map for this token to avoid repeated `indexOf`
+      const positions = [];
+      for (let j = fromIndex; j < tokens.length; j++) {
+        if (tokens[j] === token) {
+          positions.push(j);
+        }
+      }
 
-      let index = tokens.indexOf(token, fromIndex);
+      if (positions.length > 0) {
+        // Build new array with tokens in sorted order instead of splicing
+        const result = [];
 
-      if (index !== -1) {
-        do {
-          if (index !== fromIndex) {
-            tokens.splice(index, 1);
-            tokens.splice(fromIndex, 0, token);
+        // Add all instances of the current token first
+        for (let j = 0; j < positions.length; j++) {
+          result.push(token);
+        }
+
+        // Add other tokens, skipping positions where current token was
+        const posSet = new Set(positions);
+        for (let j = fromIndex; j < tokens.length; j++) {
+          if (!posSet.has(j)) {
+            result.push(tokens[j]);
           }
-          fromIndex++;
-        } while ((index = tokens.indexOf(token, fromIndex)) !== -1);
+        }
+
+        // Copy sorted portion back to tokens array
+        for (let j = 0; j < result.length; j++) {
+          tokens[fromIndex + j] = result[j];
+        }
 
-        return this[key].sort(tokens, fromIndex);
+        const newFromIndex = fromIndex + positions.length;
+        return this.sorterMap.get(token).sort(tokens, newFromIndex);
       }
     }
     return tokens;
@@ -607,44 +659,68 @@ class Sorter {
 }
 
 class TokenChain {
+  constructor() {
+    // Use Map instead of object properties for better performance
+    this.map = new Map();
+  }
+
   add(tokens) {
     tokens.forEach((token) => {
-      const key = '$' + token;
-      if (!this[key]) {
-        this[key] = [];
-        this[key].processed = 0;
+      if (!this.map.has(token)) {
+        this.map.set(token, { arrays: [], processed: 0 });
       }
-      this[key].push(tokens);
+      this.map.get(token).arrays.push(tokens);
     });
   }
 
   createSorter() {
     const sorter = new Sorter();
+    sorter.sorterMap = new Map();
+
+    // Convert Map entries to array and sort
+    const entries = Array.from(this.map.entries()).sort((a, b) => {
+      const m = a[1].arrays.length;
+      const n = b[1].arrays.length;
+      // Sort by length descending (larger first)
+      const lengthDiff = n - m;
+      if (lengthDiff !== 0) return lengthDiff;
+      // If lengths equal, sort by key ascending
+      return a[0].localeCompare(b[0]);
+    });
+
+    sorter.keys = [];
 
-    sorter.keys = Object.keys(this).sort((j, k) => {
-      const m = this[j].length;
-      const n = this[k].length;
-      return m < n ? 1 : m > n ? -1 : j < k ? -1 : j > k ? 1 : 0;
-    }).filter((key) => {
-      if (this[key].processed < this[key].length) {
-        const token = key.slice(1);
+    entries.forEach(([token, data]) => {
+      if (data.processed < data.arrays.length) {
         const chain = new TokenChain();
 
-        this[key].forEach((tokens) => {
-          let index;
-          while ((index = tokens.indexOf(token)) !== -1) {
-            tokens.splice(index, 1);
+        data.arrays.forEach((tokens) => {
+          // Build new array without the current token instead of splicing
+          const filtered = [];
+          for (let i = 0; i < tokens.length; i++) {
+            if (tokens[i] !== token) {
+              filtered.push(tokens[i]);
+            }
           }
-          tokens.forEach((token) => {
-            this['$' + token].processed++;
+
+          // Mark remaining tokens as processed
+          filtered.forEach((t) => {
+            const tData = this.map.get(t);
+            if (tData) {
+              tData.processed++;
+            }
           });
-          chain.add(tokens.slice(0));
+
+          if (filtered.length > 0) {
+            chain.add(filtered);
+          }
         });
-        sorter[key] = chain.createSorter();
-        return true;
+
+        sorter.keys.push(token);
+        sorter.sorterMap.set(token, chain.createSorter());
       }
-      return false;
     });
+
     return sorter;
   }
 }
@@ -685,6 +761,7 @@ const presets = {
     useShortDoctype: true
   },
   comprehensive: {
+    // @@ Add `collapseAttributeWhitespace: true` (also add to preset in demo)
     caseSensitive: true,
     collapseBooleanAttributes: true,
     collapseInlineTagWhitespace: true,
@@ -784,6 +861,14 @@ async function getTerser() {
  *
  *  Default: `false`
  *
+ *  @prop {boolean} [collapseAttributeWhitespace]
+ *  Collapse multiple whitespace characters within attribute values into a
+ *  single space. Also trims leading and trailing whitespace from attribute
+ *  values. Applied as an early normalization step before special attribute
+ *  handlers (CSS minification, class sorting, etc.) run.
+ *
+ *  Default: `false`
+ *
  * @prop {boolean} [collapseBooleanAttributes]
  *  Collapse boolean attributes to their name only (for example
  *  `disabled="disabled"` → `disabled`).
@@ -1469,6 +1554,12 @@ function isSrcset(attrName, tag) {
 }
 
 async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTMLSelf) {
+  // Apply early whitespace normalization if enabled
+  // Preserves special spaces (non-breaking space, hair space, etc.) for consistency with `collapseWhitespace`
+  if (options.collapseAttributeWhitespace) {
+    attrValue = attrValue.replace(/[ \n\r\t\f]+/g, ' ').replace(/^[ \n\r\t\f]+|[ \n\r\t\f]+$/g, '');
+  }
+
   if (isEventAttribute(attrName, options)) {
     attrValue = trimWhitespace(attrValue).replace(/^javascript:\s*/i, '');
     return options.minifyJS(attrValue, true);