html-minifier-next 4.16.4 → 4.17.1

package/src/htmlparser.js

@@ -1,4 +1,4 @@
-/*!
+/*
  * HTML Parser By John Resig (ejohn.org)
  * Modified by Juriy “kangax” Zaytsev
  * Original code by Erik Arvidsson, Mozilla Public License
@@ -9,10 +9,10 @@
  * 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) {}
  * });
  */
 
@@ -35,7 +35,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';
@@ -75,7 +75,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,
@@ -138,6 +138,7 @@ export 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;
@@ -181,6 +182,7 @@ export class HTMLParser {
               }
               advance(commentEnd + 3);
               prevTag = '';
+              prevAttrs = [];
               continue;
             }
           }
@@ -195,6 +197,7 @@ export class HTMLParser {
               }
               advance(conditionalEnd + 2);
               prevTag = '';
+              prevAttrs = [];
               continue;
             }
           }
@@ -207,6 +210,7 @@ export class HTMLParser {
             }
             advance(doctypeMatch[0].length);
             prevTag = '';
+            prevAttrs = [];
             continue;
           }
 
@@ -216,6 +220,7 @@ export class HTMLParser {
             advance(endTagMatch[0].length);
             await parseEndTag(endTagMatch[0], endTagMatch[1]);
             prevTag = '/' + endTagMatch[1].toLowerCase();
+            prevAttrs = [];
             continue;
           }
 
@@ -248,19 +253,24 @@ export 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
@@ -283,7 +293,7 @@ export 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;
@@ -295,10 +305,11 @@ export 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);
@@ -317,6 +328,23 @@ export 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) {
@@ -329,7 +357,7 @@ export 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
 
@@ -429,7 +457,7 @@ export 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);
@@ -497,7 +525,7 @@ export 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]; }
@@ -554,6 +582,9 @@ export class HTMLParser {
         unarySlash = '';
       }
 
+      // Store attributes for `prevAttrs` tracking (used in whitespace collapsing)
+      prevAttrs = attrs;
+
       if (handler.start) {
         await handler.start(tagName, attrs, unary, unarySlash);
       }

package/src/lib/attributes.js

@@ -15,7 +15,7 @@ import {
   keepScriptsMimetypes,
   isSimpleBoolean,
   isBooleanValue,
-  srcsetTags,
+  srcsetElements,
   reEmptyAttribute
 } from './constants.js';
 import { trimWhitespace, collapseWhitespaceAll } from './whitespace.js';
@@ -75,8 +75,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) {
@@ -134,7 +133,7 @@ function isStyleLinkTypeAttribute(attrValue = '') {
   return attrValue === '' || attrValue === 'text/css';
 }
 
-function isStyleSheet(tag, attrs) {
+function isStyleElement(tag, attrs) {
   if (tag !== 'style') {
     return false;
   }
@@ -191,11 +190,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) {
@@ -203,7 +202,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;
     }
   }
@@ -223,7 +222,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;
   }
@@ -246,7 +245,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)) {
@@ -302,7 +301,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 = '';
         }
@@ -422,13 +421,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;
   }
 
@@ -437,7 +436,7 @@ async function normalizeAttr(attr, attrs, tag, options, minifyHTML) {
   }
 
   if (options.removeEmptyAttributes &&
-    canDeleteEmptyAttribute(tag, attrName, attrValue, options)) {
+      canDeleteEmptyAttribute(tag, attrName, attrValue, options)) {
     return;
   }
 
@@ -460,19 +459,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;
@@ -491,8 +506,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) {
@@ -502,7 +527,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;
@@ -510,15 +550,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 += ' ';
@@ -544,7 +586,7 @@ export {
   keepScriptTypeAttribute,
   isExecutableScript,
   isStyleLinkTypeAttribute,
-  isStyleSheet,
+  isStyleElement,
   isBooleanAttribute,
   isUriTypeAttribute,
   isNumberTypeAttribute,

package/src/lib/constants.js

@@ -1,4 +1,4 @@
-// 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]+$/;
@@ -19,7 +19,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']);
@@ -30,6 +30,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)
@@ -69,14 +72,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'
 ]);
 
@@ -84,15 +90,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
 
@@ -108,7 +114,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>`
@@ -119,35 +125,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
 
@@ -157,12 +163,12 @@ const reEmptyAttribute = new RegExp(
 
 // Special content elements
 
-const specialContentTags = new Set(['script', 'style']);
+const specialContentElements = new Set(['script', 'style']);
 
 // Exports
 
 export {
-  // RegExp patterns
+  // Regex patterns
   RE_WS_START,
   RE_WS_END,
   RE_ALL_WS_NBSP,
@@ -182,10 +188,11 @@ export {
   RE_ATTR_WS_TRIM,
   RE_NUMERIC_VALUE,
 
-  // Inline element Sets
+  // Inline element sets
   inlineElementsToKeepWhitespaceAround,
   inlineElementsToKeepWhitespaceWithin,
   inlineElementsToKeepWhitespace,
+  formControlElements,
 
   // Default values
   generalDefaults,
@@ -196,33 +203,33 @@ export {
   keepScriptsMimetypes,
   jsonScriptTypes,
 
-  // Boolean Sets
+  // Boolean sets
   isSimpleBoolean,
   isBooleanValue,
 
   // Misc
-  srcsetTags,
+  srcsetElements,
 
   // Tag omission rules
   optionalStartTags,
   optionalEndTags,
-  headerTags,
-  descriptionTags,
-  pBlockTags,
-  pInlineTags,
+  headerElements,
+  descriptionElements,
+  pBlockElements,
+  pInlineElements,
   rubyEndTagOmission,
   rubyRtcEndTagOmission,
-  optionTag,
-  tableContentTags,
-  tableSectionTags,
-  cellTags,
-  topLevelTags,
-  compactTags,
-  looseTags,
-  trailingTags,
-  htmlTags,
+  optionElements,
+  tableContentElements,
+  tableSectionElements,
+  cellElements,
+  topLevelElements,
+  compactElements,
+  looseElements,
+  trailingElements,
+  htmlElements,
 
   // Regex
   reEmptyAttribute,
-  specialContentTags
+  specialContentElements
 };

package/src/lib/content.js

@@ -10,7 +10,6 @@ import { trimWhitespace } from './whitespace.js';
 
 // Wrap CSS declarations for inline styles and media queries
 // This ensures proper context for CSS minification
-
 function wrapCSS(text, type) {
   switch (type) {
     case 'inline':