html-minifier-next 6.2.3 → 6.2.5

package/cli.js

@@ -60,10 +60,10 @@ const pkg = require('./package.json');
 
 const DEFAULT_FILE_EXTENSIONS = ['html', 'htm', 'shtml', 'shtm'];
 
-const MARK_ERROR   = process.stderr.isTTY ? '\x1b[31m' : '';
+const MARK_ERROR = process.stderr.isTTY ? '\x1b[31m' : '';
 const MARK_SUCCESS = process.stderr.isTTY ? '\x1b[32m' : '';
 const MARK_WARNING = process.stderr.isTTY ? '\x1b[33m' : '';
-const MARK_RESET   = process.stderr.isTTY ? '\x1b[0m'  : '';
+const MARK_RESET = process.stderr.isTTY ? '\x1b[0m' : '';
 
 const program = new Command();
 program.name(pkg.name);
@@ -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;
         }
@@ -1028,7 +1028,6 @@ const presets = {
     collapseAttributeWhitespace: true,
     collapseBooleanAttributes: true,
     collapseWhitespace: true,
-    continueOnParseError: true,
     decodeEntities: true,
     mergeScripts: true,
     minifyCSS: true,
@@ -2154,7 +2153,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 +2198,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
@@ -2657,7 +2656,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))) ||
@@ -2672,7 +2671,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 === '') {
@@ -3064,6 +3063,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;
 
@@ -3702,7 +3706,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
@@ -3711,7 +3715,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;
       }
@@ -3766,9 +3770,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, ' ');
@@ -3910,8 +3914,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
@@ -4344,11 +4348,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;
@@ -4357,6 +4366,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) {
@@ -4373,7 +4399,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);
             }
@@ -4496,21 +4522,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/presets.d.ts

@@ -27,7 +27,6 @@ export namespace presets {
         export { collapseBooleanAttributes_1 as collapseBooleanAttributes };
         let collapseWhitespace_1: boolean;
         export { collapseWhitespace_1 as collapseWhitespace };
-        export let continueOnParseError: boolean;
         export let decodeEntities: boolean;
         export let mergeScripts: boolean;
         export let minifyCSS: boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/presets.js"],"names":[],"mappings":"AA0CA;;;;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":"AAyCA;;;;GAIG;AACH,gCAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAMvB;AAED;;;GAGG;AACH,kCAFa,MAAM,EAAE,CAIpB"}

package/package.json

@@ -18,7 +18,7 @@
     "@rollup/plugin-commonjs": "^29.0.2",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
-    "@swc/core": "^1.15.32",
+    "@swc/core": "^1.15.33",
     "eslint": "^10.3.0",
     "rollup": "^4.60.2",
     "rollup-plugin-polyfill-node": "^0.13.0",
@@ -96,5 +96,5 @@
   },
   "type": "module",
   "types": "./dist/types/htmlminifier.d.ts",
-  "version": "6.2.3"
+  "version": "6.2.5"
 }

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

@@ -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
@@ -575,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))) ||
@@ -590,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 === '') {

package/src/presets.js

@@ -22,7 +22,6 @@ export const presets = {
     collapseAttributeWhitespace: true,
     collapseBooleanAttributes: true,
     collapseWhitespace: true,
-    continueOnParseError: true,
     decodeEntities: true,
     mergeScripts: true,
     minifyCSS: true,