html-minifier-next 4.16.3 → 4.17.0

package/dist/htmlminifier.cjs

@@ -5,7 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var entities = require('entities');
 var RelateURL = require('relateurl');
 
-/*!
+/*
  * HTML Parser By John Resig (ejohn.org)
  * Modified by Juriy “kangax” Zaytsev
  * Original code by Erik Arvidsson, Mozilla Public License
@@ -16,10 +16,10 @@ var RelateURL = require('relateurl');
  * Use like so:
  *
  * HTMLParser(htmlString, {
- *     start: function(tag, attrs, unary) {},
- *     end: function(tag) {},
- *     chars: function(text) {},
- *     comment: function(text) {}
+ *   start: function(tag, attrs, unary) {},
+ *   end: function(tag) {},
+ *   chars: function(text) {},
+ *   comment: function(text) {}
  * });
  */
 
@@ -42,7 +42,7 @@ const singleAttrValues = [
 ];
 // https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName
 const qnameCapture = (function () {
-  // based on https://www.npmjs.com/package/ncname
+  // https://www.npmjs.com/package/ncname
   const combiningChar = '\\u0300-\\u0345\\u0360\\u0361\\u0483-\\u0486\\u0591-\\u05A1\\u05A3-\\u05B9\\u05BB-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u064B-\\u0652\\u0670\\u06D6-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0901-\\u0903\\u093C\\u093E-\\u094D\\u0951-\\u0954\\u0962\\u0963\\u0981-\\u0983\\u09BC\\u09BE-\\u09C4\\u09C7\\u09C8\\u09CB-\\u09CD\\u09D7\\u09E2\\u09E3\\u0A02\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A70\\u0A71\\u0A81-\\u0A83\\u0ABC\\u0ABE-\\u0AC5\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD\\u0B01-\\u0B03\\u0B3C\\u0B3E-\\u0B43\\u0B47\\u0B48\\u0B4B-\\u0B4D\\u0B56\\u0B57\\u0B82\\u0B83\\u0BBE-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCD\\u0BD7\\u0C01-\\u0C03\\u0C3E-\\u0C44\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C82\\u0C83\\u0CBE-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6\\u0D02\\u0D03\\u0D3E-\\u0D43\\u0D46-\\u0D48\\u0D4A-\\u0D4D\\u0D57\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F3E\\u0F3F\\u0F71-\\u0F84\\u0F86-\\u0F8B\\u0F90-\\u0F95\\u0F97\\u0F99-\\u0FAD\\u0FB1-\\u0FB7\\u0FB9\\u20D0-\\u20DC\\u20E1\\u302A-\\u302F\\u3099\\u309A';
   const digit = '0-9\\u0660-\\u0669\\u06F0-\\u06F9\\u0966-\\u096F\\u09E6-\\u09EF\\u0A66-\\u0A6F\\u0AE6-\\u0AEF\\u0B66-\\u0B6F\\u0BE7-\\u0BEF\\u0C66-\\u0C6F\\u0CE6-\\u0CEF\\u0D66-\\u0D6F\\u0E50-\\u0E59\\u0ED0-\\u0ED9\\u0F20-\\u0F29';
   const extender = '\\xB7\\u02D0\\u02D1\\u0387\\u0640\\u0E46\\u0EC6\\u3005\\u3031-\\u3035\\u309D\\u309E\\u30FC-\\u30FE';
@@ -82,7 +82,7 @@ const nonPhrasing = new CaseInsensitiveSet(['address', 'article', 'aside', 'base
 const reCache = {};
 
 // Pre-compiled regexes for common special elements (`script`, `style`, `noscript`)
-// These are used frequently and pre-compiling them avoids regex creation overhead
+// These are used frequently, and pre-compiling them avoids regex creation overhead
 const preCompiledStackedTags = {
   'script': /([\s\S]*?)<\/script[^>]*>/i,
   'style': /([\s\S]*?)<\/style[^>]*>/i,
@@ -145,6 +145,7 @@ class HTMLParser {
     // Use cached attribute regex for this handler configuration
     const attribute = getAttrRegexForHandler(handler);
     let prevTag = undefined, nextTag = undefined;
+    let prevAttrs = [], nextAttrs = [];
 
     // Index-based parsing
     let pos = 0;
@@ -188,6 +189,7 @@ class HTMLParser {
               }
               advance(commentEnd + 3);
               prevTag = '';
+              prevAttrs = [];
               continue;
             }
           }
@@ -202,6 +204,7 @@ class HTMLParser {
               }
               advance(conditionalEnd + 2);
               prevTag = '';
+              prevAttrs = [];
               continue;
             }
           }
@@ -214,6 +217,7 @@ class HTMLParser {
             }
             advance(doctypeMatch[0].length);
             prevTag = '';
+            prevAttrs = [];
             continue;
           }
 
@@ -223,6 +227,7 @@ class HTMLParser {
             advance(endTagMatch[0].length);
             await parseEndTag(endTagMatch[0], endTagMatch[1]);
             prevTag = '/' + endTagMatch[1].toLowerCase();
+            prevAttrs = [];
             continue;
           }
 
@@ -255,19 +260,24 @@ class HTMLParser {
         let nextTagMatch = parseStartTag(nextHtml);
         if (nextTagMatch) {
           nextTag = nextTagMatch.tagName;
+          // Extract minimal attribute info for whitespace logic (just name/value pairs)
+          nextAttrs = extractAttrInfo(nextTagMatch.attrs);
         } else {
           nextTagMatch = nextHtml.match(endTag);
           if (nextTagMatch) {
             nextTag = '/' + nextTagMatch[1];
+            nextAttrs = [];
           } else {
             nextTag = '';
+            nextAttrs = [];
           }
         }
 
         if (handler.chars) {
-          await handler.chars(text, prevTag, nextTag);
+          await handler.chars(text, prevTag, nextTag, prevAttrs, nextAttrs);
         }
         prevTag = '';
+        prevAttrs = [];
       } else {
         const stackedTag = lastTag.toLowerCase();
         // Use pre-compiled regex for common tags (`script`, `style`, `noscript`) to avoid regex creation overhead
@@ -290,7 +300,7 @@ class HTMLParser {
         } else {
           // No closing tag found; to avoid infinite loop, break similarly to previous behavior
           if (handler.continueOnParseError && handler.chars && html) {
-            await handler.chars(html[0], prevTag, '');
+            await handler.chars(html[0], prevTag, '', prevAttrs, []);
             advance(1);
           } else {
             break;
@@ -302,10 +312,11 @@ class HTMLParser {
         if (handler.continueOnParseError) {
           // Skip the problematic character and continue
           if (handler.chars) {
-            await handler.chars(fullHtml[pos], prevTag, '');
+            await handler.chars(fullHtml[pos], prevTag, '', prevAttrs, []);
           }
           advance(1);
           prevTag = '';
+          prevAttrs = [];
           continue;
         }
         const loc = getLineColumn(pos);
@@ -324,6 +335,23 @@ class HTMLParser {
       await parseEndTag();
     }
 
+    // Helper to extract minimal attribute info (name/value pairs) from raw attribute matches
+    // Used for whitespace collapsing logic—doesn’t need full processing
+    function extractAttrInfo(rawAttrs) {
+      if (!rawAttrs || !rawAttrs.length) return [];
+
+      const numCustomParts = handler.customAttrSurround ? handler.customAttrSurround.length * NCP : 0;
+      const baseIndex = 1 + numCustomParts;
+
+      return rawAttrs.map(args => {
+        // Extract attribute name (always at `baseIndex`)
+        const name = args[baseIndex];
+        // Extract value from double-quoted (`baseIndex + 2`), single-quoted (`baseIndex + 3`), or unquoted (`baseIndex + 4`)
+        const value = args[baseIndex + 2] ?? args[baseIndex + 3] ?? args[baseIndex + 4];
+        return { name: name?.toLowerCase(), value };
+      }).filter(attr => attr.name); // Filter out invalid entries
+    }
+
     function parseStartTag(input) {
       const start = input.match(startTagOpen);
       if (start) {
@@ -336,7 +364,7 @@ class HTMLParser {
         input = input.slice(consumed);
         let end, attr;
 
-        // Safety limit: max length of input to check for attributes
+        // Safety limit: Max length of input to check for attributes
         // Protects against catastrophic backtracking on massive attribute values
         const MAX_ATTR_PARSE_LENGTH = 20000; // 20 KB should be enough for any reasonable tag
 
@@ -436,7 +464,7 @@ class HTMLParser {
     }
 
     async function parseEndTagAt(pos) {
-      // Close all open elements up to pos (mirrors parseEndTag’s core branch)
+      // Close all open elements up to `pos` (mirrors `parseEndTag`’s core branch)
       for (let i = stack.length - 1; i >= pos; i--) {
         if (handler.end) {
           await handler.end(stack[i].tag, stack[i].attrs, true);
@@ -504,7 +532,7 @@ class HTMLParser {
       const attrs = match.attrs.map(function (args) {
         let name, value, customOpen, customClose, customAssign, quote;
 
-        // Hackish workaround for FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778
+        // Hackish workaround for Firefox bug, https://bugzilla.mozilla.org/show_bug.cgi?id=369778
         if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('""') === -1) {
           if (args[3] === '') { delete args[3]; }
           if (args[4] === '') { delete args[4]; }
@@ -561,6 +589,9 @@ class HTMLParser {
         unarySlash = '';
       }
 
+      // Store attributes for `prevAttrs` tracking (used in whitespace collapsing)
+      prevAttrs = attrs;
+
       if (handler.start) {
         await handler.start(tagName, attrs, unary, unarySlash);
       }
@@ -656,7 +687,7 @@ class Sorter {
 
 class TokenChain {
   constructor() {
-    // Use Map instead of object properties for better performance
+    // Use map instead of object properties for better performance
     this.map = new Map();
   }
 
@@ -673,7 +704,7 @@ class TokenChain {
     const sorter = new Sorter();
     sorter.sorterMap = new Map();
 
-    // Convert Map entries to array and sort by frequency (descending) then alphabetically
+    // Convert map entries to array and sort by frequency (descending), then alphabetically
     const entries = Array.from(this.map.entries()).sort((a, b) => {
       const m = a[1].arrays.length;
       const n = b[1].arrays.length;
@@ -722,11 +753,11 @@ class TokenChain {
 }
 
 /**
- * Preset configurations for HTML Minifier Next
+ * Preset configurations
  *
  * Presets provide curated option sets for common use cases:
- * - conservative: Safe minification suitable for most projects
- * - comprehensive: Aggressive minification for maximum file size reduction
+ * - `conservative`: Safe minification suitable for most projects
+ * - `comprehensive`: Aggressive minification for maximum file size reduction
  */
 
 const presets = {
@@ -772,7 +803,7 @@ const presets = {
 
 /**
  * Get preset configuration by name
- * @param {string} name - Preset name ('conservative' or 'comprehensive')
+ * @param {string} name - Preset name (“conservative” or “comprehensive”)
  * @returns {object|null} Preset options object or null if not found
  */
 function getPreset(name) {
@@ -871,7 +902,7 @@ async function replaceAsync(str, regex, asyncFn) {
   return str.replace(regex, () => data.shift());
 }
 
-// RegExp patterns (to avoid repeated allocations in hot paths)
+// Regex patterns (to avoid repeated allocations in hot paths)
 
 const RE_WS_START = /^[ \n\r\t\f]+/;
 const RE_WS_END = /[ \n\r\t\f]+$/;
@@ -892,7 +923,7 @@ const RE_ATTR_WS_COLLAPSE = /[ \n\r\t\f]+/g;
 const RE_ATTR_WS_TRIM = /^[ \n\r\t\f]+|[ \n\r\t\f]+$/g;
 const RE_NUMERIC_VALUE = /-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/g;
 
-// Inline element Sets for whitespace handling
+// Inline element sets for whitespace handling
 
 // Non-empty elements that will maintain whitespace around them
 const inlineElementsToKeepWhitespaceAround = new Set(['a', 'abbr', 'acronym', 'b', 'bdi', 'bdo', 'big', 'button', 'cite', 'code', 'del', 'dfn', 'em', 'font', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'mark', 'math', 'meter', 'nobr', 'object', 'output', 'progress', 'q', 'rb', 'rp', 'rt', 'rtc', 'ruby', 's', 'samp', 'select', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'svg', 'textarea', 'time', 'tt', 'u', 'var', 'wbr']);
@@ -903,6 +934,9 @@ const inlineElementsToKeepWhitespaceWithin = new Set(['a', 'abbr', 'acronym', 'b
 // Elements that will always maintain whitespace around them
 const inlineElementsToKeepWhitespace = new Set(['comment', 'img', 'input', 'wbr']);
 
+// Form control elements (for conditional whitespace collapsing)
+const formControlElements = new Set(['input', 'button', 'select', 'textarea', 'output', 'meter', 'progress']);
+
 // Default attribute values
 
 // Default attribute values (could apply to any element)
@@ -942,14 +976,17 @@ const tagDefaults = {
 // Script MIME types
 
 // https://mathiasbynens.be/demo/javascript-mime-type
-// https://developer.mozilla.org/en/docs/Web/HTML/Element/script#attr-type
+// https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/script
 const executableScriptsMimetypes = new Set([
   'text/javascript',
+  'text/x-javascript',
   'text/ecmascript',
+  'text/x-ecmascript',
   'text/jscript',
   'application/javascript',
   'application/x-javascript',
   'application/ecmascript',
+  'application/x-ecmascript',
   'module'
 ]);
 
@@ -957,15 +994,15 @@ const keepScriptsMimetypes = new Set([
   'module'
 ]);
 
-// Boolean attribute Sets
+// Boolean attribute sets
 
 const isSimpleBoolean = new Set(['allowfullscreen', 'async', 'autofocus', 'autoplay', 'checked', 'compact', 'controls', 'declare', 'default', 'defaultchecked', 'defaultmuted', 'defaultselected', 'defer', 'disabled', 'enabled', 'formnovalidate', 'hidden', 'indeterminate', 'inert', 'ismap', 'itemscope', 'loop', 'multiple', 'muted', 'nohref', 'noresize', 'noshade', 'novalidate', 'nowrap', 'open', 'pauseonexit', 'readonly', 'required', 'reversed', 'scoped', 'seamless', 'selected', 'sortable', 'truespeed', 'typemustmatch', 'visible']);
 
 const isBooleanValue = new Set(['true', 'false']);
 
-// `srcset` tags
+// `srcset` elements
 
-const srcsetTags = new Set(['img', 'source']);
+const srcsetElements = new Set(['img', 'source']);
 
 // JSON script types
 
@@ -981,7 +1018,7 @@ const jsonScriptTypes = new Set([
   'speculationrules',
 ]);
 
-// Tag omission rules and element Sets
+// Tag omission rules and element sets
 
 // Tag omission rules from https://html.spec.whatwg.org/multipage/syntax.html#optional-tags with the following extensions:
 // - retain `<body>` if followed by `<noscript>`
@@ -992,35 +1029,35 @@ const optionalStartTags = new Set(['html', 'head', 'body', 'colgroup', 'tbody'])
 
 const optionalEndTags = new Set(['html', 'head', 'body', 'li', 'dt', 'dd', 'p', 'rb', 'rt', 'rtc', 'rp', 'optgroup', 'option', 'colgroup', 'caption', 'thead', 'tbody', 'tfoot', 'tr', 'td', 'th']);
 
-const headerTags = new Set(['meta', 'link', 'script', 'style', 'template', 'noscript']);
+const headerElements = new Set(['meta', 'link', 'script', 'style', 'template', 'noscript']);
 
-const descriptionTags = new Set(['dt', 'dd']);
+const descriptionElements = new Set(['dt', 'dd']);
 
-const pBlockTags = new Set(['address', 'article', 'aside', 'blockquote', 'details', 'dialog', 'div', 'dl', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hgroup', 'hr', 'main', 'menu', 'nav', 'ol', 'p', 'pre', 'search', 'section', 'table', 'ul']);
+const pBlockElements = new Set(['address', 'article', 'aside', 'blockquote', 'details', 'dialog', 'div', 'dl', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hgroup', 'hr', 'main', 'menu', 'nav', 'ol', 'p', 'pre', 'search', 'section', 'table', 'ul']);
 
-const pInlineTags = new Set(['a', 'audio', 'del', 'ins', 'map', 'noscript', 'video']);
+const pInlineElements = new Set(['a', 'audio', 'del', 'ins', 'map', 'noscript', 'video']);
 
 const rubyEndTagOmission = new Set(['rb', 'rt', 'rtc', 'rp']); // `</rb>`, `</rt>`, `</rp>` can be omitted if followed by `<rb>`, `<rt>`, `<rtc>`, or `<rp>`
 
 const rubyRtcEndTagOmission = new Set(['rb', 'rtc']); // `</rtc>` can be omitted if followed by `<rb>` or `<rtc>` (not `<rt>` or `<rp>`)
 
-const optionTag = new Set(['option', 'optgroup']);
+const optionElements = new Set(['option', 'optgroup']);
 
-const tableContentTags = new Set(['tbody', 'tfoot']);
+const tableContentElements = new Set(['tbody', 'tfoot']);
 
-const tableSectionTags = new Set(['thead', 'tbody', 'tfoot']);
+const tableSectionElements = new Set(['thead', 'tbody', 'tfoot']);
 
-const cellTags = new Set(['td', 'th']);
+const cellElements = new Set(['td', 'th']);
 
-const topLevelTags = new Set(['html', 'head', 'body']);
+const topLevelElements = new Set(['html', 'head', 'body']);
 
-const compactTags = new Set(['html', 'body']);
+const compactElements = new Set(['html', 'body']);
 
-const looseTags = new Set(['head', 'colgroup', 'caption']);
+const looseElements = new Set(['head', 'colgroup', 'caption']);
 
-const trailingTags = new Set(['dt', 'thead']);
+const trailingElements = new Set(['dt', 'thead']);
 
-const htmlTags = new Set(['a', 'abbr', 'acronym', 'address', 'applet', 'area', 'article', 'aside', 'audio', 'b', 'base', 'basefont', 'bdi', 'bdo', 'bgsound', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'command', 'content', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'image', 'img', 'input', 'ins', 'isindex', 'kbd', 'keygen', 'label', 'legend', 'li', 'link', 'listing', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meta', 'meter', 'multicol', 'nav', 'nobr', 'noembed', 'noframes', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'plaintext', 'pre', 'progress', 'q', 'rb', 'rp', 'rt', 'rtc', 'ruby', 's', 'samp', 'script', 'search', 'section', 'select', 'selectedcontent', 'shadow', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr', 'xmp']);
+const htmlElements = new Set(['a', 'abbr', 'acronym', 'address', 'applet', 'area', 'article', 'aside', 'audio', 'b', 'base', 'basefont', 'bdi', 'bdo', 'bgsound', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'command', 'content', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'image', 'img', 'input', 'ins', 'isindex', 'kbd', 'keygen', 'label', 'legend', 'li', 'link', 'listing', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meta', 'meter', 'multicol', 'nav', 'nobr', 'noembed', 'noframes', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'plaintext', 'pre', 'progress', 'q', 'rb', 'rp', 'rt', 'rtc', 'ruby', 's', 'samp', 'script', 'search', 'section', 'select', 'selectedcontent', 'shadow', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr', 'xmp']);
 
 // Empty attribute regex
 
@@ -1030,7 +1067,7 @@ const reEmptyAttribute = new RegExp(
 
 // Special content elements
 
-const specialContentTags = new Set(['script', 'style']);
+const specialContentElements = new Set(['script', 'style']);
 
 // Imports
 
@@ -1094,7 +1131,7 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll) {
   }
 
   if (trimLeft) {
-    // Non-breaking space is specifically handled inside the replacer function
+    // No-break space is specifically handled inside the replacer function
     str = str.replace(/^[ \n\r\t\f\xA0]+/, function (spaces) {
       const conservative = !lineBreakBefore && options.conservativeCollapse;
       if (conservative && spaces === '\t') {
@@ -1105,7 +1142,7 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll) {
   }
 
   if (trimRight) {
-    // Non-breaking space is specifically handled inside the replacer function
+    // No-break space is specifically handled inside the replacer function
     str = str.replace(/[ \n\r\t\f\xA0]+$/, function (spaces) {
       const conservative = !lineBreakAfter && options.conservativeCollapse;
       if (conservative && spaces === '\t') {
@@ -1129,11 +1166,42 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll) {
 
 // Collapse whitespace smartly based on surrounding tags
 
-function collapseWhitespaceSmart(str, prevTag, nextTag, options, inlineElements, inlineTextSet) {
+function collapseWhitespaceSmart(str, prevTag, nextTag, prevAttrs, nextAttrs, options, inlineElements, inlineTextSet) {
+  const prevTagName = prevTag && (prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag);
+  const nextTagName = nextTag && (nextTag.charAt(0) === '/' ? nextTag.slice(1) : nextTag);
+
+  // Helper: Check if an input element has `type="hidden"`
+  const isHiddenInput = (tagName, attrs) => {
+    if (tagName !== 'input' || !attrs || !attrs.length) return false;
+    const typeAttr = attrs.find(attr => attr.name === 'type');
+    return typeAttr && typeAttr.value === 'hidden';
+  };
+
+  // Check if prev/next are non-rendering (hidden) elements
+  const prevIsHidden = isHiddenInput(prevTagName, prevAttrs);
+  const nextIsHidden = isHiddenInput(nextTagName, nextAttrs);
+
   let trimLeft = prevTag && !inlineElementsToKeepWhitespace.has(prevTag);
+
+  // Smart default behavior: Collapse space after non-rendering elements (`type="hidden"`)
+  // This happens even in basic `collapseWhitespace` mode (safe optimization)
+  if (!trimLeft && prevIsHidden && str && !/\S/.test(str)) {
+    trimLeft = true;
+  }
+
+  // Aggressive mode: Collapse between all form controls (pure whitespace only)
+  const isPureWhitespace = str && !/\S/.test(str);
+  if (!trimLeft && prevTagName && nextTagName &&
+      options.collapseInlineTagWhitespace &&
+      isPureWhitespace &&
+      formControlElements.has(prevTagName) && formControlElements.has(nextTagName)) {
+    trimLeft = true;
+  }
+
   if (trimLeft && !options.collapseInlineTagWhitespace) {
     trimLeft = prevTag.charAt(0) === '/' ? !inlineElements.has(prevTag.slice(1)) : !inlineTextSet.has(prevTag);
   }
+
   // When `collapseInlineTagWhitespace` is enabled, still preserve whitespace around inline text elements
   if (trimLeft && options.collapseInlineTagWhitespace) {
     const tagName = prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag;
@@ -1141,10 +1209,26 @@ function collapseWhitespaceSmart(str, prevTag, nextTag, options, inlineElements,
       trimLeft = false;
     }
   }
+
   let trimRight = nextTag && !inlineElementsToKeepWhitespace.has(nextTag);
+
+  // Smart default behavior: Collapse space before non-rendering elements (`type="hidden"`)
+  if (!trimRight && nextIsHidden && str && !/\S/.test(str)) {
+    trimRight = true;
+  }
+
+  // Aggressive mode: Same as `trimLeft`
+  if (!trimRight && prevTagName && nextTagName &&
+      options.collapseInlineTagWhitespace &&
+      isPureWhitespace &&
+      formControlElements.has(prevTagName) && formControlElements.has(nextTagName)) {
+    trimRight = true;
+  }
+
   if (trimRight && !options.collapseInlineTagWhitespace) {
     trimRight = nextTag.charAt(0) === '/' ? !inlineTextSet.has(nextTag.slice(1)) : !inlineElements.has(nextTag);
   }
+
   // When `collapseInlineTagWhitespace` is enabled, still preserve whitespace around inline text elements
   if (trimRight && options.collapseInlineTagWhitespace) {
     const tagName = nextTag.charAt(0) === '/' ? nextTag.slice(1) : nextTag;
@@ -1152,6 +1236,7 @@ function collapseWhitespaceSmart(str, prevTag, nextTag, options, inlineElements,
       trimRight = false;
     }
   }
+
   return collapseWhitespace(str, options, trimLeft, trimRight, prevTag && nextTag);
 }
 
@@ -1172,7 +1257,6 @@ function canTrimWhitespace(tag) {
 
 // Wrap CSS declarations for inline styles and media queries
 // This ensures proper context for CSS minification
-
 function wrapCSS(text, type) {
   switch (type) {
     case 'inline':
@@ -1254,7 +1338,6 @@ async function processScript(text, options, currentAttrs, minifyHTML) {
 
 /**
  * Lightweight SVG optimizations:
- *
  * - Numeric precision reduction for coordinates and path data
  * - Whitespace removal in attribute values (numeric sequences)
  * - Default attribute removal (safe, well-documented defaults)
@@ -1348,7 +1431,7 @@ function minifyNumber(num, precision = 3) {
   if (num === '1.0' || num === '1.00' || num === '1.000') return '1';
 
   // Check cache
-  // (Note: uses input string as key, so “0.0000” and “0.00000” create separate entries.
+  // (Note: Uses input string as key, so “0.0000” and “0.00000” create separate entries.
   // This is intentional to avoid parsing overhead.
   // Real-world SVG files from export tools typically use consistent formats.)
   const cacheKey = `${num}:${precision}`;
@@ -1387,15 +1470,15 @@ function minifyPathData(pathData, precision = 3) {
 
   // Remove unnecessary spaces around path commands
   // Safe to remove space after a command letter when it’s followed by a number (which may be negative)
-  // M 10 20 → M10 20, L -5 -3 → L-5-3
+  // `M 10 20` → `M10 20`, `L -5 -3` → `L-5-3`
   result = result.replace(/([MLHVCSQTAZmlhvcsqtaz])\s+(?=-?\d)/g, '$1');
 
   // Safe to remove space before command letter when preceded by a number
-  // 0 L → 0L, 20 M → 20M
+  // `0 L` → `0L`, `20 M` → `20M`
   result = result.replace(/(\d)\s+([MLHVCSQTAZmlhvcsqtaz])/g, '$1$2');
 
   // Safe to remove space before negative number when preceded by a number
-  // 10 -20 → 10-20 (numbers are separated by the minus sign)
+  // `10 -20` → `10-20` (numbers are separated by the minus sign)
   result = result.replace(/(\d)\s+(-\d)/g, '$1$2');
 
   return result;
@@ -1404,9 +1487,9 @@ function minifyPathData(pathData, precision = 3) {
 /**
  * Minify whitespace in numeric attribute values
  * Examples:
- *   "10 , 20" → "10,20"
- *   "translate( 10 20 )" → "translate(10 20)"
- *   "100, 10  40,  198" → "100,10 40,198"
+ * - “10 , 20" → "10,20"
+ * - "translate( 10 20 )" → "translate(10 20)"
+ * - "100, 10  40,  198" → "100,10 40,198"
  *
  * @param {string} value - Attribute value to minify
  * @returns {string} Minified value
@@ -1439,8 +1522,7 @@ function minifyColor(color) {
 
   // Don’t process values that aren’t simple colors (preserve case-sensitive references)
   // `url(#id)`, `var(--name)`, `inherit`, `currentColor`, etc.
-  if (trimmed.includes('url(') || trimmed.includes('var(') ||
-      trimmed === 'inherit' || trimmed === 'currentColor') {
+  if (trimmed.includes('url(') || trimmed.includes('var(') || trimmed === 'inherit' || trimmed === 'currentColor') {
     return trimmed;
   }
 
@@ -1448,7 +1530,7 @@ function minifyColor(color) {
   const lower = trimmed.toLowerCase();
 
   // Shorten 6-digit hex to 3-digit when possible
-  // #aabbcc → #abc, #000000 → #000
+  // `#aabbcc` → `#abc`, `#000000` → `#000`
   const hexMatch = lower.match(/^#([0-9a-f]{6})$/);
   if (hexMatch) {
     const hex = hexMatch[1];
@@ -1468,7 +1550,7 @@ function minifyColor(color) {
     return NAMED_COLORS[lower] || lower;
   }
 
-  // Convert rgb(255,255,255) to hex
+  // Convert rgb() to hex
   const rgbMatch = lower.match(/^rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/);
   if (rgbMatch) {
     const r = parseInt(rgbMatch[1], 10);
@@ -1499,14 +1581,14 @@ function minifyColor(color) {
 const NUMERIC_ATTRS = new Set([
   'd', // Path data
   'points', // Polygon/polyline points
-  'viewBox', // viewBox coordinates
+  'viewBox', // `viewBox` coordinates
   'transform', // Transform functions
   'x', 'y', 'x1', 'y1', 'x2', 'y2', // Coordinates
   'cx', 'cy', 'r', 'rx', 'ry', // Circle/ellipse
   'width', 'height', // Dimensions
   'dx', 'dy', // Text offsets
   'offset', // Gradient offset
-  'startOffset', // textPath
+  'startOffset', // `textPath`
   'pathLength', // Path length
   'stdDeviation', // Filter params
   'baseFrequency', // Turbulence
@@ -1690,8 +1772,8 @@ function shouldMinifyInnerHTML(options) {
 /**
  * @param {Partial<MinifierOptions>} inputOptions - User-provided options
  * @param {Object} deps - Dependencies from htmlminifier.js
- * @param {Function} deps.getLightningCSS - Function to lazily load lightningcss
- * @param {Function} deps.getTerser - Function to lazily load terser
+ * @param {Function} deps.getLightningCSS - Function to lazily load Lightning CSS
+ * @param {Function} deps.getTerser - Function to lazily load Terser
  * @param {Function} deps.getSwc - Function to lazily load @swc/core
  * @param {LRU} deps.cssMinifyCache - CSS minification cache
  * @param {LRU} deps.jsMinifyCache - JS minification cache
@@ -1728,7 +1810,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, cssM
     if (typeof value === 'string') {
       return new RegExp(value.replace(/^\/(.*)\/$/, '$1'));
     }
-    return value; // Already a RegExp or other type
+    return value; // Already a RegExp or another type
   };
 
   const parseRegExpArray = (arr) => {
@@ -1865,7 +1947,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, cssM
       // Validate engine
       const supportedEngines = ['terser', 'swc'];
       if (!supportedEngines.includes(engine)) {
-        throw new Error(`Unsupported JS minifier engine: "${engine}". Supported engines: ${supportedEngines.join(', ')}`);
+        throw new Error(`Unsupported JS minifier engine: “${engine}”. Supported engines: ${supportedEngines.join(', ')}`);
       }
 
       // Extract engine-specific options (excluding `engine` field itself)
@@ -1972,14 +2054,14 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, cssM
         relateUrlOptions = {};
       }
 
-      // Cache RelateURL instance for reuse (expensive to create)
+      // Cache relateurl instance for reuse (expensive to create)
       const relateUrlInstance = new RelateURL(relateUrlOptions.site || '', relateUrlOptions);
 
       // Create instance-specific cache (results depend on site configuration)
       const instanceCache = urlMinifyCache ? new (urlMinifyCache.constructor)(500) : null;
 
       options.minifyURLs = function (text) {
-        // Fast-path: Skip if text doesn't look like a URL that needs processing
+        // Fast-path: Skip if text doesn’t look like a URL that needs processing
         // Only process if contains URL-like characters (`/`, `:`, `#`, `?`) or spaces that need encoding
         if (!/[/:?#\s]/.test(text)) {
           return text;
@@ -2011,17 +2093,17 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, cssM
       };
     } else if (key === 'minifySVG') {
       // Process SVG minification options
-      // Unlike minifyCSS/minifyJS, this is a simple options object, not a function
+      // Unlike `minifyCSS`/`minifyJS`, this is a simple options object, not a function
       // The actual minification is applied inline during attribute processing
       options.minifySVG = getSVGMinifierOptions(option);
     } else if (key === 'customAttrCollapse') {
-      // Single RegExp pattern
+      // Single regex pattern
       options[key] = parseRegExp(option);
     } else if (key === 'customAttrSurround') {
       // Nested array of RegExp pairs: `[[openRegExp, closeRegExp], …]`
       options[key] = parseNestedRegExpArray(option);
     } else if (['customAttrAssign', 'customEventAttributes', 'ignoreCustomComments', 'ignoreCustomFragments'].includes(key)) {
-      // Array of RegExp patterns
+      // Array of regex patterns
       options[key] = parseRegExpArray(option);
     } else {
       options[key] = option;
@@ -2086,8 +2168,7 @@ function isAttributeRedundant(tag, attrName, attrValue, attrs) {
   const tagHasDefaults = tag in tagDefaults;
 
   // Check for legacy attribute rules (element- and attribute-specific)
-  const isLegacyAttr = (tag === 'script' && (attrName === 'language' || attrName === 'charset')) ||
-                       (tag === 'a' && attrName === 'name');
+  const isLegacyAttr = (tag === 'script' && (attrName === 'language' || attrName === 'charset')) || (tag === 'a' && attrName === 'name');
 
   // If none of these conditions apply, attribute cannot be redundant
   if (!hasGeneralDefault && !tagHasDefaults && !isLegacyAttr) {
@@ -2145,7 +2226,7 @@ function isStyleLinkTypeAttribute(attrValue = '') {
   return attrValue === '' || attrValue === 'text/css';
 }
 
-function isStyleSheet(tag, attrs) {
+function isStyleElement(tag, attrs) {
   if (tag !== 'style') {
     return false;
   }
@@ -2202,11 +2283,11 @@ function isLinkType(tag, attrs, value) {
 }
 
 function isMediaQuery(tag, attrs, attrName) {
-  return attrName === 'media' && (isLinkType(tag, attrs, 'stylesheet') || isStyleSheet(tag, attrs));
+  return attrName === 'media' && (isLinkType(tag, attrs, 'stylesheet') || isStyleElement(tag, attrs));
 }
 
 function isSrcset(attrName, tag) {
-  return attrName === 'srcset' && srcsetTags.has(tag);
+  return attrName === 'srcset' && srcsetElements.has(tag);
 }
 
 function isMetaViewport(tag, attrs) {
@@ -2214,7 +2295,7 @@ function isMetaViewport(tag, attrs) {
     return false;
   }
   for (let i = 0, len = attrs.length; i < len; i++) {
-    if (attrs[i].name === 'name' && attrs[i].value === 'viewport') {
+    if (attrs[i].name.toLowerCase() === 'name' && attrs[i].value.toLowerCase() === 'viewport') {
       return true;
     }
   }
@@ -2234,7 +2315,7 @@ function isContentSecurityPolicy(tag, attrs) {
 }
 
 function canDeleteEmptyAttribute(tag, attrName, attrValue, options) {
-  const isValueEmpty = !attrValue || /^\s*$/.test(attrValue);
+  const isValueEmpty = !attrValue || attrValue.trim() === '';
   if (!isValueEmpty) {
     return false;
   }
@@ -2257,7 +2338,7 @@ function hasAttrName(name, attrs) {
 
 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`
+  // Preserves special spaces (no-break space, hair space, etc.) for consistency with `collapseWhitespace`
   if (options.collapseAttributeWhitespace) {
     // Fast path: Only process if whitespace exists (avoids regex overhead on clean values)
     if (RE_ATTR_WS_CHECK.test(attrValue)) {
@@ -2313,7 +2394,7 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
       try {
         attrValue = await options.minifyCSS(attrValue, 'inline');
         // After minification, check if CSS consists entirely of invalid properties (no values)
-        // E.g., `color:` or `margin:;padding:` should be treated as empty
+        // I.e., `color:` or `margin:;padding:` should be treated as empty
         if (attrValue && /^(?:[a-z-]+:\s*;?\s*)+$/i.test(attrValue)) {
           attrValue = '';
         }
@@ -2433,13 +2514,13 @@ async function normalizeAttr(attr, attrs, tag, options, minifyHTML) {
   }
 
   if ((options.removeRedundantAttributes &&
-      isAttributeRedundant(tag, attrName, attrValue, attrs)) ||
-    (options.removeScriptTypeAttributes && tag === 'script' &&
-      attrName === 'type' && isScriptTypeAttribute(attrValue) && !keepScriptTypeAttribute(attrValue)) ||
-    (options.removeStyleLinkTypeAttributes && (tag === 'style' || tag === 'link') &&
-      attrName === 'type' && isStyleLinkTypeAttribute(attrValue)) ||
-    (options.insideSVG && options.minifySVG &&
-      shouldRemoveSVGAttribute(tag, attrName, attrValue, options.minifySVG))) {
+       isAttributeRedundant(tag, attrName, attrValue, attrs)) ||
+      (options.removeScriptTypeAttributes && tag === 'script' &&
+       attrName === 'type' && isScriptTypeAttribute(attrValue) && !keepScriptTypeAttribute(attrValue)) ||
+      (options.removeStyleLinkTypeAttributes && (tag === 'style' || tag === 'link') &&
+       attrName === 'type' && isStyleLinkTypeAttribute(attrValue)) ||
+      (options.insideSVG && options.minifySVG &&
+       shouldRemoveSVGAttribute(tag, attrName, attrValue, options.minifySVG))) {
     return;
   }
 
@@ -2448,7 +2529,7 @@ async function normalizeAttr(attr, attrs, tag, options, minifyHTML) {
   }
 
   if (options.removeEmptyAttributes &&
-    canDeleteEmptyAttribute(tag, attrName, attrValue, options)) {
+      canDeleteEmptyAttribute(tag, attrName, attrValue, options)) {
     return;
   }
 
@@ -2471,19 +2552,35 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
   let attrFragment;
   let emittedAttrValue;
 
-  if (typeof attrValue !== 'undefined' && (!options.removeAttributeQuotes ||
-    attrValue.indexOf(uidAttr) !== -1 || !canRemoveAttributeQuotes(attrValue))) {
+  // Determine if we 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))) ||
+    // If `removeAttributeQuotes` is not enabled, preserve original quote style or add quotes if value requires them
+    (!options.removeAttributeQuotes && (attrQuote !== '' || !canRemoveAttributeQuotes(attrValue) ||
+      // Special case: With `removeTagWhitespace`, unquoted values that aren’t last will have space added,
+      // which can create ambiguous/invalid HTML—add quotes to be safe
+      (options.removeTagWhitespace && attrQuote === '' && !isLast)))
+  );
+
+  if (shouldAddQuotes) {
     // Determine the appropriate quote character
     if (!options.preventAttributesEscaping) {
-      // Normal mode: choose quotes and escape
-      attrQuote = chooseAttributeQuote(attrValue, options);
+      // Normal mode: Choose optimal quote type to minimize escaping
+      // unless we’re 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 === '') {
+        attrQuote = chooseAttributeQuote(attrValue, options);
+      }
+
       if (attrQuote === '"') {
         attrValue = attrValue.replace(/"/g, '&#34;');
       } else {
         attrValue = attrValue.replace(/'/g, '&#39;');
       }
     } else {
-      // `preventAttributesEscaping` mode: choose safe quotes but don't escape
+      // `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;
@@ -2502,8 +2599,18 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
           attrQuote = "'";
         } else if (attrQuote === "'" && hasSingleQuote && !hasDoubleQuote) {
           attrQuote = '"';
-        // Fallback for invalid/unsupported attrQuote values (not `"`, `'`, or empty string): Choose safe default based on value content
-        } else if (attrQuote !== '"' && attrQuote !== "'" && attrQuote !== '') {
+        // If no quote character yet (empty string), choose based on content
+        } else if (attrQuote === '') {
+          if (hasSingleQuote && !hasDoubleQuote) {
+            attrQuote = '"';
+          } else if (hasDoubleQuote && !hasSingleQuote) {
+            attrQuote = "'";
+          } else {
+            attrQuote = '"';
+          }
+        // Fallback for invalid/unsupported attrQuote values (not `"`, `'`, or empty string):
+        // Choose safe default based on value content
+        } else if (attrQuote !== '"' && attrQuote !== "'") {
           if (hasSingleQuote && !hasDoubleQuote) {
             attrQuote = '"';
           } else if (hasDoubleQuote && !hasSingleQuote) {
@@ -2513,7 +2620,22 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
           }
         }
       } else {
-        attrQuote = options.quoteCharacter === '\'' ? '\'' : '"';
+        // `quoteCharacter` is explicitly set
+        const preferredQuote = options.quoteCharacter === '\'' ? '\'' : '"';
+        // Safety check: If the preferred quote conflicts with value content, switch to the opposite quote
+        if ((preferredQuote === '"' && hasDoubleQuote && !hasSingleQuote) || (preferredQuote === "'" && hasSingleQuote && !hasDoubleQuote)) {
+          attrQuote = preferredQuote === '"' ? "'" : '"';
+        } else if ((preferredQuote === '"' && hasDoubleQuote && hasSingleQuote) || (preferredQuote === "'" && hasSingleQuote && hasDoubleQuote)) {
+          // Both quote types present: Fall back to escaping despite `preventAttributesEscaping`
+          attrQuote = preferredQuote;
+          if (attrQuote === '"') {
+            attrValue = attrValue.replace(/"/g, '&#34;');
+          } else {
+            attrValue = attrValue.replace(/'/g, '&#39;');
+          }
+        } else {
+          attrQuote = preferredQuote;
+        }
       }
     }
     emittedAttrValue = attrQuote + attrValue + attrQuote;
@@ -2521,15 +2643,17 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
       emittedAttrValue += ' ';
     }
   } else if (isLast && !hasUnarySlash) {
-    // Last attribute in a non-self-closing tag: no space needed
+    // Last attribute in a non-self-closing tag:
+    // No space needed
     emittedAttrValue = attrValue;
   } else {
-    // Not last attribute, or is a self-closing tag: add space
+    // Not last attribute, or is a self-closing tag:
+    // Unquoted values must have space after them to delimit from next attribute
     emittedAttrValue = attrValue + ' ';
   }
 
   if (typeof attrValue === 'undefined' || (options.collapseBooleanAttributes &&
-    isBooleanAttribute(attrName.toLowerCase(), (attrValue || '').toLowerCase()))) {
+      isBooleanAttribute(attrName.toLowerCase(), (attrValue || '').toLowerCase()))) {
     attrFragment = attrName;
     if (!isLast) {
       attrFragment += ' ';
@@ -2552,7 +2676,7 @@ function canRemoveParentTag(optionalStartTag, tag) {
     case 'head':
       return true;
     case 'body':
-      return !headerTags.has(tag);
+      return !headerElements.has(tag);
     case 'colgroup':
       return tag === 'col';
     case 'tbody':
@@ -2566,7 +2690,7 @@ function isStartTagMandatory(optionalEndTag, tag) {
     case 'colgroup':
       return optionalEndTag === 'colgroup';
     case 'tbody':
-      return tableSectionTags.has(optionalEndTag);
+      return tableSectionElements.has(optionalEndTag);
   }
   return false;
 }
@@ -2585,9 +2709,9 @@ function canRemovePrecedingTag(optionalEndTag, tag) {
       return tag === optionalEndTag;
     case 'dt':
     case 'dd':
-      return descriptionTags.has(tag);
+      return descriptionElements.has(tag);
     case 'p':
-      return pBlockTags.has(tag);
+      return pBlockElements.has(tag);
     case 'rb':
     case 'rt':
     case 'rp':
@@ -2595,15 +2719,15 @@ function canRemovePrecedingTag(optionalEndTag, tag) {
     case 'rtc':
       return rubyRtcEndTagOmission.has(tag);
     case 'option':
-      return optionTag.has(tag);
+      return optionElements.has(tag);
     case 'thead':
     case 'tbody':
-      return tableContentTags.has(tag);
+      return tableContentElements.has(tag);
     case 'tfoot':
       return tag === 'tbody';
     case 'td':
     case 'th':
-      return cellTags.has(tag);
+      return cellElements.has(tag);
   }
   return false;
 }
@@ -2706,7 +2830,7 @@ function parseRemoveEmptyElementsExcept(input, options) {
     if (typeof item === 'string') {
       const spec = parseElementSpec(item, options);
       if (!spec && options.log) {
-        options.log('Warning: Unable to parse “removeEmptyElementsExcept” specification: "' + item + '"');
+        options.log('Warning: Unable to parse “removeEmptyElementsExcept” specification: “' + item + '”');
       }
       return spec;
     }
@@ -3219,7 +3343,7 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
   }
 
   // Pre-compile regex patterns for reuse (performance optimization)
-  // These must be declared before scan() since scan uses them
+  // These must be declared before `scan()` since scan uses them
   const whitespaceSplitPatternScan = /[ \t\n\f\r]+/;
   const whitespaceSplitPatternSort = /[ \n\f\r]+/;
 
@@ -3251,9 +3375,9 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
       chars: async function (text) {
         // Only recursively scan HTML content, not JSON-LD or other non-HTML script types
         // `scan()` is for analyzing HTML attribute order, not for parsing JSON
-        if (options.processScripts && specialContentTags.has(currentTag) &&
-          options.processScripts.indexOf(currentType) > -1 &&
-          currentType === 'text/html') {
+        if (options.processScripts && specialContentElements.has(currentTag) &&
+            options.processScripts.indexOf(currentType) > -1 &&
+            currentType === 'text/html') {
           await scan(text);
         }
       },
@@ -3276,7 +3400,7 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
   // 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.
+  // 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,
@@ -3295,7 +3419,7 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
   });
 
   // Temporarily enable `continueOnParseError` for the `scan()` function call below.
-  // Note: `firstPassOptions` already has `continueOnParseError: true` for the minifyHTML call.
+  // Note: `firstPassOptions` already has `continueOnParseError: true` for the `minifyHTML` call.
   const originalContinueOnParseError = options.continueOnParseError;
   options.continueOnParseError = true;
 
@@ -3308,7 +3432,7 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
     : null;
 
   try {
-    // Expand UID tokens back to original content for frequency analysis
+    // Expand UID tokens back to the original content for frequency analysis
     let expandedValue = value;
     if (uidReplacePattern) {
       expandedValue = value.replace(uidReplacePattern, function (match, index) {
@@ -3357,7 +3481,7 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
           attrOrderCache.set(cacheKey, sortedNames);
         }
 
-        // Apply the sorted order to attrs
+        // Apply the sorted order to `attrs`
         const attrMap = Object.create(null);
         names.forEach(function (name, index) {
           (attrMap[name] || (attrMap[name] = [])).push(attrs[index]);
@@ -3444,7 +3568,7 @@ async function minifyHTML(value, options, partialMarkup) {
   const customElementsInput = options.inlineCustomElements ?? [];
   const customElementsArr = Array.isArray(customElementsInput) ? customElementsInput : Array.from(customElementsInput);
   const normalizedCustomElements = customElementsArr.map(name => options.name(name));
-  // Fast path: Reuse base Sets if no custom elements
+  // Fast path: Reuse base sets if no custom elements
   const inlineTextSet = normalizedCustomElements.length
     ? new Set([...inlineElementsToKeepWhitespaceWithin, ...normalizedCustomElements])
     : inlineElementsToKeepWhitespaceWithin;
@@ -3464,7 +3588,7 @@ async function minifyHTML(value, options, partialMarkup) {
   }
 
   // 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-emoj-cthulhu-filled content
+  // For all we care there might be completely-horribly-broken-alien-non-html-emoji-cthulhu-filled content
   value = value.replace(/<!-- htmlmin:ignore -->([\s\S]*?)<!-- htmlmin:ignore -->/g, function (match, group1) {
     if (!uidIgnore) {
       uidIgnore = uniqueId(value);
@@ -3485,7 +3609,7 @@ async function minifyHTML(value, options, partialMarkup) {
   // 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')) {
+      (options.sortClassName && typeof options.sortClassName !== 'function')) {
     await createSortFns(value, options, uidIgnore, null, ignoredMarkupChunks);
   }
 
@@ -3547,11 +3671,11 @@ async function minifyHTML(value, options, partialMarkup) {
     });
   }
 
-  function _canCollapseWhitespace(tag, attrs) {
+  function canCollapseWhitespace$1(tag, attrs) {
     return options.canCollapseWhitespace(tag, attrs, canCollapseWhitespace);
   }
 
-  function _canTrimWhitespace(tag, attrs) {
+  function canTrimWhitespace$1(tag, attrs) {
     return options.canTrimWhitespace(tag, attrs, canTrimWhitespace);
   }
 
@@ -3573,12 +3697,12 @@ async function minifyHTML(value, options, partialMarkup) {
 
   // Look for trailing whitespaces, bypass any inline tags
   function trimTrailingWhitespace(index, nextTag) {
-    for (let endTag = null; index >= 0 && _canTrimWhitespace(endTag); index--) {
+    for (let endTag = null; index >= 0 && canTrimWhitespace$1(endTag); index--) {
       const str = buffer[index];
       const match = str.match(/^<\/([\w:-]+)>$/);
       if (match) {
         endTag = match[1];
-      } else if (/>$/.test(str) || (buffer[index] = collapseWhitespaceSmart(str, null, nextTag, options, inlineElements, inlineTextSet))) {
+      } else if (/>$/.test(str) || (buffer[index] = collapseWhitespaceSmart(str, null, nextTag, [], [], options, inlineElements, inlineTextSet))) {
         break;
       }
     }
@@ -3627,10 +3751,10 @@ async function minifyHTML(value, options, partialMarkup) {
 
       let optional = options.removeOptionalTags;
       if (optional) {
-        const htmlTag = htmlTags.has(tag);
+        const htmlTag = htmlElements.has(tag);
         // `<html>` may be omitted if first thing inside is not a comment
         // `<head>` may be omitted if first thing inside is an element
-        // `<body>` may be omitted if first thing inside is not space, comment, `<meta>`, `<link>`, `<script>`, <`style>`, or `<template>`
+        // `<body>` may be omitted if first thing inside is not space, comment, `<meta>`, `<link>`, `<script>`, `<style>`, or `<template>`
         // `<colgroup>` may be omitted if first thing inside is `<col>`
         // `<tbody>` may be omitted if first thing inside is `<tr>`
         if (htmlTag && canRemoveParentTag(optionalStartTag, tag)) {
@@ -3647,16 +3771,16 @@ async function minifyHTML(value, options, partialMarkup) {
         optionalEndTag = '';
       }
 
-      // Set whitespace flags for nested tags (e.g., <code> within a <pre>)
+      // Set whitespace flags for nested tags (e.g., `<code>` within a `<pre>`)
       if (options.collapseWhitespace) {
         if (!stackNoTrimWhitespace.length) {
           squashTrailingWhitespace(tag);
         }
         if (!unary) {
-          if (!_canTrimWhitespace(tag, attrs) || stackNoTrimWhitespace.length) {
+          if (!canTrimWhitespace$1(tag, attrs) || stackNoTrimWhitespace.length) {
             stackNoTrimWhitespace.push(tag);
           }
-          if (!_canCollapseWhitespace(tag, attrs) || stackNoCollapseWhitespace.length) {
+          if (!canCollapseWhitespace$1(tag, attrs) || stackNoCollapseWhitespace.length) {
             stackNoCollapseWhitespace.push(tag);
           }
         }
@@ -3712,7 +3836,7 @@ async function minifyHTML(value, options, partialMarkup) {
           squashTrailingWhitespace('/' + tag);
         }
         if (stackNoCollapseWhitespace.length &&
-          tag === stackNoCollapseWhitespace[stackNoCollapseWhitespace.length - 1]) {
+            tag === stackNoCollapseWhitespace[stackNoCollapseWhitespace.length - 1]) {
           stackNoCollapseWhitespace.pop();
         }
       }
@@ -3725,7 +3849,7 @@ async function minifyHTML(value, options, partialMarkup) {
 
       if (options.removeOptionalTags) {
         // `<html>`, `<head>` or `<body>` may be omitted if the element is empty
-        if (isElementEmpty && topLevelTags.has(optionalStartTag)) {
+        if (isElementEmpty && topLevelElements.has(optionalStartTag)) {
           removeStartTag();
         }
         optionalStartTag = '';
@@ -3733,7 +3857,7 @@ async function minifyHTML(value, options, partialMarkup) {
         // `</head>` may be omitted if not followed by space or comment
         // `</p>` may be omitted if no more content in non-`</a>` parent
         // except for `</dt>` or `</thead>`, end tags may be omitted if no more content in parent element
-        if (tag && optionalEndTag && !trailingTags.has(optionalEndTag) && (optionalEndTag !== 'p' || !pInlineTags.has(tag))) {
+        if (tag && optionalEndTag && !trailingElements.has(optionalEndTag) && (optionalEndTag !== 'p' || !pInlineElements.has(tag))) {
           removeEndTag();
         }
         optionalEndTag = optionalEndTags.has(tag) ? tag : '';
@@ -3780,10 +3904,12 @@ async function minifyHTML(value, options, partialMarkup) {
         }
       }
     },
-    chars: async function (text, prevTag, nextTag) {
+    chars: async function (text, prevTag, nextTag, prevAttrs, nextAttrs) {
       prevTag = prevTag === '' ? 'comment' : prevTag;
       nextTag = nextTag === '' ? 'comment' : nextTag;
-      if (options.decodeEntities && text && !specialContentTags.has(currentTag)) {
+      prevAttrs = prevAttrs || [];
+      nextAttrs = nextAttrs || [];
+      if (options.decodeEntities && text && !specialContentElements.has(currentTag)) {
         if (text.indexOf('&') !== -1) {
           text = entities.decodeHTML(text);
         }
@@ -3819,7 +3945,7 @@ async function minifyHTML(value, options, partialMarkup) {
             }
           }
           if (prevTag || nextTag) {
-            text = collapseWhitespaceSmart(text, prevTag, nextTag, options, inlineElements, inlineTextSet);
+            text = collapseWhitespaceSmart(text, prevTag, nextTag, prevAttrs, nextAttrs, options, inlineElements, inlineTextSet);
           } else {
             text = collapseWhitespace(text, options, true, true);
           }
@@ -3831,13 +3957,13 @@ async function minifyHTML(value, options, partialMarkup) {
           text = collapseWhitespace(text, options, false, false, true);
         }
       }
-      if (specialContentTags.has(currentTag) && (options.processScripts || hasJsonScriptType(currentAttrs))) {
+      if (specialContentElements.has(currentTag) && (options.processScripts || hasJsonScriptType(currentAttrs))) {
         text = await processScript(text, options, currentAttrs, minifyHTML);
       }
       if (isExecutableScript(currentTag, currentAttrs)) {
         text = await options.minifyJS(text);
       }
-      if (isStyleSheet(currentTag, currentAttrs)) {
+      if (isStyleElement(currentTag, currentAttrs)) {
         text = await options.minifyCSS(text);
       }
       if (options.removeOptionalTags && text) {
@@ -3849,7 +3975,7 @@ async function minifyHTML(value, options, partialMarkup) {
         optionalStartTag = '';
         // `</html>` or `</body>` may be omitted if not followed by comment
         // `</head>`, `</colgroup>`, or `</caption>` may be omitted if not followed by space or comment
-        if (compactTags.has(optionalEndTag) || (looseTags.has(optionalEndTag) && !/^\s/.test(text))) {
+        if (compactElements.has(optionalEndTag) || (looseElements.has(optionalEndTag) && !/^\s/.test(text))) {
           removeEndTag();
         }
         // Don’t reset optionalEndTag if text is only whitespace and will be collapsed (not conservatively)
@@ -3858,11 +3984,11 @@ async function minifyHTML(value, options, partialMarkup) {
         }
       }
       charsPrevTag = /^\s*$/.test(text) ? prevTag : 'comment';
-      if (options.decodeEntities && text && !specialContentTags.has(currentTag)) {
+      if (options.decodeEntities && text && !specialContentElements.has(currentTag)) {
         // Escape any `&` symbols that start either:
-        // 1) a legacy named character reference (i.e., one that doesn’t end with `;`)
+        // 1) a legacy-named character reference (i.e., one that doesn’t end with `;`)
         // 2) or any other character reference (i.e., one that does end with `;`)
-        // Note that `&` can be escaped as `&amp`, without the semi-colon.
+        // Note that `&` can be escaped as `&amp`, without the semicolon.
         // https://mathiasbynens.be/notes/ambiguous-ampersands
         if (text.indexOf('&') !== -1) {
           text = text.replace(RE_LEGACY_ENTITIES, '&amp$1');
@@ -3927,7 +4053,7 @@ 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
+                  // 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)) {
@@ -3988,11 +4114,11 @@ async function minifyHTML(value, options, partialMarkup) {
   if (options.removeOptionalTags) {
     // `<html>` may be omitted if first thing inside is not a comment
     // `<head>` or `<body>` may be omitted if empty
-    if (topLevelTags.has(optionalStartTag)) {
+    if (topLevelElements.has(optionalStartTag)) {
       removeStartTag();
     }
     // except for `</dt>` or `</thead>`, end tags may be omitted if no more content in parent element
-    if (optionalEndTag && !trailingTags.has(optionalEndTag)) {
+    if (optionalEndTag && !trailingElements.has(optionalEndTag)) {
       removeEndTag();
     }
   }