html-minifier-next 4.10.0 → 4.11.1

package/README.md

@@ -139,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>`) | `[]` |
@@ -235,34 +236,34 @@ How does HTML Minifier Next compare to other minifiers? (All with the most aggre
 | Site | Original Size (KB) | [HTML Minifier Next](https://github.com/j9t/html-minifier-next)<br>[![npm last update](https://img.shields.io/npm/last-update/html-minifier-next)](https://socket.dev/npm/package/html-minifier-next) | [HTML Minifier Terser](https://github.com/terser/html-minifier-terser)<br>[![npm last update](https://img.shields.io/npm/last-update/html-minifier-terser)](https://socket.dev/npm/package/html-minifier-terser) | [htmlnano](https://github.com/posthtml/htmlnano)<br>[![npm last update](https://img.shields.io/npm/last-update/htmlnano)](https://socket.dev/npm/package/htmlnano) | [@swc/html](https://github.com/swc-project/swc)<br>[![npm last update](https://img.shields.io/npm/last-update/@swc/html)](https://socket.dev/npm/package/@swc/html) | [minify-html](https://github.com/wilsonzlin/minify-html)<br>[![npm last update](https://img.shields.io/npm/last-update/@minify-html/node)](https://socket.dev/npm/package/@minify-html/node) | [minimize](https://github.com/Swaagie/minimize)<br>[![npm last update](https://img.shields.io/npm/last-update/minimize)](https://socket.dev/npm/package/minimize) | [html­com­pressor.­com](https://htmlcompressor.com/) |
 | --- | --- | --- | --- | --- | --- | --- | --- | --- |
 | [A List Apart](https://alistapart.com/) | 59 | **49** | 50 | 51 | 52 | 51 | 54 | 52 |
-| [Apple](https://www.apple.com/) | 260 | **203** | 204 | 231 | 235 | 236 | 238 | 238 |
-| [BBC](https://www.bbc.co.uk/) | 720 | **655** | 665 | 677 | 677 | 678 | 714 | n/a |
-| [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 |
+| [Apple](https://www.apple.com/) | 266 | **206** | n/a | 236 | 239 | 240 | 242 | 243 |
+| [BBC](https://www.bbc.co.uk/) | 697 | **634** | n/a | 655 | 655 | 656 | 691 | n/a |
+| [CERN](https://home.cern/) | 156 | **87** | n/a | 95 | 95 | 95 | 97 | 100 |
+| [CSS-Tricks](https://css-tricks.com/) | 163 | **122** | n/a | 128 | 143 | 144 | 149 | 145 |
+| [ECMAScript](https://tc39.es/ecma262/) | 7238 | **6342** | **6342** | 6561 | 6444 | 6567 | 6614 | n/a |
 | [EDRi](https://edri.org/) | 80 | **59** | 60 | 70 | 70 | 71 | 75 | 73 |
-| [EFF](https://www.eff.org/) | 56 | **48** | **48** | 50 | 49 | 49 | 51 | 51 |
+| [EFF](https://www.eff.org/) | 55 | **47** | n/a | 50 | 48 | 49 | 50 | 50 |
 | [European Alternatives](https://european-alternatives.eu/) | 48 | **30** | **30** | 32 | 32 | 32 | 32 | 32 |
-| [FAZ](https://www.faz.net/aktuell/) | 1562 | 1455 | 1460 | **1400** | 1487 | 1498 | 1509 | n/a |
+| [FAZ](https://www.faz.net/aktuell/) | 1604 | 1494 | 1499 | **1437** | 1527 | 1539 | 1550 | n/a |
 | [French Tech](https://lafrenchtech.gouv.fr/) | 152 | **121** | 122 | 125 | 125 | 125 | 132 | 126 |
-| [Frontend Dogma](https://frontenddogma.com/) | 222 | **213** | 215 | 236 | 221 | 222 | 241 | 222 |
+| [Frontend Dogma](https://frontenddogma.com/) | 223 | **213** | 215 | 236 | 221 | 223 | 241 | 222 |
 | [Google](https://www.google.com/) | 18 | **17** | **17** | **17** | **17** | **17** | 18 | 18 |
-| [Ground News](https://ground.news/) | 2339 | **2052** | 2056 | 2151 | 2179 | 2182 | 2326 | n/a |
-| [HTML Living Standard](https://html.spec.whatwg.org/multipage/) | 149 | **147** | **147** | 153 | **147** | 149 | 155 | 149 |
+| [Ground News](https://ground.news/) | 1481 | **1259** | n/a | 1361 | 1386 | 1392 | 1468 | n/a |
+| [HTML Living Standard](https://html.spec.whatwg.org/multipage/) | 149 | **147** | n/a | 153 | **147** | 149 | 155 | 149 |
 | [Igalia](https://www.igalia.com/) | 50 | **33** | **33** | 36 | 36 | 36 | 37 | 36 |
-| [Leanpub](https://leanpub.com/) | 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/) | 222 | **195** | 196 | 202 | 200 | 200 | 202 | 203 |
-| [Nielsen Norman Group](https://www.nngroup.com/) | 84 | 71 | 71 | **53** | 71 | 73 | 74 | 73 |
+| [Leanpub](https://leanpub.com/) | 1521 | **1287** | **1287** | 1294 | 1293 | 1290 | 1516 | n/a |
+| [Mastodon](https://mastodon.social/explore) | 37 | **27** | n/a | 32 | 34 | 35 | 35 | 35 |
+| [MDN](https://developer.mozilla.org/en-US/) | 109 | **62** | n/a | 64 | 65 | 65 | 68 | 68 |
+| [Middle East Eye](https://www.middleeasteye.net/) | 222 | **195** | **195** | 202 | 200 | 200 | 202 | 203 |
+| [Nielsen Norman Group](https://www.nngroup.com/) | 86 | 74 | 74 | **55** | 74 | 75 | 77 | 76 |
 | [SitePoint](https://www.sitepoint.com/) | 485 | **354** | **354** | 425 | 459 | 464 | 481 | n/a |
 | [TetraLogical](https://tetralogical.com/) | 44 | 38 | 38 | **35** | 38 | 38 | 39 | 39 |
-| [TPGi](https://www.tpgi.com/) | 175 | **159** | 161 | 160 | 164 | 165 | 172 | 171 |
-| [United Nations](https://www.un.org/en/) | 151 | **112** | 114 | 121 | 125 | 124 | 130 | 123 |
+| [TPGi](https://www.tpgi.com/) | 175 | **159** | n/a | 160 | 164 | 166 | 172 | 171 |
+| [United Nations](https://www.un.org/en/) | 150 | **112** | 113 | 120 | 124 | 124 | 129 | 122 |
 | [W3C](https://www.w3.org/) | 50 | **36** | **36** | 38 | 38 | 38 | 40 | 38 |
-| **Average processing time** |  | 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) |
+| **Average processing time** |  | 478 ms (26/26) | 735 ms (16/26) | 174 ms (26/26) | 57 ms (26/26) | **17 ms (26/26)** | 318 ms (26/26) | 1536 ms (20/26) |
 
-(Last updated: Dec 16, 2025)
+(Last updated: Dec 17, 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

@@ -761,6 +761,7 @@ const presets = {
     useShortDoctype: true
   },
   comprehensive: {
+    // @@ Add `collapseAttributeWhitespace: true` (also add to preset in demo)
     caseSensitive: true,
     collapseBooleanAttributes: true,
     collapseInlineTagWhitespace: true,
@@ -860,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`).
@@ -1545,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);
@@ -1625,7 +1640,7 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
     return options.minifyCSS(attrValue, 'media');
   } else if (tag === 'iframe' && attrName === 'srcdoc') {
     // Recursively minify HTML content within srcdoc attribute
-    // Fast-path: skip if nothing would change
+    // Fast-path: Skip if nothing would change
     if (!shouldMinifyInnerHTML(options)) {
       return attrValue;
     }
@@ -2057,7 +2072,9 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
 
   if (typeof attrValue !== 'undefined' && (!options.removeAttributeQuotes ||
     ~attrValue.indexOf(uidAttr) || !canRemoveAttributeQuotes(attrValue))) {
+    // Determine the appropriate quote character
     if (!options.preventAttributesEscaping) {
+      // Normal mode: choose quotes and escape
       if (typeof options.quoteCharacter === 'undefined') {
         // Count quotes in a single pass instead of two regex operations
         let apos = 0, quot = 0;
@@ -2074,6 +2091,50 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
       } else {
         attrValue = attrValue.replace(/'/g, ''');
       }
+    } else {
+      // `preventAttributesEscaping` mode: choose safe quotes but don’t escape
+      // EXCEPT when both quote types are present—then escape to prevent invalid HTML
+      const hasDoubleQuote = attrValue.indexOf('"') !== -1;
+      const hasSingleQuote = attrValue.indexOf("'") !== -1;
+
+      if (hasDoubleQuote && hasSingleQuote) {
+        // Both quote types present: `preventAttributesEscaping` is ignored to ensure valid HTML
+        // Choose the quote type with fewer occurrences and escape the other
+        if (typeof options.quoteCharacter === 'undefined') {
+          let apos = 0, quot = 0;
+          for (let i = 0; i < attrValue.length; i++) {
+            if (attrValue[i] === "'") apos++;
+            else if (attrValue[i] === '"') quot++;
+          }
+          attrQuote = apos < quot ? '\'' : '"';
+        } else {
+          attrQuote = options.quoteCharacter === '\'' ? '\'' : '"';
+        }
+        if (attrQuote === '"') {
+          attrValue = attrValue.replace(/"/g, '&#34;');
+        } else {
+          attrValue = attrValue.replace(/'/g, '&#39;');
+        }
+      } else if (typeof options.quoteCharacter === 'undefined') {
+        // Single or no quote type: Choose safe quote delimiter
+        if (attrQuote === '"' && hasDoubleQuote && !hasSingleQuote) {
+          attrQuote = "'";
+        } else if (attrQuote === "'" && hasSingleQuote && !hasDoubleQuote) {
+          attrQuote = '"';
+        } else if (attrQuote !== '"' && attrQuote !== "'" && attrQuote !== '') {
+          // `attrQuote` is invalid/undefined (not `"`, `'`, or empty string)
+          // Set a safe default based on the value’s content
+          if (hasSingleQuote && !hasDoubleQuote) {
+            attrQuote = '"'; // Value has single quotes, use double quotes as delimiter
+          } else if (hasDoubleQuote && !hasSingleQuote) {
+            attrQuote = "'"; // Value has double quotes, use single quotes as delimiter
+          } else {
+            attrQuote = '"'; // No quotes in value, default to double quotes
+          }
+        }
+      } else {
+        attrQuote = options.quoteCharacter === '\'' ? '\'' : '"';
+      }
     }
     emittedAttrValue = attrQuote + attrValue + attrQuote;
     if (!isLast && !options.removeTagWhitespace) {
@@ -2338,7 +2399,7 @@ function uniqueId(value) {
 
 const specialContentTags = new Set(['script', 'style']);
 
-async function createSortFns(value, options, uidIgnore, uidAttr) {
+async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupChunks) {
   const attrChains = options.sortAttributes && Object.create(null);
   const classChain = options.sortClassName && new TokenChain();
 
@@ -2352,10 +2413,20 @@ async function createSortFns(value, options, uidIgnore, uidAttr) {
     return !uid || token.indexOf(uid) === -1;
   }
 
-  function shouldSkipUIDs(token) {
+  function shouldKeepToken(token) {
+    // Filter out any HTML comment tokens (UID placeholders)
+    // These are temporary markers created by `htmlmin:ignore` and `ignoreCustomFragments`
+    if (token.startsWith('<!--') && token.endsWith('-->')) {
+      return false;
+    }
     return shouldSkipUID(token, uidIgnore) && shouldSkipUID(token, uidAttr);
   }
 
+  // Pre-compile regex patterns for reuse (performance optimization)
+  // These must be declared before scan() since scan uses them
+  const whitespaceSplitPatternScan = /[ \t\n\f\r]+/;
+  const whitespaceSplitPatternSort = /[ \n\f\r]+/;
+
   async function scan(input) {
     let currentTag, currentType;
     const parser = new HTMLParser(input, {
@@ -2364,12 +2435,14 @@ async function createSortFns(value, options, uidIgnore, uidAttr) {
           if (!attrChains[tag]) {
             attrChains[tag] = new TokenChain();
           }
-          attrChains[tag].add(attrNames(attrs).filter(shouldSkipUIDs));
+          const attrNamesList = attrNames(attrs).filter(shouldKeepToken);
+          attrChains[tag].add(attrNamesList);
         }
         for (let i = 0, len = attrs.length; i < len; i++) {
           const attr = attrs[i];
           if (classChain && attr.value && options.name(attr.name) === 'class') {
-            classChain.add(trimWhitespace(attr.value).split(/[ \t\n\f\r]+/).filter(shouldSkipUIDs));
+            const classes = trimWhitespace(attr.value).split(whitespaceSplitPatternScan).filter(shouldKeepToken);
+            classChain.add(classes);
           } else if (options.processScripts && attr.name.toLowerCase() === 'type') {
             currentTag = tag;
             currentType = attr.value;
@@ -2389,19 +2462,84 @@ async function createSortFns(value, options, uidIgnore, uidAttr) {
         }
       },
       // We never need `nextTag` information in this scan
-      wantsNextTag: false
+      wantsNextTag: false,
+      // Continue on parse errors during analysis pass
+      continueOnParseError: options.continueOnParseError
     });
 
-    await parser.parse();
+    try {
+      await parser.parse();
+    } catch (e) {
+      // If parsing fails during analysis pass, just skip it—we’ll still have
+      // partial frequency data from what we could parse
+      if (!options.continueOnParseError) {
+        throw e;
+      }
+    }
   }
 
-  const log = options.log;
-  options.log = identity;
-  options.sortAttributes = false;
-  options.sortClassName = false;
-  const firstPassOutput = await minifyHTML(value, options);
-  await scan(firstPassOutput);
-  options.log = log;
+  // For the first pass, create a copy of options and disable aggressive minification.
+  // Keep attribute transformations (like `removeStyleLinkTypeAttributes`) for accurate analysis.
+  // This is safe because `createSortFns` is called before custom fragment UID markers (uidAttr) are added.
+  // Note: `htmlmin:ignore` UID markers (uidIgnore) already exist and are expanded for analysis.
+  const firstPassOptions = Object.assign({}, options, {
+    // Disable sorting for the analysis pass
+    sortAttributes: false,
+    sortClassName: false,
+    // Disable aggressive minification that doesn’t affect attribute analysis
+    collapseWhitespace: false,
+    removeAttributeQuotes: false,
+    removeTagWhitespace: false,
+    decodeEntities: false,
+    processScripts: false,
+    // Keep `ignoreCustomFragments` to handle template syntax correctly
+    // This is safe because `createSortFns` is now called before UID markers are added
+    // Continue on parse errors during analysis (e.g., template syntax)
+    continueOnParseError: true,
+    log: identity
+  });
+
+  // Temporarily enable `continueOnParseError` for the `scan()` function call below.
+  // Note: `firstPassOptions` already has `continueOnParseError: true` for the minifyHTML call.
+  const originalContinueOnParseError = options.continueOnParseError;
+  options.continueOnParseError = true;
+
+  // Pre-compile regex patterns for UID replacement and custom fragments
+  const uidReplacePattern = uidIgnore && ignoredMarkupChunks
+    ? new RegExp('<!--' + uidIgnore + '(\\d+)-->', 'g')
+    : null;
+  const customFragmentPattern = options.ignoreCustomFragments && options.ignoreCustomFragments.length > 0
+    ? new RegExp('(' + options.ignoreCustomFragments.map(re => re.source).join('|') + ')', 'g')
+    : null;
+
+  try {
+    // Expand UID tokens back to original content for frequency analysis
+    let expandedValue = value;
+    if (uidReplacePattern) {
+      expandedValue = value.replace(uidReplacePattern, function (match, index) {
+        return ignoredMarkupChunks[+index] || '';
+      });
+      // Reset `lastIndex` for pattern reuse
+      uidReplacePattern.lastIndex = 0;
+    }
+
+    // First pass minification applies attribute transformations
+    // like removeStyleLinkTypeAttributes for accurate frequency analysis
+    const firstPassOutput = await minifyHTML(expandedValue, firstPassOptions);
+
+    // For frequency analysis, we need to remove custom fragments temporarily
+    // because HTML comments in opening tags prevent proper attribute parsing.
+    // We remove them with a space to preserve attribute boundaries.
+    let scanValue = firstPassOutput;
+    if (customFragmentPattern) {
+      scanValue = firstPassOutput.replace(customFragmentPattern, ' ');
+    }
+
+    await scan(scanValue);
+  } finally {
+    // Restore original option
+    options.continueOnParseError = originalContinueOnParseError;
+  }
   if (attrChains) {
     const attrSorters = Object.create(null);
     for (const tag in attrChains) {
@@ -2415,7 +2553,8 @@ async function createSortFns(value, options, uidIgnore, uidAttr) {
         names.forEach(function (name, index) {
           (attrMap[name] || (attrMap[name] = [])).push(attrs[index]);
         });
-        sorter.sort(names).forEach(function (name, index) {
+        const sorted = sorter.sort(names);
+        sorted.forEach(function (name, index) {
           attrs[index] = attrMap[name].shift();
         });
       }
@@ -2424,7 +2563,21 @@ async function createSortFns(value, options, uidIgnore, uidAttr) {
   if (classChain) {
     const sorter = classChain.createSorter();
     options.sortClassName = function (value) {
-      return sorter.sort(value.split(/[ \n\f\r]+/)).join(' ');
+      // Expand UID tokens back to original content before sorting
+      // Fast path: Skip if no HTML comments (UID markers) present
+      let expandedValue = value;
+      if (uidReplacePattern && value.indexOf('<!--') !== -1) {
+        expandedValue = value.replace(uidReplacePattern, function (match, index) {
+          return ignoredMarkupChunks[+index] || '';
+        });
+        // Reset `lastIndex` for pattern reuse
+        uidReplacePattern.lastIndex = 0;
+      }
+      const classes = expandedValue.split(whitespaceSplitPatternSort).filter(function(cls) {
+        return cls !== '';
+      });
+      const sorted = sorter.sort(classes);
+      return sorted.join(' ');
     };
   }
 }
@@ -2505,6 +2658,13 @@ async function minifyHTML(value, options, partialMarkup) {
     return token;
   });
 
+  // Create sort functions after `htmlmin:ignore` processing but before custom fragment UID markers
+  // This allows proper frequency analysis with access to ignored content via UID tokens
+  if ((options.sortAttributes && typeof options.sortAttributes !== 'function') ||
+    (options.sortClassName && typeof options.sortClassName !== 'function')) {
+    await createSortFns(value, options, uidIgnore, null, ignoredMarkupChunks);
+  }
+
   const customFragments = options.ignoreCustomFragments.map(function (re) {
     return re.source;
   });
@@ -2563,11 +2723,6 @@ async function minifyHTML(value, options, partialMarkup) {
     });
   }
 
-  if ((options.sortAttributes && typeof options.sortAttributes !== 'function') ||
-    (options.sortClassName && typeof options.sortClassName !== 'function')) {
-    await createSortFns(value, options, uidIgnore, uidAttr);
-  }
-
   function _canCollapseWhitespace(tag, attrs) {
     return options.canCollapseWhitespace(tag, attrs, canCollapseWhitespace);
   }

package/dist/htmlminifier.esm.bundle.js

@@ -5903,6 +5903,7 @@ const presets = {
     useShortDoctype: true
   },
   comprehensive: {
+    // @@ Add `collapseAttributeWhitespace: true` (also add to preset in demo)
     caseSensitive: true,
     collapseBooleanAttributes: true,
     collapseInlineTagWhitespace: true,
@@ -6002,6 +6003,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`).
@@ -6687,6 +6696,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);
@@ -6767,7 +6782,7 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
     return options.minifyCSS(attrValue, 'media');
   } else if (tag === 'iframe' && attrName === 'srcdoc') {
     // Recursively minify HTML content within srcdoc attribute
-    // Fast-path: skip if nothing would change
+    // Fast-path: Skip if nothing would change
     if (!shouldMinifyInnerHTML(options)) {
       return attrValue;
     }
@@ -7199,7 +7214,9 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
 
   if (typeof attrValue !== 'undefined' && (!options.removeAttributeQuotes ||
     ~attrValue.indexOf(uidAttr) || !canRemoveAttributeQuotes(attrValue))) {
+    // Determine the appropriate quote character
     if (!options.preventAttributesEscaping) {
+      // Normal mode: choose quotes and escape
       if (typeof options.quoteCharacter === 'undefined') {
         // Count quotes in a single pass instead of two regex operations
         let apos = 0, quot = 0;
@@ -7216,6 +7233,50 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
       } else {
         attrValue = attrValue.replace(/'/g, ''');
       }
+    } else {
+      // `preventAttributesEscaping` mode: choose safe quotes but don’t escape
+      // EXCEPT when both quote types are present—then escape to prevent invalid HTML
+      const hasDoubleQuote = attrValue.indexOf('"') !== -1;
+      const hasSingleQuote = attrValue.indexOf("'") !== -1;
+
+      if (hasDoubleQuote && hasSingleQuote) {
+        // Both quote types present: `preventAttributesEscaping` is ignored to ensure valid HTML
+        // Choose the quote type with fewer occurrences and escape the other
+        if (typeof options.quoteCharacter === 'undefined') {
+          let apos = 0, quot = 0;
+          for (let i = 0; i < attrValue.length; i++) {
+            if (attrValue[i] === "'") apos++;
+            else if (attrValue[i] === '"') quot++;
+          }
+          attrQuote = apos < quot ? '\'' : '"';
+        } else {
+          attrQuote = options.quoteCharacter === '\'' ? '\'' : '"';
+        }
+        if (attrQuote === '"') {
+          attrValue = attrValue.replace(/"/g, '&#34;');
+        } else {
+          attrValue = attrValue.replace(/'/g, '&#39;');
+        }
+      } else if (typeof options.quoteCharacter === 'undefined') {
+        // Single or no quote type: Choose safe quote delimiter
+        if (attrQuote === '"' && hasDoubleQuote && !hasSingleQuote) {
+          attrQuote = "'";
+        } else if (attrQuote === "'" && hasSingleQuote && !hasDoubleQuote) {
+          attrQuote = '"';
+        } else if (attrQuote !== '"' && attrQuote !== "'" && attrQuote !== '') {
+          // `attrQuote` is invalid/undefined (not `"`, `'`, or empty string)
+          // Set a safe default based on the value’s content
+          if (hasSingleQuote && !hasDoubleQuote) {
+            attrQuote = '"'; // Value has single quotes, use double quotes as delimiter
+          } else if (hasDoubleQuote && !hasSingleQuote) {
+            attrQuote = "'"; // Value has double quotes, use single quotes as delimiter
+          } else {
+            attrQuote = '"'; // No quotes in value, default to double quotes
+          }
+        }
+      } else {
+        attrQuote = options.quoteCharacter === '\'' ? '\'' : '"';
+      }
     }
     emittedAttrValue = attrQuote + attrValue + attrQuote;
     if (!isLast && !options.removeTagWhitespace) {
@@ -7480,7 +7541,7 @@ function uniqueId(value) {
 
 const specialContentTags = new Set(['script', 'style']);
 
-async function createSortFns(value, options, uidIgnore, uidAttr) {
+async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupChunks) {
   const attrChains = options.sortAttributes && Object.create(null);
   const classChain = options.sortClassName && new TokenChain();
 
@@ -7494,10 +7555,20 @@ async function createSortFns(value, options, uidIgnore, uidAttr) {
     return !uid || token.indexOf(uid) === -1;
   }
 
-  function shouldSkipUIDs(token) {
+  function shouldKeepToken(token) {
+    // Filter out any HTML comment tokens (UID placeholders)
+    // These are temporary markers created by `htmlmin:ignore` and `ignoreCustomFragments`
+    if (token.startsWith('<!--') && token.endsWith('-->')) {
+      return false;
+    }
     return shouldSkipUID(token, uidIgnore) && shouldSkipUID(token, uidAttr);
   }
 
+  // Pre-compile regex patterns for reuse (performance optimization)
+  // These must be declared before scan() since scan uses them
+  const whitespaceSplitPatternScan = /[ \t\n\f\r]+/;
+  const whitespaceSplitPatternSort = /[ \n\f\r]+/;
+
   async function scan(input) {
     let currentTag, currentType;
     const parser = new HTMLParser(input, {
@@ -7506,12 +7577,14 @@ async function createSortFns(value, options, uidIgnore, uidAttr) {
           if (!attrChains[tag]) {
             attrChains[tag] = new TokenChain();
           }
-          attrChains[tag].add(attrNames(attrs).filter(shouldSkipUIDs));
+          const attrNamesList = attrNames(attrs).filter(shouldKeepToken);
+          attrChains[tag].add(attrNamesList);
         }
         for (let i = 0, len = attrs.length; i < len; i++) {
           const attr = attrs[i];
           if (classChain && attr.value && options.name(attr.name) === 'class') {
-            classChain.add(trimWhitespace(attr.value).split(/[ \t\n\f\r]+/).filter(shouldSkipUIDs));
+            const classes = trimWhitespace(attr.value).split(whitespaceSplitPatternScan).filter(shouldKeepToken);
+            classChain.add(classes);
           } else if (options.processScripts && attr.name.toLowerCase() === 'type') {
             currentTag = tag;
             currentType = attr.value;
@@ -7531,19 +7604,84 @@ async function createSortFns(value, options, uidIgnore, uidAttr) {
         }
       },
       // We never need `nextTag` information in this scan
-      wantsNextTag: false
+      wantsNextTag: false,
+      // Continue on parse errors during analysis pass
+      continueOnParseError: options.continueOnParseError
     });
 
-    await parser.parse();
+    try {
+      await parser.parse();
+    } catch (e) {
+      // If parsing fails during analysis pass, just skip it—we’ll still have
+      // partial frequency data from what we could parse
+      if (!options.continueOnParseError) {
+        throw e;
+      }
+    }
   }
 
-  const log = options.log;
-  options.log = identity;
-  options.sortAttributes = false;
-  options.sortClassName = false;
-  const firstPassOutput = await minifyHTML(value, options);
-  await scan(firstPassOutput);
-  options.log = log;
+  // For the first pass, create a copy of options and disable aggressive minification.
+  // Keep attribute transformations (like `removeStyleLinkTypeAttributes`) for accurate analysis.
+  // This is safe because `createSortFns` is called before custom fragment UID markers (uidAttr) are added.
+  // Note: `htmlmin:ignore` UID markers (uidIgnore) already exist and are expanded for analysis.
+  const firstPassOptions = Object.assign({}, options, {
+    // Disable sorting for the analysis pass
+    sortAttributes: false,
+    sortClassName: false,
+    // Disable aggressive minification that doesn’t affect attribute analysis
+    collapseWhitespace: false,
+    removeAttributeQuotes: false,
+    removeTagWhitespace: false,
+    decodeEntities: false,
+    processScripts: false,
+    // Keep `ignoreCustomFragments` to handle template syntax correctly
+    // This is safe because `createSortFns` is now called before UID markers are added
+    // Continue on parse errors during analysis (e.g., template syntax)
+    continueOnParseError: true,
+    log: identity
+  });
+
+  // Temporarily enable `continueOnParseError` for the `scan()` function call below.
+  // Note: `firstPassOptions` already has `continueOnParseError: true` for the minifyHTML call.
+  const originalContinueOnParseError = options.continueOnParseError;
+  options.continueOnParseError = true;
+
+  // Pre-compile regex patterns for UID replacement and custom fragments
+  const uidReplacePattern = uidIgnore && ignoredMarkupChunks
+    ? new RegExp('<!--' + uidIgnore + '(\\d+)-->', 'g')
+    : null;
+  const customFragmentPattern = options.ignoreCustomFragments && options.ignoreCustomFragments.length > 0
+    ? new RegExp('(' + options.ignoreCustomFragments.map(re => re.source).join('|') + ')', 'g')
+    : null;
+
+  try {
+    // Expand UID tokens back to original content for frequency analysis
+    let expandedValue = value;
+    if (uidReplacePattern) {
+      expandedValue = value.replace(uidReplacePattern, function (match, index) {
+        return ignoredMarkupChunks[+index] || '';
+      });
+      // Reset `lastIndex` for pattern reuse
+      uidReplacePattern.lastIndex = 0;
+    }
+
+    // First pass minification applies attribute transformations
+    // like removeStyleLinkTypeAttributes for accurate frequency analysis
+    const firstPassOutput = await minifyHTML(expandedValue, firstPassOptions);
+
+    // For frequency analysis, we need to remove custom fragments temporarily
+    // because HTML comments in opening tags prevent proper attribute parsing.
+    // We remove them with a space to preserve attribute boundaries.
+    let scanValue = firstPassOutput;
+    if (customFragmentPattern) {
+      scanValue = firstPassOutput.replace(customFragmentPattern, ' ');
+    }
+
+    await scan(scanValue);
+  } finally {
+    // Restore original option
+    options.continueOnParseError = originalContinueOnParseError;
+  }
   if (attrChains) {
     const attrSorters = Object.create(null);
     for (const tag in attrChains) {
@@ -7557,7 +7695,8 @@ async function createSortFns(value, options, uidIgnore, uidAttr) {
         names.forEach(function (name, index) {
           (attrMap[name] || (attrMap[name] = [])).push(attrs[index]);
         });
-        sorter.sort(names).forEach(function (name, index) {
+        const sorted = sorter.sort(names);
+        sorted.forEach(function (name, index) {
           attrs[index] = attrMap[name].shift();
         });
       }
@@ -7566,7 +7705,21 @@ async function createSortFns(value, options, uidIgnore, uidAttr) {
   if (classChain) {
     const sorter = classChain.createSorter();
     options.sortClassName = function (value) {
-      return sorter.sort(value.split(/[ \n\f\r]+/)).join(' ');
+      // Expand UID tokens back to original content before sorting
+      // Fast path: Skip if no HTML comments (UID markers) present
+      let expandedValue = value;
+      if (uidReplacePattern && value.indexOf('<!--') !== -1) {
+        expandedValue = value.replace(uidReplacePattern, function (match, index) {
+          return ignoredMarkupChunks[+index] || '';
+        });
+        // Reset `lastIndex` for pattern reuse
+        uidReplacePattern.lastIndex = 0;
+      }
+      const classes = expandedValue.split(whitespaceSplitPatternSort).filter(function(cls) {
+        return cls !== '';
+      });
+      const sorted = sorter.sort(classes);
+      return sorted.join(' ');
     };
   }
 }
@@ -7647,6 +7800,13 @@ async function minifyHTML(value, options, partialMarkup) {
     return token;
   });
 
+  // Create sort functions after `htmlmin:ignore` processing but before custom fragment UID markers
+  // This allows proper frequency analysis with access to ignored content via UID tokens
+  if ((options.sortAttributes && typeof options.sortAttributes !== 'function') ||
+    (options.sortClassName && typeof options.sortClassName !== 'function')) {
+    await createSortFns(value, options, uidIgnore, null, ignoredMarkupChunks);
+  }
+
   const customFragments = options.ignoreCustomFragments.map(function (re) {
     return re.source;
   });
@@ -7705,11 +7865,6 @@ async function minifyHTML(value, options, partialMarkup) {
     });
   }
 
-  if ((options.sortAttributes && typeof options.sortAttributes !== 'function') ||
-    (options.sortClassName && typeof options.sortClassName !== 'function')) {
-    await createSortFns(value, options, uidIgnore, uidAttr);
-  }
-
   function _canCollapseWhitespace(tag, attrs) {
     return options.canCollapseWhitespace(tag, attrs, canCollapseWhitespace);
   }

package/dist/types/htmlminifier.d.ts

@@ -44,6 +44,15 @@ export type MinifierOptions = {
      * Default: `false`
      */
     caseSensitive?: boolean;
+    /**
+     * 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`
+     */
+    collapseAttributeWhitespace?: boolean;
     /**
      * Collapse boolean attributes to their name only (for example
      * `disabled="disabled"` → `disabled`).

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

@@ -1 +1 @@
-{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"AAovEO,8BAJI,MAAM,YACN,eAAe,GACb,OAAO,CAAC,MAAM,CAAC,CAQ3B;;;;;;;;;;;;UA3tES,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":"AA84EO,8BAJI,MAAM,YACN,eAAe,GACb,OAAO,CAAC,MAAM,CAAC,CAQ3B;;;;;;;;;;;;UAr3ES,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;;;;;;;;;kCAON,OAAO;;;;;;;;gCAQR,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;;wBA3YkC,cAAc;0BAAd,cAAc;+BAAd,cAAc"}

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

@@ -1 +1 @@
-{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/presets.js"],"names":[],"mappings":"AAgDA;;;;GAIG;AACH,gCAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAMvB;AAED;;;GAGG;AACH,kCAFa,MAAM,EAAE,CAIpB"}
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/presets.js"],"names":[],"mappings":"AAiDA;;;;GAIG;AACH,gCAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAMvB;AAED;;;GAGG;AACH,kCAFa,MAAM,EAAE,CAIpB"}

package/package.json

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

package/src/htmlminifier.js

@@ -61,6 +61,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`).
@@ -746,6 +754,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);
@@ -826,7 +840,7 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
     return options.minifyCSS(attrValue, 'media');
   } else if (tag === 'iframe' && attrName === 'srcdoc') {
     // Recursively minify HTML content within srcdoc attribute
-    // Fast-path: skip if nothing would change
+    // Fast-path: Skip if nothing would change
     if (!shouldMinifyInnerHTML(options)) {
       return attrValue;
     }
@@ -1258,7 +1272,9 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
 
   if (typeof attrValue !== 'undefined' && (!options.removeAttributeQuotes ||
     ~attrValue.indexOf(uidAttr) || !canRemoveAttributeQuotes(attrValue))) {
+    // Determine the appropriate quote character
     if (!options.preventAttributesEscaping) {
+      // Normal mode: choose quotes and escape
       if (typeof options.quoteCharacter === 'undefined') {
         // Count quotes in a single pass instead of two regex operations
         let apos = 0, quot = 0;
@@ -1275,6 +1291,50 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
       } else {
         attrValue = attrValue.replace(/'/g, ''');
       }
+    } else {
+      // `preventAttributesEscaping` mode: choose safe quotes but don’t escape
+      // EXCEPT when both quote types are present—then escape to prevent invalid HTML
+      const hasDoubleQuote = attrValue.indexOf('"') !== -1;
+      const hasSingleQuote = attrValue.indexOf("'") !== -1;
+
+      if (hasDoubleQuote && hasSingleQuote) {
+        // Both quote types present: `preventAttributesEscaping` is ignored to ensure valid HTML
+        // Choose the quote type with fewer occurrences and escape the other
+        if (typeof options.quoteCharacter === 'undefined') {
+          let apos = 0, quot = 0;
+          for (let i = 0; i < attrValue.length; i++) {
+            if (attrValue[i] === "'") apos++;
+            else if (attrValue[i] === '"') quot++;
+          }
+          attrQuote = apos < quot ? '\'' : '"';
+        } else {
+          attrQuote = options.quoteCharacter === '\'' ? '\'' : '"';
+        }
+        if (attrQuote === '"') {
+          attrValue = attrValue.replace(/"/g, '&#34;');
+        } else {
+          attrValue = attrValue.replace(/'/g, '&#39;');
+        }
+      } else if (typeof options.quoteCharacter === 'undefined') {
+        // Single or no quote type: Choose safe quote delimiter
+        if (attrQuote === '"' && hasDoubleQuote && !hasSingleQuote) {
+          attrQuote = "'";
+        } else if (attrQuote === "'" && hasSingleQuote && !hasDoubleQuote) {
+          attrQuote = '"';
+        } else if (attrQuote !== '"' && attrQuote !== "'" && attrQuote !== '') {
+          // `attrQuote` is invalid/undefined (not `"`, `'`, or empty string)
+          // Set a safe default based on the value’s content
+          if (hasSingleQuote && !hasDoubleQuote) {
+            attrQuote = '"'; // Value has single quotes, use double quotes as delimiter
+          } else if (hasDoubleQuote && !hasSingleQuote) {
+            attrQuote = "'"; // Value has double quotes, use single quotes as delimiter
+          } else {
+            attrQuote = '"'; // No quotes in value, default to double quotes
+          }
+        }
+      } else {
+        attrQuote = options.quoteCharacter === '\'' ? '\'' : '"';
+      }
     }
     emittedAttrValue = attrQuote + attrValue + attrQuote;
     if (!isLast && !options.removeTagWhitespace) {
@@ -1539,7 +1599,7 @@ function uniqueId(value) {
 
 const specialContentTags = new Set(['script', 'style']);
 
-async function createSortFns(value, options, uidIgnore, uidAttr) {
+async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupChunks) {
   const attrChains = options.sortAttributes && Object.create(null);
   const classChain = options.sortClassName && new TokenChain();
 
@@ -1553,10 +1613,20 @@ async function createSortFns(value, options, uidIgnore, uidAttr) {
     return !uid || token.indexOf(uid) === -1;
   }
 
-  function shouldSkipUIDs(token) {
+  function shouldKeepToken(token) {
+    // Filter out any HTML comment tokens (UID placeholders)
+    // These are temporary markers created by `htmlmin:ignore` and `ignoreCustomFragments`
+    if (token.startsWith('<!--') && token.endsWith('-->')) {
+      return false;
+    }
     return shouldSkipUID(token, uidIgnore) && shouldSkipUID(token, uidAttr);
   }
 
+  // Pre-compile regex patterns for reuse (performance optimization)
+  // These must be declared before scan() since scan uses them
+  const whitespaceSplitPatternScan = /[ \t\n\f\r]+/;
+  const whitespaceSplitPatternSort = /[ \n\f\r]+/;
+
   async function scan(input) {
     let currentTag, currentType;
     const parser = new HTMLParser(input, {
@@ -1565,12 +1635,14 @@ async function createSortFns(value, options, uidIgnore, uidAttr) {
           if (!attrChains[tag]) {
             attrChains[tag] = new TokenChain();
           }
-          attrChains[tag].add(attrNames(attrs).filter(shouldSkipUIDs));
+          const attrNamesList = attrNames(attrs).filter(shouldKeepToken);
+          attrChains[tag].add(attrNamesList);
         }
         for (let i = 0, len = attrs.length; i < len; i++) {
           const attr = attrs[i];
           if (classChain && attr.value && options.name(attr.name) === 'class') {
-            classChain.add(trimWhitespace(attr.value).split(/[ \t\n\f\r]+/).filter(shouldSkipUIDs));
+            const classes = trimWhitespace(attr.value).split(whitespaceSplitPatternScan).filter(shouldKeepToken);
+            classChain.add(classes);
           } else if (options.processScripts && attr.name.toLowerCase() === 'type') {
             currentTag = tag;
             currentType = attr.value;
@@ -1590,19 +1662,84 @@ async function createSortFns(value, options, uidIgnore, uidAttr) {
         }
       },
       // We never need `nextTag` information in this scan
-      wantsNextTag: false
+      wantsNextTag: false,
+      // Continue on parse errors during analysis pass
+      continueOnParseError: options.continueOnParseError
     });
 
-    await parser.parse();
+    try {
+      await parser.parse();
+    } catch (e) {
+      // If parsing fails during analysis pass, just skip it—we’ll still have
+      // partial frequency data from what we could parse
+      if (!options.continueOnParseError) {
+        throw e;
+      }
+    }
   }
 
-  const log = options.log;
-  options.log = identity;
-  options.sortAttributes = false;
-  options.sortClassName = false;
-  const firstPassOutput = await minifyHTML(value, options);
-  await scan(firstPassOutput);
-  options.log = log;
+  // For the first pass, create a copy of options and disable aggressive minification.
+  // Keep attribute transformations (like `removeStyleLinkTypeAttributes`) for accurate analysis.
+  // This is safe because `createSortFns` is called before custom fragment UID markers (uidAttr) are added.
+  // Note: `htmlmin:ignore` UID markers (uidIgnore) already exist and are expanded for analysis.
+  const firstPassOptions = Object.assign({}, options, {
+    // Disable sorting for the analysis pass
+    sortAttributes: false,
+    sortClassName: false,
+    // Disable aggressive minification that doesn’t affect attribute analysis
+    collapseWhitespace: false,
+    removeAttributeQuotes: false,
+    removeTagWhitespace: false,
+    decodeEntities: false,
+    processScripts: false,
+    // Keep `ignoreCustomFragments` to handle template syntax correctly
+    // This is safe because `createSortFns` is now called before UID markers are added
+    // Continue on parse errors during analysis (e.g., template syntax)
+    continueOnParseError: true,
+    log: identity
+  });
+
+  // Temporarily enable `continueOnParseError` for the `scan()` function call below.
+  // Note: `firstPassOptions` already has `continueOnParseError: true` for the minifyHTML call.
+  const originalContinueOnParseError = options.continueOnParseError;
+  options.continueOnParseError = true;
+
+  // Pre-compile regex patterns for UID replacement and custom fragments
+  const uidReplacePattern = uidIgnore && ignoredMarkupChunks
+    ? new RegExp('<!--' + uidIgnore + '(\\d+)-->', 'g')
+    : null;
+  const customFragmentPattern = options.ignoreCustomFragments && options.ignoreCustomFragments.length > 0
+    ? new RegExp('(' + options.ignoreCustomFragments.map(re => re.source).join('|') + ')', 'g')
+    : null;
+
+  try {
+    // Expand UID tokens back to original content for frequency analysis
+    let expandedValue = value;
+    if (uidReplacePattern) {
+      expandedValue = value.replace(uidReplacePattern, function (match, index) {
+        return ignoredMarkupChunks[+index] || '';
+      });
+      // Reset `lastIndex` for pattern reuse
+      uidReplacePattern.lastIndex = 0;
+    }
+
+    // First pass minification applies attribute transformations
+    // like removeStyleLinkTypeAttributes for accurate frequency analysis
+    const firstPassOutput = await minifyHTML(expandedValue, firstPassOptions);
+
+    // For frequency analysis, we need to remove custom fragments temporarily
+    // because HTML comments in opening tags prevent proper attribute parsing.
+    // We remove them with a space to preserve attribute boundaries.
+    let scanValue = firstPassOutput;
+    if (customFragmentPattern) {
+      scanValue = firstPassOutput.replace(customFragmentPattern, ' ');
+    }
+
+    await scan(scanValue);
+  } finally {
+    // Restore original option
+    options.continueOnParseError = originalContinueOnParseError;
+  }
   if (attrChains) {
     const attrSorters = Object.create(null);
     for (const tag in attrChains) {
@@ -1616,7 +1753,8 @@ async function createSortFns(value, options, uidIgnore, uidAttr) {
         names.forEach(function (name, index) {
           (attrMap[name] || (attrMap[name] = [])).push(attrs[index]);
         });
-        sorter.sort(names).forEach(function (name, index) {
+        const sorted = sorter.sort(names);
+        sorted.forEach(function (name, index) {
           attrs[index] = attrMap[name].shift();
         });
       }
@@ -1625,7 +1763,21 @@ async function createSortFns(value, options, uidIgnore, uidAttr) {
   if (classChain) {
     const sorter = classChain.createSorter();
     options.sortClassName = function (value) {
-      return sorter.sort(value.split(/[ \n\f\r]+/)).join(' ');
+      // Expand UID tokens back to original content before sorting
+      // Fast path: Skip if no HTML comments (UID markers) present
+      let expandedValue = value;
+      if (uidReplacePattern && value.indexOf('<!--') !== -1) {
+        expandedValue = value.replace(uidReplacePattern, function (match, index) {
+          return ignoredMarkupChunks[+index] || '';
+        });
+        // Reset `lastIndex` for pattern reuse
+        uidReplacePattern.lastIndex = 0;
+      }
+      const classes = expandedValue.split(whitespaceSplitPatternSort).filter(function(cls) {
+        return cls !== '';
+      });
+      const sorted = sorter.sort(classes);
+      return sorted.join(' ');
     };
   }
 }
@@ -1706,6 +1858,13 @@ async function minifyHTML(value, options, partialMarkup) {
     return token;
   });
 
+  // Create sort functions after `htmlmin:ignore` processing but before custom fragment UID markers
+  // This allows proper frequency analysis with access to ignored content via UID tokens
+  if ((options.sortAttributes && typeof options.sortAttributes !== 'function') ||
+    (options.sortClassName && typeof options.sortClassName !== 'function')) {
+    await createSortFns(value, options, uidIgnore, null, ignoredMarkupChunks);
+  }
+
   const customFragments = options.ignoreCustomFragments.map(function (re) {
     return re.source;
   });
@@ -1764,11 +1923,6 @@ async function minifyHTML(value, options, partialMarkup) {
     });
   }
 
-  if ((options.sortAttributes && typeof options.sortAttributes !== 'function') ||
-    (options.sortClassName && typeof options.sortClassName !== 'function')) {
-    await createSortFns(value, options, uidIgnore, uidAttr);
-  }
-
   function _canCollapseWhitespace(tag, attrs) {
     return options.canCollapseWhitespace(tag, attrs, canCollapseWhitespace);
   }

package/src/presets.js

@@ -22,6 +22,7 @@ export const presets = {
     useShortDoctype: true
   },
   comprehensive: {
+    // @@ Add `collapseAttributeWhitespace: true` (also add to preset in demo)
     caseSensitive: true,
     collapseBooleanAttributes: true,
     collapseInlineTagWhitespace: true,