html-minifier-next 6.2.2 → 6.2.4

package/cli.js

@@ -300,7 +300,7 @@ program.helpOption('-h, --help', 'Display help for command');
   await program.arguments('[files...]').action(function (files) {
     capturedFiles = files;
     filesProvided = files.length > 0;
-    // Defer reading files until after we check for consumed filenames
+    // Defer reading files until after check for consumed filenames
   }).parseAsync(process.argv);
 
   const programOptions = program.opts();

package/dist/htmlminifier.cjs

@@ -332,12 +332,12 @@ class HTMLParser {
     while (pos < fullLength) {
       lastPos = pos;
 
-      // Make sure we’re not in a `script` or `style` element
+      // Make sure not to be in a `script` or `style` element
       if (!lastTag || !special.has(lastTag)) {
         const textEnd = fullHtml.indexOf('<', pos);
 
         if (textEnd === pos) {
-          // We found a tag at current position
+          // Tag found at current position
 
           // Check cache from previous lookahead (avoids re-parsing the same tag)
           if (cachedNextStartTag && cachedNextStartTag.pos === pos) {
@@ -571,7 +571,7 @@ class HTMLParser {
             break;
           }
 
-          // Limit the input length we pass to the regex to prevent catastrophic backtracking
+          // Limit the input length to pass to the regex to prevent catastrophic backtracking
           const remainingLen = fullLength - currentPos;
           const isLimited = remainingLen > MAX_ATTR_PARSE_LENGTH;
 
@@ -586,7 +586,7 @@ class HTMLParser {
             const searchStr = fullHtml.substring(currentPos, extractEndPos);
             attr = searchStr.match(attribute);
 
-            // If we limited the input and got a match, check if the value might be truncated
+            // If input was limited and there’s a match, check if the value might be truncated
             if (attr) {
               // Check if the attribute value extends beyond our search window
               const attrEnd = attr[0].length;
@@ -644,7 +644,7 @@ class HTMLParser {
             }
 
             if (!attr) {
-              // If we limited the input and got no match, try manual extraction
+              // If input was limited and there’s no match, try manual extraction
               // This handles cases where quoted attributes exceed `MAX_ATTR_PARSE_LENGTH`
               const manualMatch = searchStr.match(/^\s*([^\s"'<>/=]+)\s*=\s*/);
               if (manualMatch) {
@@ -710,7 +710,7 @@ class HTMLParser {
         if (currentTag === needle) {
           return pos;
         }
-        // Stop searching if we hit a table boundary
+        // Stop searching if hitting a table boundary
         if (currentTag === 'table') {
           break;
         }
@@ -2103,7 +2103,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
 // Imports
 
 
-// Lazy-load entities only when `decodeEntities` is enabled
+// Lazy-load entities (used for `decodeEntities` and event-handler attribute decode before `minifyJS`)
 
 let decodeHTMLStrictPromise;
 async function getDecodeHTMLStrict() {
@@ -2154,7 +2154,7 @@ function attributesInclude(attributes, attribute) {
 /**
  * Remove duplicate attributes from an attribute list.
  * Per HTML spec, when an attribute appears multiple times, the first occurrence wins.
- * Duplicate attributes result in invalid HTML, so we keep only the first.
+ * Duplicate attributes result in invalid HTML, so only the first is kept.
  * @param {Array} attrs - Array of attribute objects with `name` property
  * @param {boolean} caseSensitive - Whether to compare names case-sensitively (for XML/SVG)
  * @returns {Array} Deduplicated attribute array (modifies in place and returns)
@@ -2199,7 +2199,7 @@ function isAttributeRedundant(tag, attrName, attrValue, attrs) {
     return false;
   }
 
-  // Now we know we need to check the value, so normalize it
+  // Value needs to be checked, so normalize it
   attrValue = attrValue ? trimWhitespace(attrValue.toLowerCase()) : '';
 
   // Legacy attribute checks
@@ -2399,6 +2399,23 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTM
 
   if (isEventAttr) {
     attrValue = trimWhitespace(attrValue).replace(/^javascript:\s*/i, '');
+    // Browsers decode attribute values before running event-handler JS—
+    // decode first so the minifier gets valid JavaScript
+    if (!options.decodeEntities && options.minifyJS !== identity && attrValue.indexOf('&') !== -1) {
+      return getDecodeHTMLStrict().then(decode => {
+        const decoded = decode(attrValue);
+        const result = options.minifyJS(decoded, true);
+        const reEncode = v => (v && v.indexOf('&') !== -1) ? v.replace(RE_AMP_ENTITY, '&amp;$1') : v;
+        if (isThenable(result)) {
+          return result.then(reEncode, err => {
+            if (!options.continueOnMinifyError) throw err;
+            options.log && options.log(err);
+            return attrValue;
+          });
+        }
+        return reEncode(result);
+      });
+    }
     const result = options.minifyJS(attrValue, true);
     if (isThenable(result)) {
       return result.catch(err => {
@@ -2640,7 +2657,7 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
   let attrFragment;
   let emittedAttrValue;
 
-  // Determine if we need to add/keep quotes
+  // Determine if need to add/keep quotes
   const shouldAddQuotes = typeof attrValue !== 'undefined' && (
     // If `removeAttributeQuotes` is enabled, add quotes only if they can’t be removed
     (options.removeAttributeQuotes && (attrValue.indexOf(uidAttr) !== -1 || !canRemoveAttributeQuotes(attrValue))) ||
@@ -2655,7 +2672,7 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
     // Determine the appropriate quote character
     if (!options.preventAttributesEscaping) {
       // Normal mode: Choose optimal quote type to minimize escaping
-      // unless we’re preserving original quotes and they don’t need escaping
+      // unless preserving original quotes and they don’t need escaping
       const needsEscaping = (attrQuote === '"' && attrValue.indexOf('"') !== -1) || (attrQuote === "'" && attrValue.indexOf("'") !== -1);
 
       if (options.removeAttributeQuotes || typeof options.quoteCharacter !== 'undefined' || needsEscaping || attrQuote === '') {
@@ -3047,6 +3064,11 @@ const DEFAULT_JS_TYPES = new Set(['', 'text/javascript', 'application/javascript
 const RE_START_TAG = /^<[^/!]/;
 const RE_END_TAG = /^<\//;
 
+// Pre-compiled patterns for `htmlmin:ignore` block content analysis
+const RE_HTML_COMMENT_START = /^\s*<!--/;
+const RE_CLOSING_TAG_START = /^\s*<\/([a-zA-Z][\w:-]*)/;
+const RE_LAST_HTML_TAG = /[\s\S]*<(\/?[a-zA-Z][\w:-]*)/;
+
 // HTML encoding types for annotation-xml (MathML)
 const RE_HTML_ENCODING = /^(text\/html|application\/xhtml\+xml)$/i;
 
@@ -3685,7 +3707,7 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
           await scan(text);
         }
       },
-      // We never need `nextTag` information in this scan
+      // No need for `nextTag` information in this scan
       wantsNextTag: false,
       // Continue on parse errors during analysis pass
       continueOnParseError: options.continueOnParseError
@@ -3694,7 +3716,7 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
     try {
       await parser.parse();
     } catch (err) {
-      // If parsing fails during analysis pass, just skip it—we’ll still have partial frequency data from what we could parse
+      // If parsing fails during analysis pass, skip it—there’s partial frequency data from what can be parsed
       if (!options.continueOnParseError) {
         throw err;
       }
@@ -3749,9 +3771,9 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
     // 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.
+    // For frequency analysis, remove custom fragments temporarily
+    // because HTML comments in opening tags prevent proper attribute parsing;
+    // removed with a space to preserve attribute boundaries
     let scanValue = firstPassOutput;
     if (customFragmentPattern) {
       scanValue = firstPassOutput.replace(customFragmentPattern, ' ');
@@ -3893,8 +3915,8 @@ async function minifyHTML(value, options, partialMarkup) {
     removeEmptyElementsExcept = parseRemoveEmptyElementsExcept(options.removeEmptyElementsExcept, options) || [];
   }
 
-  // Temporarily replace ignored chunks with comments, so that we don’t have to worry what’s there;
-  // for all we care there might be completely-horribly-broken-alien-non-html-emoji-cthulhu-filled content
+  // Temporarily replace ignored chunks with comments, so that there’s no need to worry what’s there;
+  // there might be completely-horribly-broken-alien-non-html-emoji-cthulhu-filled content
   if (value.indexOf('<!-- htmlmin:ignore -->') !== -1) {
     // Use `indexOf`-based O(n) loop instead of a global regex with [\s\S]*? to avoid O(n²)
     // backtracking on adversarial HTML with many `<!--` prefixes but no closing marker
@@ -4327,11 +4349,16 @@ async function minifyHTML(value, options, partialMarkup) {
         }
         if (options.collapseWhitespace) {
           if (!stackNoTrimWhitespace.length) {
+            // When the prev item is a UID placeholder, compute its effective tag name for whitespace decisions;
+            // this is only used in `collapseWhitespaceSmart`—`prevTag` itself is not modified,
+            // to avoid side effects on the `inlineTextSet` branch below
+            let effectivePrevTag = prevTag;
             if (prevTag === 'comment') {
               const prevComment = buffer[buffer.length - 1];
               if (!uidIgnore || prevComment.indexOf(uidIgnore) === -1) {
                 if (!prevComment) {
                   prevTag = charsPrevTag;
+                  effectivePrevTag = prevTag;
                 }
                 if (buffer.length > 1 && (!prevComment || (!options.conservativeCollapse && / $/.test(currentChars)))) {
                   const charsIndex = buffer.length - 2;
@@ -4340,6 +4367,23 @@ async function minifyHTML(value, options, partialMarkup) {
                     return '';
                   });
                 }
+              } else if (uidIgnorePlaceholderPattern && nextTag !== 'comment') {
+                // UID placeholder followed by a real element—derive the effective `prevTag` from the
+                // placeholder’s last HTML tag so `collapseWhitespaceSmart` can make the right call;
+                // when `nextTag` is `comment` (another UID placeholder), `commentFinalize` handles it
+                const match = prevComment.match(uidIgnorePlaceholderPattern);
+                if (match) {
+                  const idx = +match[1];
+                  if (idx < ignoredMarkupChunks.length) {
+                    const content = ignoredMarkupChunks[idx];
+                    const lastTagMatch = content && RE_LAST_HTML_TAG.exec(content);
+                    if (lastTagMatch) {
+                      const isClose = lastTagMatch[1].charAt(0) === '/';
+                      const tagName = options.name(isClose ? lastTagMatch[1].slice(1) : lastTagMatch[1]);
+                      effectivePrevTag = isClose ? '/' + tagName : tagName;
+                    }
+                  }
+                }
               }
             }
             if (prevTag) {
@@ -4356,7 +4400,7 @@ async function minifyHTML(value, options, partialMarkup) {
               }
             }
             if (prevTag || nextTag) {
-              text = collapseWhitespaceSmart(text, prevTag, nextTag, prevAttrs, nextAttrs, options, inlineElements, inlineTextSet);
+              text = collapseWhitespaceSmart(text, effectivePrevTag, nextTag, prevAttrs, nextAttrs, options, inlineElements, inlineTextSet);
             } else {
               text = collapseWhitespace(text, options, true, true);
             }
@@ -4479,21 +4523,26 @@ async function minifyHTML(value, options, partialMarkup) {
 
                     // Only collapse whitespace if both blocks contain HTML (start with `<`)
                     // Don’t collapse if either contains plain text, as that would change meaning
-                    // Note: This check will match HTML comments (`<!-- … -->`), but the tag name
-                    // regex below requires starting with a letter, so comments are intentionally
-                    // excluded by the `currentTagMatch && prevTagMatch` guard
                     if (currentContent && prevContent && /^\s*</.test(currentContent) && /^\s*</.test(prevContent)) {
-                      // Extract tag names from the HTML content (excludes comments, processing instructions, etc.)
+                      // Extract tag names from the HTML content
                       const currentTagMatch = currentContent.match(/^\s*<([a-zA-Z][\w:-]*)/);
                       const prevTagMatch = prevContent.match(/^\s*<([a-zA-Z][\w:-]*)/);
-
-                      // Only collapse if both matched valid element tags (not comments/text)
-                      // and both tags are block-level (inline elements need whitespace preserved)
-                      if (currentTagMatch && prevTagMatch) {
-                        const currentTag = options.name(currentTagMatch[1]);
-                        const prevTag = options.name(prevTagMatch[1]);
-
-                        // Don’t collapse between inline elements
+                      // HTML comments are invisible (no block/inline nature), treat as non-inline
+                      const prevIsHtmlComment = !prevTagMatch && RE_HTML_COMMENT_START.test(prevContent);
+                      const currentIsHtmlComment = !currentTagMatch && RE_HTML_COMMENT_START.test(currentContent);
+                      // Closing tags (e.g., `</div>`)—inline-ness determines whether to collapse
+                      const prevClosingTagMatch = !prevTagMatch && RE_CLOSING_TAG_START.exec(prevContent);
+                      const currentClosingTagMatch = !currentTagMatch && RE_CLOSING_TAG_START.exec(currentContent);
+
+                      // Collapse if both sides are element/closing tags or HTML comments, and neither is inline
+                      if ((currentTagMatch || currentIsHtmlComment || currentClosingTagMatch) &&
+                          (prevTagMatch || prevIsHtmlComment || prevClosingTagMatch)) {
+                        const currentTag = currentTagMatch ? options.name(currentTagMatch[1])
+                          : currentClosingTagMatch ? options.name(currentClosingTagMatch[1]) : null;
+                        const prevTag = prevTagMatch ? options.name(prevTagMatch[1])
+                          : prevClosingTagMatch ? options.name(prevClosingTagMatch[1]) : null;
+
+                        // Don’t collapse between inline elements (HTML comments count as non-inline)
                         if (!inlineElements.has(currentTag) && !inlineElements.has(prevTag)) {
                           // Collapse whitespace respecting context rules
                           let collapsedText = prevText;

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

@@ -1 +1 @@
-{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"AA2uDO,8BAJI,MAAM,YACN,eAAe,GACb,OAAO,CAAC,MAAM,CAAC,CAwB3B;;;;;;;;;;;;UAh+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;;;;;;;;;;;;;;;;;wBAjqBK,cAAc;0BAAd,cAAc;+BAAd,cAAc"}
+{"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"}

package/dist/types/lib/attributes.d.ts

@@ -24,7 +24,7 @@ export function buildAttr(normalized: any, hasUnarySlash: any, options: any, isL
 /**
  * Remove duplicate attributes from an attribute list.
  * Per HTML spec, when an attribute appears multiple times, the first occurrence wins.
- * Duplicate attributes result in invalid HTML, so we keep only the first.
+ * Duplicate attributes result in invalid HTML, so only the first is kept.
  * @param {Array} attrs - Array of attribute objects with `name` property
  * @param {boolean} caseSensitive - Whether to compare names case-sensitively (for XML/SVG)
  * @returns {Array} Deduplicated attribute array (modifies in place and returns)

package/dist/types/lib/attributes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../src/lib/attributes.js"],"names":[],"mappings":"AAmCA,mEAOC;AAED,uEAWC;AAED,8DAGC;AAED,4EAOC;AAgCD,mGAuCC;AAED,mEAGC;AAED,qEAGC;AAED,kEAWC;AAED,sEAGC;AAED,8DAWC;AAED,2EAIC;AAmBD,qEAGC;AAgBD,wEAGC;AAED,sEAUC;AAED,2EAEC;AAED,2DAEC;AAED,8DAUC;AAED,uEAUC;AAED,oGASC;AAED,4DAOC;AAUD,iIA4KC;AAwBD,mGAYC;AA0CD,6GAuHC;AAxlBD;;;;;;;GAOG;AACH,mEAHW,OAAO,SAuBjB"}
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../src/lib/attributes.js"],"names":[],"mappings":"AAmCA,mEAOC;AAED,uEAWC;AAED,8DAGC;AAED,4EAOC;AAgCD,mGAuCC;AAED,mEAGC;AAED,qEAGC;AAED,kEAWC;AAED,sEAGC;AAED,8DAWC;AAED,2EAIC;AAmBD,qEAGC;AAgBD,wEAGC;AAED,sEAUC;AAED,2EAEC;AAED,2DAEC;AAED,8DAUC;AAED,uEAUC;AAED,oGASC;AAED,4DAOC;AAUD,iIA6LC;AAwBD,mGAYC;AA0CD,6GAuHC;AAzmBD;;;;;;;GAOG;AACH,mEAHW,OAAO,SAuBjB"}

package/package.json

@@ -5,25 +5,25 @@
   },
   "bugs": "https://github.com/j9t/html-minifier-next/issues",
   "dependencies": {
-    "commander": "^14.0.2",
+    "commander": "^14.0.3",
     "entities": "^8.0.0",
     "lightningcss": "^1.32.0",
     "svgo": "^4.0.1",
-    "terser": "^5.46.1"
+    "terser": "^5.46.2"
   },
   "description": "Super-configurable and well-tested web page minifier (enhanced successor of HTML Minifier)",
   "devDependencies": {
-    "@commitlint/cli": "^20.5.0",
+    "@commitlint/cli": "^20.5.3",
     "@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.30",
-    "eslint": "^10.2.0",
+    "@swc/core": "^1.15.33",
+    "eslint": "^10.3.0",
     "rollup": "^4.60.2",
     "rollup-plugin-polyfill-node": "^0.13.0",
     "typescript": "^6.0.3",
-    "vite": "^8.0.8"
+    "vite": "^8.0.10"
   },
   "exports": {
     ".": {
@@ -96,5 +96,5 @@
   },
   "type": "module",
   "types": "./dist/types/htmlminifier.d.ts",
-  "version": "6.2.2"
+  "version": "6.2.4"
 }

package/src/htmlminifier.js

@@ -121,6 +121,11 @@ const DEFAULT_JS_TYPES = new Set(['', 'text/javascript', 'application/javascript
 const RE_START_TAG = /^<[^/!]/;
 const RE_END_TAG = /^<\//;
 
+// Pre-compiled patterns for `htmlmin:ignore` block content analysis
+const RE_HTML_COMMENT_START = /^\s*<!--/;
+const RE_CLOSING_TAG_START = /^\s*<\/([a-zA-Z][\w:-]*)/;
+const RE_LAST_HTML_TAG = /[\s\S]*<(\/?[a-zA-Z][\w:-]*)/;
+
 // HTML encoding types for annotation-xml (MathML)
 const RE_HTML_ENCODING = /^(text\/html|application\/xhtml\+xml)$/i;
 
@@ -759,7 +764,7 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
           await scan(text);
         }
       },
-      // We never need `nextTag` information in this scan
+      // No need for `nextTag` information in this scan
       wantsNextTag: false,
       // Continue on parse errors during analysis pass
       continueOnParseError: options.continueOnParseError
@@ -768,7 +773,7 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
     try {
       await parser.parse();
     } catch (err) {
-      // If parsing fails during analysis pass, just skip it—we’ll still have partial frequency data from what we could parse
+      // If parsing fails during analysis pass, skip it—there’s partial frequency data from what can be parsed
       if (!options.continueOnParseError) {
         throw err;
       }
@@ -823,9 +828,9 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
     // 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.
+    // For frequency analysis, remove custom fragments temporarily
+    // because HTML comments in opening tags prevent proper attribute parsing;
+    // removed with a space to preserve attribute boundaries
     let scanValue = firstPassOutput;
     if (customFragmentPattern) {
       scanValue = firstPassOutput.replace(customFragmentPattern, ' ');
@@ -967,8 +972,8 @@ async function minifyHTML(value, options, partialMarkup) {
     removeEmptyElementsExcept = parseRemoveEmptyElementsExcept(options.removeEmptyElementsExcept, options) || [];
   }
 
-  // Temporarily replace ignored chunks with comments, so that we don’t have to worry what’s there;
-  // for all we care there might be completely-horribly-broken-alien-non-html-emoji-cthulhu-filled content
+  // Temporarily replace ignored chunks with comments, so that there’s no need to worry what’s there;
+  // there might be completely-horribly-broken-alien-non-html-emoji-cthulhu-filled content
   if (value.indexOf('<!-- htmlmin:ignore -->') !== -1) {
     // Use `indexOf`-based O(n) loop instead of a global regex with [\s\S]*? to avoid O(n²)
     // backtracking on adversarial HTML with many `<!--` prefixes but no closing marker
@@ -1401,11 +1406,16 @@ async function minifyHTML(value, options, partialMarkup) {
         }
         if (options.collapseWhitespace) {
           if (!stackNoTrimWhitespace.length) {
+            // When the prev item is a UID placeholder, compute its effective tag name for whitespace decisions;
+            // this is only used in `collapseWhitespaceSmart`—`prevTag` itself is not modified,
+            // to avoid side effects on the `inlineTextSet` branch below
+            let effectivePrevTag = prevTag;
             if (prevTag === 'comment') {
               const prevComment = buffer[buffer.length - 1];
               if (!uidIgnore || prevComment.indexOf(uidIgnore) === -1) {
                 if (!prevComment) {
                   prevTag = charsPrevTag;
+                  effectivePrevTag = prevTag;
                 }
                 if (buffer.length > 1 && (!prevComment || (!options.conservativeCollapse && / $/.test(currentChars)))) {
                   const charsIndex = buffer.length - 2;
@@ -1414,6 +1424,23 @@ async function minifyHTML(value, options, partialMarkup) {
                     return '';
                   });
                 }
+              } else if (uidIgnorePlaceholderPattern && nextTag !== 'comment') {
+                // UID placeholder followed by a real element—derive the effective `prevTag` from the
+                // placeholder’s last HTML tag so `collapseWhitespaceSmart` can make the right call;
+                // when `nextTag` is `comment` (another UID placeholder), `commentFinalize` handles it
+                const match = prevComment.match(uidIgnorePlaceholderPattern);
+                if (match) {
+                  const idx = +match[1];
+                  if (idx < ignoredMarkupChunks.length) {
+                    const content = ignoredMarkupChunks[idx];
+                    const lastTagMatch = content && RE_LAST_HTML_TAG.exec(content);
+                    if (lastTagMatch) {
+                      const isClose = lastTagMatch[1].charAt(0) === '/';
+                      const tagName = options.name(isClose ? lastTagMatch[1].slice(1) : lastTagMatch[1]);
+                      effectivePrevTag = isClose ? '/' + tagName : tagName;
+                    }
+                  }
+                }
               }
             }
             if (prevTag) {
@@ -1430,7 +1457,7 @@ async function minifyHTML(value, options, partialMarkup) {
               }
             }
             if (prevTag || nextTag) {
-              text = collapseWhitespaceSmart(text, prevTag, nextTag, prevAttrs, nextAttrs, options, inlineElements, inlineTextSet);
+              text = collapseWhitespaceSmart(text, effectivePrevTag, nextTag, prevAttrs, nextAttrs, options, inlineElements, inlineTextSet);
             } else {
               text = collapseWhitespace(text, options, true, true);
             }
@@ -1553,21 +1580,26 @@ async function minifyHTML(value, options, partialMarkup) {
 
                     // Only collapse whitespace if both blocks contain HTML (start with `<`)
                     // Don’t collapse if either contains plain text, as that would change meaning
-                    // Note: This check will match HTML comments (`<!-- … -->`), but the tag name
-                    // regex below requires starting with a letter, so comments are intentionally
-                    // excluded by the `currentTagMatch && prevTagMatch` guard
                     if (currentContent && prevContent && /^\s*</.test(currentContent) && /^\s*</.test(prevContent)) {
-                      // Extract tag names from the HTML content (excludes comments, processing instructions, etc.)
+                      // Extract tag names from the HTML content
                       const currentTagMatch = currentContent.match(/^\s*<([a-zA-Z][\w:-]*)/);
                       const prevTagMatch = prevContent.match(/^\s*<([a-zA-Z][\w:-]*)/);
-
-                      // Only collapse if both matched valid element tags (not comments/text)
-                      // and both tags are block-level (inline elements need whitespace preserved)
-                      if (currentTagMatch && prevTagMatch) {
-                        const currentTag = options.name(currentTagMatch[1]);
-                        const prevTag = options.name(prevTagMatch[1]);
-
-                        // Don’t collapse between inline elements
+                      // HTML comments are invisible (no block/inline nature), treat as non-inline
+                      const prevIsHtmlComment = !prevTagMatch && RE_HTML_COMMENT_START.test(prevContent);
+                      const currentIsHtmlComment = !currentTagMatch && RE_HTML_COMMENT_START.test(currentContent);
+                      // Closing tags (e.g., `</div>`)—inline-ness determines whether to collapse
+                      const prevClosingTagMatch = !prevTagMatch && RE_CLOSING_TAG_START.exec(prevContent);
+                      const currentClosingTagMatch = !currentTagMatch && RE_CLOSING_TAG_START.exec(currentContent);
+
+                      // Collapse if both sides are element/closing tags or HTML comments, and neither is inline
+                      if ((currentTagMatch || currentIsHtmlComment || currentClosingTagMatch) &&
+                          (prevTagMatch || prevIsHtmlComment || prevClosingTagMatch)) {
+                        const currentTag = currentTagMatch ? options.name(currentTagMatch[1])
+                          : currentClosingTagMatch ? options.name(currentClosingTagMatch[1]) : null;
+                        const prevTag = prevTagMatch ? options.name(prevTagMatch[1])
+                          : prevClosingTagMatch ? options.name(prevClosingTagMatch[1]) : null;
+
+                        // Don’t collapse between inline elements (HTML comments count as non-inline)
                         if (!inlineElements.has(currentTag) && !inlineElements.has(prevTag)) {
                           // Collapse whitespace respecting context rules
                           let collapsedText = prevText;

package/src/htmlparser.js

@@ -218,12 +218,12 @@ export class HTMLParser {
     while (pos < fullLength) {
       lastPos = pos;
 
-      // Make sure we’re not in a `script` or `style` element
+      // Make sure not to be in a `script` or `style` element
       if (!lastTag || !special.has(lastTag)) {
         const textEnd = fullHtml.indexOf('<', pos);
 
         if (textEnd === pos) {
-          // We found a tag at current position
+          // Tag found at current position
 
           // Check cache from previous lookahead (avoids re-parsing the same tag)
           if (cachedNextStartTag && cachedNextStartTag.pos === pos) {
@@ -459,7 +459,7 @@ export class HTMLParser {
             break;
           }
 
-          // Limit the input length we pass to the regex to prevent catastrophic backtracking
+          // Limit the input length to pass to the regex to prevent catastrophic backtracking
           const remainingLen = fullLength - currentPos;
           const isLimited = remainingLen > MAX_ATTR_PARSE_LENGTH;
 
@@ -474,7 +474,7 @@ export class HTMLParser {
             const searchStr = fullHtml.substring(currentPos, extractEndPos);
             attr = searchStr.match(attribute);
 
-            // If we limited the input and got a match, check if the value might be truncated
+            // If input was limited and there’s a match, check if the value might be truncated
             if (attr) {
               // Check if the attribute value extends beyond our search window
               const attrEnd = attr[0].length;
@@ -532,7 +532,7 @@ export class HTMLParser {
             }
 
             if (!attr) {
-              // If we limited the input and got no match, try manual extraction
+              // If input was limited and there’s no match, try manual extraction
               // This handles cases where quoted attributes exceed `MAX_ATTR_PARSE_LENGTH`
               const manualMatch = searchStr.match(/^\s*([^\s"'<>/=]+)\s*=\s*/);
               if (manualMatch) {
@@ -598,7 +598,7 @@ export class HTMLParser {
         if (currentTag === needle) {
           return pos;
         }
-        // Stop searching if we hit a table boundary
+        // Stop searching if hitting a table boundary
         if (currentTag === 'table') {
           break;
         }

package/src/lib/attributes.js

@@ -19,9 +19,9 @@ import {
 } from './constants.js';
 import { trimWhitespace, collapseWhitespaceAll } from './whitespace.js';
 import { shouldMinifyInnerHTML } from './options.js';
-import { isThenable } from './utils.js';
+import { identity, isThenable } from './utils.js';
 
-// Lazy-load entities only when `decodeEntities` is enabled
+// Lazy-load entities (used for `decodeEntities` and event-handler attribute decode before `minifyJS`)
 
 let decodeHTMLStrictPromise;
 async function getDecodeHTMLStrict() {
@@ -72,7 +72,7 @@ function attributesInclude(attributes, attribute) {
 /**
  * Remove duplicate attributes from an attribute list.
  * Per HTML spec, when an attribute appears multiple times, the first occurrence wins.
- * Duplicate attributes result in invalid HTML, so we keep only the first.
+ * Duplicate attributes result in invalid HTML, so only the first is kept.
  * @param {Array} attrs - Array of attribute objects with `name` property
  * @param {boolean} caseSensitive - Whether to compare names case-sensitively (for XML/SVG)
  * @returns {Array} Deduplicated attribute array (modifies in place and returns)
@@ -117,7 +117,7 @@ function isAttributeRedundant(tag, attrName, attrValue, attrs) {
     return false;
   }
 
-  // Now we know we need to check the value, so normalize it
+  // Value needs to be checked, so normalize it
   attrValue = attrValue ? trimWhitespace(attrValue.toLowerCase()) : '';
 
   // Legacy attribute checks
@@ -317,6 +317,23 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTM
 
   if (isEventAttr) {
     attrValue = trimWhitespace(attrValue).replace(/^javascript:\s*/i, '');
+    // Browsers decode attribute values before running event-handler JS—
+    // decode first so the minifier gets valid JavaScript
+    if (!options.decodeEntities && options.minifyJS !== identity && attrValue.indexOf('&') !== -1) {
+      return getDecodeHTMLStrict().then(decode => {
+        const decoded = decode(attrValue);
+        const result = options.minifyJS(decoded, true);
+        const reEncode = v => (v && v.indexOf('&') !== -1) ? v.replace(RE_AMP_ENTITY, '&$1') : v;
+        if (isThenable(result)) {
+          return result.then(reEncode, err => {
+            if (!options.continueOnMinifyError) throw err;
+            options.log && options.log(err);
+            return attrValue;
+          });
+        }
+        return reEncode(result);
+      });
+    }
     const result = options.minifyJS(attrValue, true);
     if (isThenable(result)) {
       return result.catch(err => {
@@ -558,7 +575,7 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
   let attrFragment;
   let emittedAttrValue;
 
-  // Determine if we need to add/keep quotes
+  // Determine if need to add/keep quotes
   const shouldAddQuotes = typeof attrValue !== 'undefined' && (
     // If `removeAttributeQuotes` is enabled, add quotes only if they can’t be removed
     (options.removeAttributeQuotes && (attrValue.indexOf(uidAttr) !== -1 || !canRemoveAttributeQuotes(attrValue))) ||
@@ -573,7 +590,7 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
     // Determine the appropriate quote character
     if (!options.preventAttributesEscaping) {
       // Normal mode: Choose optimal quote type to minimize escaping
-      // unless we’re preserving original quotes and they don’t need escaping
+      // unless preserving original quotes and they don’t need escaping
       const needsEscaping = (attrQuote === '"' && attrValue.indexOf('"') !== -1) || (attrQuote === "'" && attrValue.indexOf("'") !== -1);
 
       if (options.removeAttributeQuotes || typeof options.quoteCharacter !== 'undefined' || needsEscaping || attrQuote === '') {