html-minifier-next 4.12.1 → 4.13.0

package/dist/htmlminifier.cjs

@@ -13,7 +13,8 @@ var RelateURL = require('relateurl');
  */
 
 /*
- * // Use like so:
+ * Use like so:
+ *
  * HTMLParser(htmlString, {
  *     start: function(tag, attrs, unary) {},
  *     end: function(tag) {},
@@ -32,11 +33,11 @@ class CaseInsensitiveSet extends Set {
 const singleAttrIdentifier = /([^\s"'<>/=]+)/;
 const singleAttrAssigns = [/=/];
 const singleAttrValues = [
-  // attr value double quotes
+  // Attr value double quotes
   /"([^"]*)"+/.source,
-  // attr value, single quotes
+  // Attr value, single quotes
   /'([^']*)'+/.source,
-  // attr value, no quotes
+  // Attr value, no quotes
   /([^ \t\n\f\r"'`=<>]+)/.source
 ];
 // https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName
@@ -65,18 +66,17 @@ const empty = new CaseInsensitiveSet(['area', 'base', 'basefont', 'br', 'col', '
 // Inline elements
 const inline = new CaseInsensitiveSet(['a', 'abbr', 'acronym', 'applet', 'b', 'basefont', 'bdo', 'big', 'br', 'button', 'cite', 'code', 'del', 'dfn', 'em', 'font', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'label', 'map', 'noscript', 'object', 'q', 's', 'samp', 'script', 'select', 'selectedcontent', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'svg', 'textarea', 'tt', 'u', 'var']);
 
-// Elements that you can, intentionally, leave open
-// (and which close themselves)
+// Elements that you can, intentionally, leave open (and which close themselves)
 const closeSelf = new CaseInsensitiveSet(['colgroup', 'dd', 'dt', 'li', 'option', 'p', 'td', 'tfoot', 'th', 'thead', 'tr', 'source']);
 
-// Attributes that have their values filled in disabled='disabled'
+// Attributes that have their values filled in `disabled='disabled'`
 const fillAttrs = new CaseInsensitiveSet(['checked', 'compact', 'declare', 'defer', 'disabled', 'ismap', 'multiple', 'nohref', 'noresize', 'noshade', 'nowrap', 'readonly', 'selected']);
 
 // Special elements (can contain anything)
 const special = new CaseInsensitiveSet(['script', 'style']);
 
-// HTML elements https://html.spec.whatwg.org/multipage/indices.html#elements-3
-// Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
+// HTML elements, https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// Phrasing content, https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
 const nonPhrasing = new CaseInsensitiveSet(['address', 'article', 'aside', 'base', 'blockquote', 'body', 'caption', 'col', 'colgroup', 'dd', 'details', 'dialog', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'legend', 'li', 'menuitem', 'meta', 'ol', 'optgroup', 'option', 'param', 'rp', 'rt', 'source', 'style', 'summary', 'tbody', 'td', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul']);
 
 const reCache = {};
@@ -198,7 +198,7 @@ class HTMLParser {
 
             if (conditionalEnd >= 0) {
               if (handler.comment) {
-                await handler.comment(html.substring(2, conditionalEnd + 1), true /* non-standard */);
+                await handler.comment(html.substring(2, conditionalEnd + 1), true /* Non-standard */);
               }
               advance(conditionalEnd + 2);
               prevTag = '';
@@ -375,7 +375,7 @@ class HTMLParser {
                     attr = [];
                     attr[0] = fullAttr;
                     attr[baseIndex] = manualMatch[1]; // Attribute name
-                    attr[baseIndex + 1] = '='; // customAssign (falls back to “=” for huge attributes)
+                    attr[baseIndex + 1] = '='; // `customAssign` (falls back to “=” for huge attributes)
                     const value = input.slice(manualMatch[0].length + 1, closeQuote);
                     // Place value at correct index based on quote type
                     if (quoteChar === '"') {
@@ -681,7 +681,7 @@ class TokenChain {
     const sorter = new Sorter();
     sorter.sorterMap = new Map();
 
-    // Convert Map entries to array and sort
+    // 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;
@@ -729,18 +729,6 @@ class TokenChain {
   }
 }
 
-async function replaceAsync(str, regex, asyncFn) {
-  const promises = [];
-
-  str.replace(regex, (match, ...args) => {
-    const promise = asyncFn(match, ...args);
-    promises.push(promise);
-  });
-
-  const data = await Promise.all(promises);
-  return str.replace(regex, () => data.shift());
-}
-
 /**
  * Preset configurations for HTML Minifier Next
  *
@@ -765,7 +753,6 @@ const presets = {
     useShortDoctype: true
   },
   comprehensive: {
-    // @@ Add `collapseAttributeWhitespace: true` (also add to preset in demo)
     caseSensitive: true,
     collapseBooleanAttributes: true,
     collapseInlineTagWhitespace: true,
@@ -809,407 +796,90 @@ function getPresetNames() {
   return Object.keys(presets);
 }
 
-// Lazy-load heavy dependencies only when needed
+// Stringify for options signatures (sorted keys, shallow, nested objects)
 
-let lightningCSSPromise;
-async function getLightningCSS() {
-  if (!lightningCSSPromise) {
-    lightningCSSPromise = import('lightningcss').then(m => m.transform);
+function stableStringify(obj) {
+  if (obj == null || typeof obj !== 'object') return JSON.stringify(obj);
+  if (Array.isArray(obj)) return '[' + obj.map(stableStringify).join(',') + ']';
+  const keys = Object.keys(obj).sort();
+  let out = '{';
+  for (let i = 0; i < keys.length; i++) {
+    const k = keys[i];
+    out += JSON.stringify(k) + ':' + stableStringify(obj[k]) + (i < keys.length - 1 ? ',' : '');
   }
-  return lightningCSSPromise;
+  return out + '}';
 }
 
-let terserPromise;
-async function getTerser() {
-  if (!terserPromise) {
-    terserPromise = import('terser').then(m => m.minify);
+// LRU cache for strings and promises
+
+class LRU {
+  constructor(limit = 200) {
+    this.limit = limit;
+    this.map = new Map();
   }
-  return terserPromise;
+  get(key) {
+    if (this.map.has(key)) {
+      const v = this.map.get(key);
+      this.map.delete(key);
+      this.map.set(key, v);
+      return v;
+    }
+    return undefined;
+  }
+  set(key, value) {
+    if (this.map.has(key)) this.map.delete(key);
+    this.map.set(key, value);
+    if (this.map.size > this.limit) {
+      const first = this.map.keys().next().value;
+      this.map.delete(first);
+    }
+  }
+  delete(key) { this.map.delete(key); }
 }
 
-// Type definitions
+// Unique ID generator
+
+function uniqueId(value) {
+  let id;
+  do {
+    id = Math.random().toString(36).replace(/^0\.[0-9]*/, '');
+  } while (~value.indexOf(id));
+  return id;
+}
+
+// Identity functions
+
+function identity(value) {
+  return value;
+}
+
+function identityAsync(value) {
+  return Promise.resolve(value);
+}
+
+// Replace async helper
 
 /**
- * @typedef {Object} HTMLAttribute
- *  Representation of an attribute from the HTML parser.
- *
- * @prop {string} name
- * @prop {string} [value]
- * @prop {string} [quote]
- * @prop {string} [customAssign]
- * @prop {string} [customOpen]
- * @prop {string} [customClose]
+ * Asynchronously replace matches in a string
+ * @param {string} str - Input string
+ * @param {RegExp} regex - Regular expression with global flag
+ * @param {Function} asyncFn - Async function to process each match
+ * @returns {Promise<string>} Processed string
  */
+async function replaceAsync(str, regex, asyncFn) {
+  const promises = [];
 
-/**
- * @typedef {Object} MinifierOptions
- *  Options that control how HTML is minified. All of these are optional
- *  and usually default to a disabled/safe value unless noted.
- *
- * @prop {(tag: string, attrs: HTMLAttribute[], canCollapseWhitespace: (tag: string) => boolean) => boolean} [canCollapseWhitespace]
- *  Predicate that determines whether whitespace inside a given element
- *  can be collapsed.
- *
- *  Default: Built-in `canCollapseWhitespace` function
- *
- * @prop {(tag: string | null, attrs: HTMLAttribute[] | undefined, canTrimWhitespace: (tag: string) => boolean) => boolean} [canTrimWhitespace]
- *  Predicate that determines whether leading/trailing whitespace around
- *  the element may be trimmed.
- *
- *  Default: Built-in `canTrimWhitespace` function
- *
- * @prop {boolean} [caseSensitive]
- *  When true, tag and attribute names are treated as case-sensitive.
- *  Useful for custom HTML tags.
- *  If false (default) names are lower-cased via the `name` function.
- *
- *  Default: `false`
- *
- *  @prop {boolean} [collapseAttributeWhitespace]
- *  Collapse multiple whitespace characters within attribute values into a
- *  single space. Also trims leading and trailing whitespace from attribute
- *  values. Applied as an early normalization step before special attribute
- *  handlers (CSS minification, class sorting, etc.) run.
- *
- *  Default: `false`
- *
- * @prop {boolean} [collapseBooleanAttributes]
- *  Collapse boolean attributes to their name only (for example
- *  `disabled="disabled"` → `disabled`).
- *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#collapse_boolean_attributes
- *
- *  Default: `false`
- *
- * @prop {boolean} [collapseInlineTagWhitespace]
- *  When false (default) whitespace around `inline` tags is preserved in
- *  more cases. When true, whitespace around inline tags may be collapsed.
- *  Must also enable `collapseWhitespace` to have effect.
- *
- *  Default: `false`
- *
- * @prop {boolean} [collapseWhitespace]
- *  Collapse multiple whitespace characters into one where allowed. Also
- *  controls trimming behaviour in several code paths.
- *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#collapse_whitespace
- *
- *  Default: `false`
- *
- * @prop {boolean} [conservativeCollapse]
- *  If true, be conservative when collapsing whitespace (preserve more
- *  whitespace in edge cases). Affects collapse algorithms.
- *  Must also enable `collapseWhitespace` to have effect.
- *
- *  Default: `false`
- *
- * @prop {boolean} [continueOnMinifyError]
- *  When set to `false`, minification errors may throw.
- *  By default, the minifier will attempt to recover from minification
- *  errors, or ignore them and preserve the original content.
- *
- *  Default: `true`
- *
- * @prop {boolean} [continueOnParseError]
- *  When true, the parser will attempt to continue on recoverable parse
- *  errors. Otherwise, parsing errors may throw.
- *
- *  Default: `false`
- *
- * @prop {RegExp[]} [customAttrAssign]
- *  Array of regexes used to recognise custom attribute assignment
- *  operators (e.g. `'<div flex?="{{mode != cover}}"></div>'`).
- *  These are concatenated with the built-in assignment patterns.
- *
- *  Default: `[]`
- *
- * @prop {RegExp} [customAttrCollapse]
- *  Regex matching attribute names whose values should be collapsed.
- *  Basically used to remove newlines and excess spaces inside attribute values,
- *  e.g. `/ng-class/`.
- *
- * @prop {[RegExp, RegExp][]} [customAttrSurround]
- *  Array of `[openRegExp, closeRegExp]` pairs used by the parser to
- *  detect custom attribute surround patterns (for non-standard syntaxes,
- *  e.g. `<input {{#if value}}checked="checked"{{/if}}>`).
- *
- * @prop {RegExp[]} [customEventAttributes]
- *  Array of regexes used to detect event handler attributes for `minifyJS`
- *  (e.g. `ng-click`). The default matches standard `on…` event attributes.
- *
- *  Default: `[/^on[a-z]{3,}$/]`
- *
- * @prop {number} [customFragmentQuantifierLimit]
- *  Limits the quantifier used when building a safe regex for custom
- *  fragments to avoid ReDoS. See source use for details.
- *
- *  Default: `200`
- *
- * @prop {boolean} [decodeEntities]
- *  When true, decodes HTML entities in text and attributes before
- *  processing, and re-encodes ambiguous ampersands when outputting.
- *
- *  Default: `false`
- *
- * @prop {boolean} [html5]
- *  Parse and emit using HTML5 rules. Set to `false` to use non-HTML5
- *  parsing behavior.
- *
- *  Default: `true`
- *
- * @prop {RegExp[]} [ignoreCustomComments]
- *  Comments matching any pattern in this array of regexes will be
- *  preserved when `removeComments` is enabled. The default preserves
- *  “bang” comments and comments starting with `#`.
- *
- *  Default: `[/^!/, /^\s*#/]`
- *
- * @prop {RegExp[]} [ignoreCustomFragments]
- *  Array of regexes used to identify fragments that should be
- *  preserved (for example server templates). These fragments are temporarily
- *  replaced during minification to avoid corrupting template code.
- *  The default preserves ASP/PHP-style tags.
- *
- *  Default: `[/<%[\s\S]*?%>/, /<\?[\s\S]*?\?>/]`
- *
- * @prop {boolean} [includeAutoGeneratedTags]
- *  If false, tags marked as auto-generated by the parser will be omitted
- *  from output. Useful to skip injected tags.
- *
- *  Default: `true`
- *
- * @prop {ArrayLike<string>} [inlineCustomElements]
- *  Collection of custom element tag names that should be treated as inline
- *  elements for white-space handling, alongside the built-in inline elements.
- *
- *  Default: `[]`
- *
- * @prop {boolean} [keepClosingSlash]
- *  Preserve the trailing slash in self-closing tags when present.
- *
- *  Default: `false`
- *
- * @prop {(message: unknown) => void} [log]
- *  Logging function used by the minifier for warnings/errors/info.
- *  You can directly provide `console.log`, but `message` may also be an `Error`
- *  object or other non-string value.
- *
- *  Default: `() => {}` (no-op function)
- *
- * @prop {number} [maxInputLength]
- *  The maximum allowed input length. Used as a guard against ReDoS via
- *  pathological inputs. If the input exceeds this length an error is
- *  thrown.
- *
- *  Default: No limit
- *
- * @prop {number} [maxLineLength]
- *  Maximum line length for the output. When set the minifier will wrap
- *  output to the given number of characters where possible.
- *
- *  Default: No limit
- *
- * @prop {boolean | Partial<import("lightningcss").TransformOptions<import("lightningcss").CustomAtRules>> | ((text: string, type?: string) => Promise<string> | string)} [minifyCSS]
- *  When true, enables CSS minification for inline `<style>` tags or
- *  `style` attributes. If an object is provided, it is passed to
- *  [Lightning CSS](https://www.npmjs.com/package/lightningcss)
- *  as transform options. If a function is provided, it will be used to perform
- *  custom CSS minification. If disabled, CSS is not minified.
- *
- *  Default: `false`
- *
- * @prop {boolean | import("terser").MinifyOptions | ((text: string, inline?: boolean) => Promise<string> | string)} [minifyJS]
- *  When true, enables JS minification for `<script>` contents and
- *  event handler attributes. If an object is provided, it is passed to
- *  [terser](https://www.npmjs.com/package/terser) as minify options.
- *  If a function is provided, it will be used to perform
- *  custom JS minification. If disabled, JS is not minified.
- *
- *  Default: `false`
- *
- * @prop {boolean | string | import("relateurl").Options | ((text: string) => Promise<string> | string)} [minifyURLs]
- *  When true, enables URL rewriting/minification. If an object is provided,
- *  it is passed to [relateurl](https://www.npmjs.com/package/relateurl)
- *  as options. If a string is provided, it is treated as an `{ site: string }`
- *  options object. If a function is provided, it will be used to perform
- *  custom URL minification. If disabled, URLs are not minified.
- *
- *  Default: `false`
- *
- * @prop {(name: string) => string} [name]
- *  Function used to normalise tag/attribute names. By default, this lowercases
- *  names, unless `caseSensitive` is enabled.
- *
- *  Default: `(name) => name.toLowerCase()`,
- *  or `(name) => name` (no-op function) if `caseSensitive` is enabled.
- *
- * @prop {boolean} [noNewlinesBeforeTagClose]
- *  When wrapping lines, prevent inserting a newline directly before a
- *  closing tag (useful to keep tags like `</a>` on the same line).
- *
- *  Default: `false`
- *
- * @prop {boolean} [partialMarkup]
- *  When true, treat input as a partial HTML fragment rather than a complete
- *  document. This preserves stray end tags (closing tags without corresponding
- *  opening tags) and prevents auto-closing of unclosed tags at the end of input.
- *  Useful for minifying template fragments, SSI includes, or other partial HTML
- *  that will be combined with other fragments.
- *
- *  Default: `false`
- *
- * @prop {boolean} [preserveLineBreaks]
- *  Preserve a single line break at the start/end of text nodes when
- *  collapsing/trimming whitespace.
- *  Must also enable `collapseWhitespace` to have effect.
- *
- *  Default: `false`
- *
- * @prop {boolean} [preventAttributesEscaping]
- *  When true, attribute values will not be HTML-escaped (dangerous for
- *  untrusted input). By default, attributes are escaped.
- *
- *  Default: `false`
- *
- * @prop {boolean} [processConditionalComments]
- *  When true, conditional comments (for example `<!--[if IE]> … <![endif]-->`)
- *  will have their inner content processed by the minifier.
- *  Useful to minify HTML that appears inside conditional comments.
- *
- *  Default: `false`
- *
- * @prop {string[]} [processScripts]
- *  Array of `type` attribute values for `<script>` elements whose contents
- *  should be processed as HTML
- *  (e.g. `text/ng-template`, `text/x-handlebars-template`, etc.).
- *  When present, the contents of matching script tags are recursively minified,
- *  like normal HTML content.
- *
- *  Default: `[]`
- *
- * @prop {"\"" | "'"} [quoteCharacter]
- *  Preferred quote character for attribute values. If unspecified the
- *  minifier picks the safest quote based on the attribute value.
- *
- *  Default: Auto-detected
- *
- * @prop {boolean} [removeAttributeQuotes]
- *  Remove quotes around attribute values where it is safe to do so.
- *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#remove_attribute_quotes
- *
- *  Default: `false`
- *
- * @prop {boolean} [removeComments]
- *  Remove HTML comments. Comments that match `ignoreCustomComments` will
- *  still be preserved.
- *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#remove_comments
- *
- *  Default: `false`
- *
- * @prop {boolean | ((attrName: string, tag: string) => boolean)} [removeEmptyAttributes]
- *  If true, removes attributes whose values are empty (some attributes
- *  are excluded by name). Can also be a function to customise which empty
- *  attributes are removed.
- *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#remove_empty_or_blank_attributes
- *
- *  Default: `false`
- *
- * @prop {boolean} [removeEmptyElements]
- *  Remove elements that are empty and safe to remove (for example
- *  `<script />` without `src`).
- *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#remove_empty_elements
- *
- *  Default: `false`
- *
- * @prop {string[]} [removeEmptyElementsExcept]
- *  Specifies empty elements to preserve when `removeEmptyElements` is enabled.
- *  Has no effect unless `removeEmptyElements: true`.
- *
- *  Accepts tag names or HTML-like element specifications:
- *
- *  * Tag name only: `["td", "span"]`—preserves all empty elements of these types
- *  * With valued attributes: `["<span aria-hidden='true'>"]`—preserves only when attribute values match
- *  * With boolean attributes: `["<input disabled>"]`—preserves only when boolean attribute is present
- *  * Mixed: `["<button type='button' disabled>"]`—all specified attributes must match
- *
- *  Attribute matching:
- *
- *  * All specified attributes must be present and match (valued attributes must have exact values)
- *  * Additional attributes on the element are allowed
- *  * Attribute name matching respects the `caseSensitive` option
- *  * Supports double quotes, single quotes, and unquoted attribute values in specifications
- *
- *  Limitations:
- *
- *  * Self-closing syntax (e.g., `["<span/>"]`) is not supported; use `["span"]` instead
- *  * Definitions containing `>` within quoted attribute values (e.g., `["<span title='a>b'>"]`) are not supported
- *
- *  Default: `[]`
- *
- * @prop {boolean} [removeOptionalTags]
- *  Drop optional start/end tags where the HTML specification permits it
- *  (for example `</li>`, optional `<html>` etc.).
- *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#remove_optional_tags
- *
- *  Default: `false`
- *
- * @prop {boolean} [removeRedundantAttributes]
- *  Remove attributes that are redundant because they match the element’s
- *  default values (for example `<button type="submit">`).
- *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#remove_redundant_attributes
- *
- *  Default: `false`
- *
- * @prop {boolean} [removeScriptTypeAttributes]
- *  Remove `type` attributes from `<script>` when they are unnecessary
- *  (e.g. `type="text/javascript"`).
- *
- *  Default: `false`
- *
- * @prop {boolean} [removeStyleLinkTypeAttributes]
- *  Remove `type` attributes from `<style>` and `<link>` elements when
- *  they are unnecessary (e.g. `type="text/css"`).
- *
- *  Default: `false`
- *
- * @prop {boolean} [removeTagWhitespace]
- *  **Note that this will result in invalid HTML!**
- *
- *  When true, extra whitespace between tag name and attributes (or before
- *  the closing bracket) will be removed where possible. Affects output spacing
- *  such as the space used in the short doctype representation.
- *
- *  Default: `false`
- *
- * @prop {boolean | ((tag: string, attrs: HTMLAttribute[]) => void)} [sortAttributes]
- *  When true, enables sorting of attributes. If a function is provided it
- *  will be used as a custom attribute sorter, which should mutate `attrs`
- *  in-place to the desired order. If disabled, the minifier will attempt to
- *  preserve the order from the input.
- *
- *  Default: `false`
- *
- * @prop {boolean | ((value: string) => string)} [sortClassName]
- *  When true, enables sorting of class names inside `class` attributes.
- *  If a function is provided it will be used to transform/sort the class
- *  name string. If disabled, the minifier will attempt to preserve the
- *  class-name order from the input.
- *
- *  Default: `false`
- *
- * @prop {boolean} [trimCustomFragments]
- *  When true, whitespace around ignored custom fragments may be trimmed
- *  more aggressively. This affects how preserved fragments interact with
- *  surrounding whitespace collapse.
- *
- *  Default: `false`
- *
- * @prop {boolean} [useShortDoctype]
- *  Replace the HTML doctype with the short `<!doctype html>` form.
- *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#use_short_doctype
- *
- *  Default: `false`
- */
+  str.replace(regex, (match, ...args) => {
+    const promise = asyncFn(match, ...args);
+    promises.push(promise);
+  });
+
+  const data = await Promise.all(promises);
+  return str.replace(regex, () => data.shift());
+}
+
+// RegExp patterns (to avoid repeated allocations in hot paths)
 
-// Hoisted, reusable RegExp patterns and tiny helpers to avoid repeated allocations in hot paths
 const RE_WS_START = /^[ \n\r\t\f]+/;
 const RE_WS_END = /[ \n\r\t\f]+$/;
 const RE_ALL_WS_NBSP = /[ \n\r\t\f\xA0]+/g;
@@ -1223,74 +893,194 @@ const RE_CAN_REMOVE_ATTR_QUOTES = /^[^ \t\n\f\r"'`=<>]+$/;
 const RE_TRAILING_SEMICOLON = /;$/;
 const RE_AMP_ENTITY = /&(#?[0-9a-zA-Z]+;)/g;
 
-// Tiny stable stringify for options signatures (sorted keys, shallow, nested objects)
-function stableStringify(obj) {
-  if (obj == null || typeof obj !== 'object') return JSON.stringify(obj);
-  if (Array.isArray(obj)) return '[' + obj.map(stableStringify).join(',') + ']';
-  const keys = Object.keys(obj).sort();
-  let out = '{';
-  for (let i = 0; i < keys.length; i++) {
-    const k = keys[i];
-    out += JSON.stringify(k) + ':' + stableStringify(obj[k]) + (i < keys.length - 1 ? ',' : '');
-  }
-  return out + '}';
-}
+// Inline element Sets for whitespace handling
 
-// Minimal LRU cache for strings and promises
-class LRU {
-  constructor(limit = 200) {
-    this.limit = limit;
-    this.map = new Map();
-  }
-  get(key) {
-    const v = this.map.get(key);
-    if (v !== undefined) {
-      this.map.delete(key);
-      this.map.set(key, v);
-    }
-    return v;
-  }
-  set(key, value) {
-    if (this.map.has(key)) this.map.delete(key);
-    this.map.set(key, value);
-    if (this.map.size > this.limit) {
-      const first = this.map.keys().next().value;
-      this.map.delete(first);
-    }
-  }
-  delete(key) { this.map.delete(key); }
-}
+// 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']);
 
-// Per-process caches
-const jsMinifyCache = new LRU(200);
-const cssMinifyCache = new LRU(200);
+// Non-empty elements that will maintain whitespace within them
+const inlineElementsToKeepWhitespaceWithin = new Set(['a', 'abbr', 'acronym', 'b', 'big', 'del', 'em', 'font', 'i', 'ins', 'kbd', 'mark', 'nobr', 's', 'samp', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'time', 'tt', 'u', 'var']);
 
-const trimWhitespace = str => {
-  if (!str) return str;
-  // Fast path: If no whitespace at start or end, return early
-  if (!/^[ \n\r\t\f]/.test(str) && !/[ \n\r\t\f]$/.test(str)) {
-    return str;
-  }
-  return str.replace(RE_WS_START, '').replace(RE_WS_END, '');
+// Elements that will always maintain whitespace around them
+const inlineElementsToKeepWhitespace = new Set(['comment', 'img', 'input', 'wbr']);
+
+// Default attribute values
+
+// Default attribute values (could apply to any element)
+const generalDefaults = {
+  autocorrect: 'on',
+  fetchpriority: 'auto',
+  loading: 'eager',
+  popovertargetaction: 'toggle'
 };
 
+// Tag-specific default attribute values
+const tagDefaults = {
+  area: { shape: 'rect' },
+  button: { type: 'submit' },
+  form: {
+    enctype: 'application/x-www-form-urlencoded',
+    method: 'get'
+  },
+  html: { dir: 'ltr' },
+  img: { decoding: 'auto' },
+  input: {
+    colorspace: 'limited-srgb',
+    type: 'text'
+  },
+  marquee: {
+    behavior: 'scroll',
+    direction: 'left'
+  },
+  style: { media: 'all' },
+  textarea: { wrap: 'soft' },
+  track: { kind: 'subtitles' }
+};
+
+// Script MIME types
+
+// https://mathiasbynens.be/demo/javascript-mime-type
+// https://developer.mozilla.org/en/docs/Web/HTML/Element/script#attr-type
+const executableScriptsMimetypes = new Set([
+  'text/javascript',
+  'text/ecmascript',
+  'text/jscript',
+  'application/javascript',
+  'application/x-javascript',
+  'application/ecmascript',
+  'module'
+]);
+
+const keepScriptsMimetypes = new Set([
+  'module'
+]);
+
+// 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
+
+const srcsetTags = new Set(['img', 'source']);
+
+// JSON script types
+
+const jsonScriptTypes = new Set([
+  'application/json',
+  'application/ld+json',
+  'application/manifest+json',
+  'application/vnd.geo+json',
+  'application/problem+json',
+  'application/merge-patch+json',
+  'application/json-patch+json',
+  'importmap',
+  'speculationrules',
+]);
+
+// 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>`
+// - `<rb>`, `<rt>`, `<rtc>`, `<rp>` follow HTML Ruby Markup Extensions draft (https://www.w3.org/TR/html-ruby-extensions/)
+// - retain all tags which are adjacent to non-standard HTML tags
+
+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 descriptionTags = 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 pInlineTags = 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 tableContentTags = new Set(['tbody', 'tfoot']);
+
+const tableSectionTags = new Set(['thead', 'tbody', 'tfoot']);
+
+const cellTags = new Set(['td', 'th']);
+
+const topLevelTags = new Set(['html', 'head', 'body']);
+
+const compactTags = new Set(['html', 'body']);
+
+const looseTags = new Set(['head', 'colgroup', 'caption']);
+
+const trailingTags = 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']);
+
+// Empty attribute regex
+
+const reEmptyAttribute = new RegExp(
+  '^(?:class|id|style|title|lang|dir|on(?:focus|blur|change|click|dblclick|mouse(' +
+  '?:down|up|over|move|out)|key(?:press|down|up)))$');
+
+// Special content elements
+
+const specialContentTags = new Set(['script', 'style']);
+
+// Imports
+
+
+// Trim whitespace
+
+const trimWhitespace = str => {
+  if (!str) return str;
+  // Fast path: If no whitespace at start or end, return early
+  if (!/^[ \n\r\t\f]/.test(str) && !/[ \n\r\t\f]$/.test(str)) {
+    return str;
+  }
+  return str.replace(RE_WS_START, '').replace(RE_WS_END, '');
+};
+
+// Collapse all whitespace
+
 function collapseWhitespaceAll(str) {
   if (!str) return str;
   // Fast path: If there are no common whitespace characters, return early
   if (!/[ \n\r\t\f\xA0]/.test(str)) {
     return str;
   }
-  // Non-breaking space is specifically handled inside the replacer function here:
+  // No-break space is specifically handled inside the replacer function here:
   return str.replace(RE_ALL_WS_NBSP, function (spaces) {
-    return spaces === '\t' ? '\t' : spaces.replace(RE_NBSP_LEADING_GROUP, '$1 ');
+    // Preserve standalone tabs
+    if (spaces === '\t') return '\t';
+    // Fast path: No no-break space, common case—just collapse to single space
+    // This avoids the nested regex for the majority of cases
+    if (spaces.indexOf('\xA0') === -1) return ' ';
+    // For no-break space handling, use the original regex approach
+    return spaces.replace(RE_NBSP_LEADING_GROUP, '$1 ');
   });
 }
 
+// Collapse whitespace with options
+
 function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll) {
   let lineBreakBefore = ''; let lineBreakAfter = '';
 
   if (!str) return str;
 
+  // Fast path: Nothing to do
+  if (!trimLeft && !trimRight && !collapseAll && !options.preserveLineBreaks) {
+    return str;
+  }
+
+  // Fast path: No whitespace at all
+  if (!/[ \n\r\t\f\xA0]/.test(str)) {
+    return str;
+  }
+
   if (options.preserveLineBreaks) {
     str = str.replace(/^[ \n\r\t\f]*?[\n\r][ \n\r\t\f]*/, function () {
       lineBreakBefore = '\n';
@@ -1302,7 +1092,7 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll) {
   }
 
   if (trimLeft) {
-    // Non-breaking space is specifically handled inside the replacer function here:
+    // Non-breaking 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') {
@@ -1313,7 +1103,7 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll) {
   }
 
   if (trimRight) {
-    // Non-breaking space is specifically handled inside the replacer function here:
+    // Non-breaking 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') {
@@ -1328,15 +1118,14 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll) {
     str = collapseWhitespaceAll(str);
   }
 
+  // Avoid string concatenation when no line breaks (common case)
+  if (!lineBreakBefore && !lineBreakAfter) return str;
+  if (!lineBreakBefore) return str + lineBreakAfter;
+  if (!lineBreakAfter) return lineBreakBefore + str;
   return lineBreakBefore + str + lineBreakAfter;
 }
 
-// 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']);
-// Non-empty elements that will maintain whitespace within them
-const inlineElementsToKeepWhitespaceWithin = new Set(['a', 'abbr', 'acronym', 'b', 'big', 'del', 'em', 'font', 'i', 'ins', 'kbd', 'mark', 'nobr', 's', 'samp', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'time', 'tt', 'u', 'var']);
-// Elements that will always maintain whitespace around them
-const inlineElementsToKeepWhitespace = new Set(['comment', 'img', 'input', 'wbr']);
+// Collapse whitespace smartly based on surrounding tags
 
 function collapseWhitespaceSmart(str, prevTag, nextTag, options, inlineElements, inlineTextSet) {
   let trimLeft = prevTag && !inlineElementsToKeepWhitespace.has(prevTag);
@@ -1350,507 +1139,528 @@ function collapseWhitespaceSmart(str, prevTag, nextTag, options, inlineElements,
   return collapseWhitespace(str, options, trimLeft, trimRight, prevTag && nextTag);
 }
 
-function isConditionalComment(text) {
-  return RE_CONDITIONAL_COMMENT.test(text);
+// Collapse/trim whitespace for given tag
+
+function canCollapseWhitespace(tag) {
+  return !/^(?:script|style|pre|textarea)$/.test(tag);
 }
 
-function isIgnoredComment(text, options) {
-  for (let i = 0, len = options.ignoreCustomComments.length; i < len; i++) {
-    if (options.ignoreCustomComments[i].test(text)) {
-      return true;
+function canTrimWhitespace(tag) {
+  return !/^(?:pre|textarea)$/.test(tag);
+}
+
+// Imports
+
+
+// CSS processing
+
+// Wrap CSS declarations for inline styles and media queries
+// This ensures proper context for CSS minification
+
+function wrapCSS(text, type) {
+  switch (type) {
+    case 'inline':
+      return '*{' + text + '}';
+    case 'media':
+      return '@media ' + text + '{a{top:0}}';
+    default:
+      return text;
+  }
+}
+
+function unwrapCSS(text, type) {
+  let matches;
+  switch (type) {
+    case 'inline':
+      matches = text.match(/^\*\{([\s\S]*)\}$/);
+      break;
+    case 'media':
+      matches = text.match(/^@media ([\s\S]*?)\s*{[\s\S]*}$/);
+      break;
+  }
+  return matches ? matches[1] : text;
+}
+
+async function cleanConditionalComment(comment, options, minifyHTML) {
+  return options.processConditionalComments
+    ? await replaceAsync(comment, /^(\[if\s[^\]]+]>)([\s\S]*?)(<!\[endif])$/, async function (match, prefix, text, suffix) {
+      return prefix + await minifyHTML(text, options, true) + suffix;
+    })
+    : comment;
+}
+
+// Script processing
+
+function minifyJson(text, options) {
+  try {
+    return JSON.stringify(JSON.parse(text));
+  }
+  catch (err) {
+    if (!options.continueOnMinifyError) {
+      throw err;
     }
+    options.log && options.log(err);
+    return text;
   }
-  return false;
 }
 
-function isEventAttribute(attrName, options) {
-  const patterns = options.customEventAttributes;
-  if (patterns) {
-    for (let i = patterns.length; i--;) {
-      if (patterns[i].test(attrName)) {
+function hasJsonScriptType(attrs) {
+  for (let i = 0, len = attrs.length; i < len; i++) {
+    const attrName = attrs[i].name.toLowerCase();
+    if (attrName === 'type') {
+      const attrValue = trimWhitespace((attrs[i].value || '').split(/;/, 2)[0]).toLowerCase();
+      if (jsonScriptTypes.has(attrValue)) {
         return true;
       }
     }
-    return false;
   }
-  return RE_EVENT_ATTR_DEFAULT.test(attrName);
-}
-
-function canRemoveAttributeQuotes(value) {
-  // https://mathiasbynens.be/notes/unquoted-attribute-values
-  return RE_CAN_REMOVE_ATTR_QUOTES.test(value);
+  return false;
 }
 
-function attributesInclude(attributes, attribute) {
-  for (let i = attributes.length; i--;) {
-    if (attributes[i].name.toLowerCase() === attribute) {
-      return true;
+async function processScript(text, options, currentAttrs, minifyHTML) {
+  for (let i = 0, len = currentAttrs.length; i < len; i++) {
+    const attrName = currentAttrs[i].name.toLowerCase();
+    if (attrName === 'type') {
+      const rawValue = currentAttrs[i].value;
+      const normalizedValue = trimWhitespace((rawValue || '').split(/;/, 2)[0]).toLowerCase();
+      // Minify JSON script types automatically
+      if (jsonScriptTypes.has(normalizedValue)) {
+        return minifyJson(text, options);
+      }
+      // Process custom script types if specified
+      if (options.processScripts && options.processScripts.indexOf(rawValue) > -1) {
+        return await minifyHTML(text, options);
+      }
     }
   }
-  return false;
+  return text;
 }
 
-// Default attribute values (could apply to any element)
-const generalDefaults = {
-  autocorrect: 'on',
-  fetchpriority: 'auto',
-  loading: 'eager',
-  popovertargetaction: 'toggle'
-};
+// Imports
 
-// Tag-specific default attribute values
-const tagDefaults = {
-  area: { shape: 'rect' },
-  button: { type: 'submit' },
-  form: {
-    enctype: 'application/x-www-form-urlencoded',
-    method: 'get'
-  },
-  html: { dir: 'ltr' },
-  img: { decoding: 'auto' },
-  input: {
-    colorspace: 'limited-srgb',
-    type: 'text'
-  },
-  marquee: {
-    behavior: 'scroll',
-    direction: 'left'
-  },
-  style: { media: 'all' },
-  textarea: { wrap: 'soft' },
-  track: { kind: 'subtitles' }
-};
-
-function isAttributeRedundant(tag, attrName, attrValue, attrs) {
-  attrValue = attrValue ? trimWhitespace(attrValue.toLowerCase()) : '';
-
-  // Legacy attributes
-  if (tag === 'script' && attrName === 'language' && attrValue === 'javascript') {
-    return true;
-  }
-  if (tag === 'script' && attrName === 'charset' && !attributesInclude(attrs, 'src')) {
-    return true;
-  }
-  if (tag === 'a' && attrName === 'name' && attributesInclude(attrs, 'id')) {
-    return true;
-  }
 
-  // Check general defaults
-  if (generalDefaults[attrName] === attrValue) {
-    return true;
-  }
+// Helper functions
 
-  // Check tag-specific defaults
-  return tagDefaults[tag]?.[attrName] === attrValue;
+function shouldMinifyInnerHTML(options) {
+  return Boolean(
+    options.collapseWhitespace ||
+    options.removeComments ||
+    options.removeOptionalTags ||
+    options.minifyJS !== identity ||
+    options.minifyCSS !== identityAsync ||
+    options.minifyURLs !== identity
+  );
 }
 
-// https://mathiasbynens.be/demo/javascript-mime-type
-// https://developer.mozilla.org/en/docs/Web/HTML/Element/script#attr-type
-const executableScriptsMimetypes = new Set([
-  'text/javascript',
-  'text/ecmascript',
-  'text/jscript',
-  'application/javascript',
-  'application/x-javascript',
-  'application/ecmascript',
-  'module'
-]);
+// Main options processor
 
-const keepScriptsMimetypes = new Set([
-  'module'
-]);
+/**
+ * @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 {LRU} deps.cssMinifyCache - CSS minification cache
+ * @param {LRU} deps.jsMinifyCache - JS minification cache
+ * @returns {MinifierOptions} Normalized options with defaults applied
+ */
+const processOptions = (inputOptions, { getLightningCSS, getTerser, cssMinifyCache, jsMinifyCache } = {}) => {
+  const options = {
+    name: function (name) {
+      return name.toLowerCase();
+    },
+    canCollapseWhitespace,
+    canTrimWhitespace,
+    continueOnMinifyError: true,
+    html5: true,
+    ignoreCustomComments: [
+      /^!/,
+      /^\s*#/
+    ],
+    ignoreCustomFragments: [
+      /<%[\s\S]*?%>/,
+      /<\?[\s\S]*?\?>/
+    ],
+    includeAutoGeneratedTags: true,
+    log: identity,
+    minifyCSS: identityAsync,
+    minifyJS: identity,
+    minifyURLs: identity
+  };
 
-function isScriptTypeAttribute(attrValue = '') {
-  attrValue = trimWhitespace(attrValue.split(/;/, 2)[0]).toLowerCase();
-  return attrValue === '' || executableScriptsMimetypes.has(attrValue);
-}
+  Object.keys(inputOptions).forEach(function (key) {
+    const option = inputOptions[key];
 
-function keepScriptTypeAttribute(attrValue = '') {
-  attrValue = trimWhitespace(attrValue.split(/;/, 2)[0]).toLowerCase();
-  return keepScriptsMimetypes.has(attrValue);
-}
+    if (key === 'caseSensitive') {
+      if (option) {
+        options.name = identity;
+      }
+    } else if (key === 'log') {
+      if (typeof option === 'function') {
+        options.log = option;
+      }
+    } else if (key === 'minifyCSS' && typeof option !== 'function') {
+      if (!option) {
+        return;
+      }
 
-function isExecutableScript(tag, attrs) {
-  if (tag !== 'script') {
-    return false;
-  }
-  for (let i = 0, len = attrs.length; i < len; i++) {
-    const attrName = attrs[i].name.toLowerCase();
-    if (attrName === 'type') {
-      return isScriptTypeAttribute(attrs[i].value);
-    }
-  }
-  return true;
-}
+      const lightningCssOptions = typeof option === 'object' ? option : {};
 
-function isStyleLinkTypeAttribute(attrValue = '') {
-  attrValue = trimWhitespace(attrValue).toLowerCase();
-  return attrValue === '' || attrValue === 'text/css';
-}
+      options.minifyCSS = async function (text, type) {
+        // Fast path: Nothing to minify
+        if (!text || !text.trim()) {
+          return text;
+        }
+        text = await replaceAsync(
+          text,
+          /(url\s*\(\s*)(?:"([^"]*)"|'([^']*)'|([^\s)]+))(\s*\))/ig,
+          async function (match, prefix, dq, sq, unq, suffix) {
+            const quote = dq != null ? '"' : (sq != null ? "'" : '');
+            const url = dq ?? sq ?? unq ?? '';
+            try {
+              const out = await options.minifyURLs(url);
+              return prefix + quote + (typeof out === 'string' ? out : url) + quote + suffix;
+            } catch (err) {
+              if (!options.continueOnMinifyError) {
+                throw err;
+              }
+              options.log && options.log(err);
+              return match;
+            }
+          }
+        );
+        // Cache key: Wrapped content, type, options signature
+        const inputCSS = wrapCSS(text, type);
+        const cssSig = stableStringify({ type, opts: lightningCssOptions, cont: !!options.continueOnMinifyError });
+        // For large inputs, use length and content fingerprint (first/last 50 chars) to prevent collisions
+        const cssKey = inputCSS.length > 2048
+          ? (inputCSS.length + '|' + inputCSS.slice(0, 50) + inputCSS.slice(-50) + '|' + type + '|' + cssSig)
+          : (inputCSS + '|' + type + '|' + cssSig);
 
-function isStyleSheet(tag, attrs) {
-  if (tag !== 'style') {
-    return false;
-  }
-  for (let i = 0, len = attrs.length; i < len; i++) {
-    const attrName = attrs[i].name.toLowerCase();
-    if (attrName === 'type') {
-      return isStyleLinkTypeAttribute(attrs[i].value);
-    }
-  }
-  return true;
-}
+        try {
+          const cached = cssMinifyCache.get(cssKey);
+          if (cached) {
+            return cached;
+          }
 
-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']);
+          const transformCSS = await getLightningCSS();
+          const result = transformCSS({
+            filename: 'input.css',
+            code: Buffer.from(inputCSS),
+            minify: true,
+            errorRecovery: !!options.continueOnMinifyError,
+            ...lightningCssOptions
+          });
 
-function isBooleanAttribute(attrName, attrValue) {
-  return isSimpleBoolean.has(attrName) || (attrName === 'draggable' && !isBooleanValue.has(attrValue));
-}
+          const outputCSS = unwrapCSS(result.code.toString(), type);
 
-function isUriTypeAttribute(attrName, tag) {
-  return (
-    (/^(?:a|area|link|base)$/.test(tag) && attrName === 'href') ||
-    (tag === 'img' && /^(?:src|longdesc|usemap)$/.test(attrName)) ||
-    (tag === 'object' && /^(?:classid|codebase|data|usemap)$/.test(attrName)) ||
-    (tag === 'q' && attrName === 'cite') ||
-    (tag === 'blockquote' && attrName === 'cite') ||
-    ((tag === 'ins' || tag === 'del') && attrName === 'cite') ||
-    (tag === 'form' && attrName === 'action') ||
-    (tag === 'input' && (attrName === 'src' || attrName === 'usemap')) ||
-    (tag === 'head' && attrName === 'profile') ||
-    (tag === 'script' && (attrName === 'src' || attrName === 'for'))
-  );
-}
+          // If Lightning CSS removed significant content that looks like template syntax or UIDs, return original
+          // This preserves:
+          // 1. Template code like `<?php ?>`, `<%= %>`, `{{ }}`, etc. (contain `<` or `>` but not `CDATA`)
+          // 2. UIDs representing custom fragments (only lowercase letters and digits, no spaces)
+          // CDATA sections, HTML entities, and other invalid CSS are allowed to be removed
+          const isCDATA = text.includes('<![CDATA[');
+          const uidPattern = /[a-z0-9]{10,}/; // UIDs are long alphanumeric strings
+          const hasUID = uidPattern.test(text) && !isCDATA; // Exclude CDATA from UID detection
+          const looksLikeTemplate = (text.includes('<') || text.includes('>')) && !isCDATA;
 
-function isNumberTypeAttribute(attrName, tag) {
-  return (
-    (/^(?:a|area|object|button)$/.test(tag) && attrName === 'tabindex') ||
-    (tag === 'input' && (attrName === 'maxlength' || attrName === 'tabindex')) ||
-    (tag === 'select' && (attrName === 'size' || attrName === 'tabindex')) ||
-    (tag === 'textarea' && /^(?:rows|cols|tabindex)$/.test(attrName)) ||
-    (tag === 'colgroup' && attrName === 'span') ||
-    (tag === 'col' && attrName === 'span') ||
-    ((tag === 'th' || tag === 'td') && (attrName === 'rowspan' || attrName === 'colspan'))
-  );
-}
+          // Preserve if output is empty and input had template syntax or UIDs
+          // This catches cases where Lightning CSS removed content that should be preserved
+          const finalOutput = (text.trim() && !outputCSS.trim() && (looksLikeTemplate || hasUID)) ? text : outputCSS;
 
-function isLinkType(tag, attrs, value) {
-  if (tag !== 'link') return false;
-  const needle = String(value).toLowerCase();
-  for (let i = 0; i < attrs.length; i++) {
-    if (attrs[i].name.toLowerCase() === 'rel') {
-      const tokens = String(attrs[i].value).toLowerCase().split(/\s+/);
-      if (tokens.includes(needle)) return true;
-    }
-  }
-  return false;
-}
+          cssMinifyCache.set(cssKey, finalOutput);
+          return finalOutput;
+        } catch (err) {
+          cssMinifyCache.delete(cssKey);
+          if (!options.continueOnMinifyError) {
+            throw err;
+          }
+          options.log && options.log(err);
+          return text;
+        }
+      };
+    } else if (key === 'minifyJS' && typeof option !== 'function') {
+      if (!option) {
+        return;
+      }
 
-function isMediaQuery(tag, attrs, attrName) {
-  return attrName === 'media' && (isLinkType(tag, attrs, 'stylesheet') || isStyleSheet(tag, attrs));
-}
+      const terserOptions = typeof option === 'object' ? option : {};
 
-const srcsetTags = new Set(['img', 'source']);
+      terserOptions.parse = {
+        ...terserOptions.parse,
+        bare_returns: false
+      };
 
-function isSrcset(attrName, tag) {
-  return attrName === 'srcset' && srcsetTags.has(tag);
-}
+      options.minifyJS = async function (text, inline) {
+        const start = text.match(/^\s*<!--.*/);
+        const code = start ? text.slice(start[0].length).replace(/\n\s*-->\s*$/, '') : text;
 
-async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTMLSelf) {
-  // Apply early whitespace normalization if enabled
-  // Preserves special spaces (non-breaking space, hair space, etc.) for consistency with `collapseWhitespace`
-  if (options.collapseAttributeWhitespace) {
-    attrValue = attrValue.replace(/[ \n\r\t\f]+/g, ' ').replace(/^[ \n\r\t\f]+|[ \n\r\t\f]+$/g, '');
-  }
+        terserOptions.parse.bare_returns = inline;
 
-  if (isEventAttribute(attrName, options)) {
-    attrValue = trimWhitespace(attrValue).replace(/^javascript:\s*/i, '');
-    return options.minifyJS(attrValue, true);
-  } else if (attrName === 'class') {
-    attrValue = trimWhitespace(attrValue);
-    if (options.sortClassName) {
-      attrValue = options.sortClassName(attrValue);
-    } else {
-      attrValue = collapseWhitespaceAll(attrValue);
-    }
-    return attrValue;
-  } else if (isUriTypeAttribute(attrName, tag)) {
-    attrValue = trimWhitespace(attrValue);
-    if (isLinkType(tag, attrs, 'canonical')) {
-      return attrValue;
-    }
-    try {
-      const out = await options.minifyURLs(attrValue);
-      return typeof out === 'string' ? out : attrValue;
-    } catch (err) {
-      if (!options.continueOnMinifyError) {
-        throw err;
+        let jsKey;
+        try {
+          // Fast path: Avoid invoking Terser for empty/whitespace-only content
+          if (!code || !code.trim()) {
+            return '';
+          }
+          // Cache key: content, inline, options signature (subset)
+          const terserSig = stableStringify({
+            compress: terserOptions.compress,
+            mangle: terserOptions.mangle,
+            ecma: terserOptions.ecma,
+            toplevel: terserOptions.toplevel,
+            module: terserOptions.module,
+            keep_fnames: terserOptions.keep_fnames,
+            format: terserOptions.format,
+            cont: !!options.continueOnMinifyError,
+          });
+          // For large inputs, use length and content fingerprint (first/last 50 chars) to prevent collisions
+          jsKey = (code.length > 2048 ? (code.length + '|' + code.slice(0, 50) + code.slice(-50) + '|') : (code + '|')) + (inline ? '1' : '0') + '|' + terserSig;
+          const cached = jsMinifyCache.get(jsKey);
+          if (cached) {
+            return await cached;
+          }
+          const inFlight = (async () => {
+            const terser = await getTerser();
+            const result = await terser(code, terserOptions);
+            return result.code.replace(RE_TRAILING_SEMICOLON, '');
+          })();
+          jsMinifyCache.set(jsKey, inFlight);
+          const resolved = await inFlight;
+          jsMinifyCache.set(jsKey, resolved);
+          return resolved;
+        } catch (err) {
+          if (jsKey) jsMinifyCache.delete(jsKey);
+          if (!options.continueOnMinifyError) {
+            throw err;
+          }
+          options.log && options.log(err);
+          return text;
+        }
+      };
+    } else if (key === 'minifyURLs' && typeof option !== 'function') {
+      if (!option) {
+        return;
       }
-      options.log && options.log(err);
-      return attrValue;
-    }
-  } else if (isNumberTypeAttribute(attrName, tag)) {
-    return trimWhitespace(attrValue);
-  } else if (attrName === 'style') {
-    attrValue = trimWhitespace(attrValue);
-    if (attrValue) {
-      if (attrValue.endsWith(';') && !/&#?[0-9a-zA-Z]+;$/.test(attrValue)) {
-        attrValue = attrValue.replace(/\s*;$/, ';');
+
+      let relateUrlOptions = option;
+
+      if (typeof option === 'string') {
+        relateUrlOptions = { site: option };
+      } else if (typeof option !== 'object') {
+        relateUrlOptions = {};
       }
-      attrValue = await options.minifyCSS(attrValue, 'inline');
-    }
-    return attrValue;
-  } else if (isSrcset(attrName, tag)) {
-    // https://html.spec.whatwg.org/multipage/embedded-content.html#attr-img-srcset
-    attrValue = (await Promise.all(trimWhitespace(attrValue).split(/\s+,\s*|\s*,\s+/).map(async function (candidate) {
-      let url = candidate;
-      let descriptor = '';
-      const match = candidate.match(/\s+([1-9][0-9]*w|[0-9]+(?:\.[0-9]+)?x)$/);
-      if (match) {
-        url = url.slice(0, -match[0].length);
-        const num = +match[1].slice(0, -1);
-        const suffix = match[1].slice(-1);
-        if (num !== 1 || suffix !== 'x') {
-          descriptor = ' ' + num + suffix;
+
+      // Cache RelateURL instance for reuse (expensive to create)
+      const relateUrlInstance = new RelateURL(relateUrlOptions.site || '', relateUrlOptions);
+
+      options.minifyURLs = function (text) {
+        // 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;
         }
-      }
-      try {
-        const out = await options.minifyURLs(url);
-        return (typeof out === 'string' ? out : url) + descriptor;
-      } catch (err) {
-        if (!options.continueOnMinifyError) {
-          throw err;
+
+        try {
+          return relateUrlInstance.relate(text);
+        } catch (err) {
+          if (!options.continueOnMinifyError) {
+            throw err;
+          }
+          options.log && options.log(err);
+          return text;
         }
-        options.log && options.log(err);
-        return url + descriptor;
-      }
-    }))).join(', ');
-  } else if (isMetaViewport(tag, attrs) && attrName === 'content') {
-    attrValue = attrValue.replace(/\s+/g, '').replace(/[0-9]+\.[0-9]+/g, function (numString) {
-      // “0.90000” → “0.9”
-      // “1.0” → “1”
-      // “1.0001” → “1.0001” (unchanged)
-      return (+numString).toString();
-    });
-  } else if (isContentSecurityPolicy(tag, attrs) && attrName.toLowerCase() === 'content') {
-    return collapseWhitespaceAll(attrValue);
-  } else if (options.customAttrCollapse && options.customAttrCollapse.test(attrName)) {
-    attrValue = trimWhitespace(attrValue.replace(/ ?[\n\r]+ ?/g, '').replace(/\s{2,}/g, options.conservativeCollapse ? ' ' : ''));
-  } else if (tag === 'script' && attrName === 'type') {
-    attrValue = trimWhitespace(attrValue.replace(/\s*;\s*/g, ';'));
-  } else if (isMediaQuery(tag, attrs, attrName)) {
-    attrValue = trimWhitespace(attrValue);
-    return options.minifyCSS(attrValue, 'media');
-  } else if (tag === 'iframe' && attrName === 'srcdoc') {
-    // Recursively minify HTML content within srcdoc attribute
-    // Fast-path: Skip if nothing would change
-    if (!shouldMinifyInnerHTML(options)) {
-      return attrValue;
+      };
+    } else {
+      options[key] = option;
     }
-    return minifyHTMLSelf(attrValue, options, true);
-  }
-  return attrValue;
+  });
+  return options;
+};
+
+// Imports
+
+
+// Validators
+
+function isConditionalComment(text) {
+  return RE_CONDITIONAL_COMMENT.test(text);
 }
 
-function isMetaViewport(tag, attrs) {
-  if (tag !== 'meta') {
-    return false;
-  }
-  for (let i = 0, len = attrs.length; i < len; i++) {
-    if (attrs[i].name === 'name' && attrs[i].value === 'viewport') {
+function isIgnoredComment(text, options) {
+  for (let i = 0, len = options.ignoreCustomComments.length; i < len; i++) {
+    if (options.ignoreCustomComments[i].test(text)) {
       return true;
     }
   }
+  return false;
 }
 
-function isContentSecurityPolicy(tag, attrs) {
-  if (tag !== 'meta') {
+function isEventAttribute(attrName, options) {
+  const patterns = options.customEventAttributes;
+  if (patterns) {
+    for (let i = patterns.length; i--;) {
+      if (patterns[i].test(attrName)) {
+        return true;
+      }
+    }
     return false;
   }
-  for (let i = 0, len = attrs.length; i < len; i++) {
-    if (attrs[i].name.toLowerCase() === 'http-equiv' && attrs[i].value.toLowerCase() === 'content-security-policy') {
+  return RE_EVENT_ATTR_DEFAULT.test(attrName);
+}
+
+function canRemoveAttributeQuotes(value) {
+  // https://mathiasbynens.be/notes/unquoted-attribute-values
+  return RE_CAN_REMOVE_ATTR_QUOTES.test(value);
+}
+
+function attributesInclude(attributes, attribute) {
+  for (let i = attributes.length; i--;) {
+    if (attributes[i].name.toLowerCase() === attribute) {
       return true;
     }
   }
+  return false;
 }
 
-// Wrap CSS declarations for inline styles and media queries
-// This ensures proper context for CSS minification
-function wrapCSS(text, type) {
-  switch (type) {
-    case 'inline':
-      return '*{' + text + '}';
-    case 'media':
-      return '@media ' + text + '{a{top:0}}';
-    default:
-      return text;
+function isAttributeRedundant(tag, attrName, attrValue, attrs) {
+  attrValue = attrValue ? trimWhitespace(attrValue.toLowerCase()) : '';
+
+  // Legacy attributes
+  if (tag === 'script' && attrName === 'language' && attrValue === 'javascript') {
+    return true;
+  }
+  if (tag === 'script' && attrName === 'charset' && !attributesInclude(attrs, 'src')) {
+    return true;
+  }
+  if (tag === 'a' && attrName === 'name' && attributesInclude(attrs, 'id')) {
+    return true;
   }
-}
 
-function unwrapCSS(text, type) {
-  let matches;
-  switch (type) {
-    case 'inline':
-      matches = text.match(/^\*\{([\s\S]*)\}$/);
-      break;
-    case 'media':
-      matches = text.match(/^@media ([\s\S]*?)\s*{[\s\S]*}$/);
-      break;
+  // Check general defaults
+  if (generalDefaults[attrName] === attrValue) {
+    return true;
   }
-  return matches ? matches[1] : text;
+
+  // Check tag-specific defaults
+  return tagDefaults[tag]?.[attrName] === attrValue;
 }
 
-async function cleanConditionalComment(comment, options) {
-  return options.processConditionalComments
-    ? await replaceAsync(comment, /^(\[if\s[^\]]+]>)([\s\S]*?)(<!\[endif])$/, async function (match, prefix, text, suffix) {
-      return prefix + await minifyHTML(text, options, true) + suffix;
-    })
-    : comment;
+function isScriptTypeAttribute(attrValue = '') {
+  attrValue = trimWhitespace(attrValue.split(/;/, 2)[0]).toLowerCase();
+  return attrValue === '' || executableScriptsMimetypes.has(attrValue);
 }
 
-const jsonScriptTypes = new Set([
-  'application/json',
-  'application/ld+json',
-  'application/manifest+json',
-  'application/vnd.geo+json',
-  'importmap',
-  'speculationrules',
-]);
+function keepScriptTypeAttribute(attrValue = '') {
+  attrValue = trimWhitespace(attrValue.split(/;/, 2)[0]).toLowerCase();
+  return keepScriptsMimetypes.has(attrValue);
+}
 
-function minifyJson(text, options) {
-  try {
-    return JSON.stringify(JSON.parse(text));
+function isExecutableScript(tag, attrs) {
+  if (tag !== 'script') {
+    return false;
   }
-  catch (err) {
-    if (!options.continueOnMinifyError) {
-      throw err;
+  for (let i = 0, len = attrs.length; i < len; i++) {
+    const attrName = attrs[i].name.toLowerCase();
+    if (attrName === 'type') {
+      return isScriptTypeAttribute(attrs[i].value);
     }
-    options.log && options.log(err);
-    return text;
   }
+  return true;
 }
 
-function hasJsonScriptType(attrs) {
+function isStyleLinkTypeAttribute(attrValue = '') {
+  attrValue = trimWhitespace(attrValue).toLowerCase();
+  return attrValue === '' || attrValue === 'text/css';
+}
+
+function isStyleSheet(tag, attrs) {
+  if (tag !== 'style') {
+    return false;
+  }
   for (let i = 0, len = attrs.length; i < len; i++) {
     const attrName = attrs[i].name.toLowerCase();
     if (attrName === 'type') {
-      const attrValue = trimWhitespace((attrs[i].value || '').split(/;/, 2)[0]).toLowerCase();
-      if (jsonScriptTypes.has(attrValue)) {
-        return true;
-      }
+      return isStyleLinkTypeAttribute(attrs[i].value);
     }
   }
-  return false;
+  return true;
 }
 
-async function processScript(text, options, currentAttrs) {
-  for (let i = 0, len = currentAttrs.length; i < len; i++) {
-    const attrName = currentAttrs[i].name.toLowerCase();
-    if (attrName === 'type') {
-      const rawValue = currentAttrs[i].value;
-      const normalizedValue = trimWhitespace((rawValue || '').split(/;/, 2)[0]).toLowerCase();
-      // Minify JSON script types automatically
-      if (jsonScriptTypes.has(normalizedValue)) {
-        return minifyJson(text, options);
-      }
-      // Process custom script types if specified
-      if (options.processScripts && options.processScripts.indexOf(rawValue) > -1) {
-        return await minifyHTML(text, options);
-      }
-    }
-  }
-  return text;
+function isBooleanAttribute(attrName, attrValue) {
+  return isSimpleBoolean.has(attrName) || (attrName === 'draggable' && !isBooleanValue.has(attrValue));
 }
 
-// Tag omission rules from https://html.spec.whatwg.org/multipage/syntax.html#optional-tags with the following extensions:
-// - retain `<body>` if followed by `<noscript>`
-// - `<rb>`, `<rt>`, `<rtc>`, `<rp>` follow HTML Ruby Markup Extensions draft (https://www.w3.org/TR/html-ruby-extensions/)
-// - retain all tags which are adjacent to non-standard HTML tags
-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 descriptionTags = 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 pInlineTags = 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 tableContentTags = new Set(['tbody', 'tfoot']);
-const tableSectionTags = new Set(['thead', 'tbody', 'tfoot']);
-const cellTags = new Set(['td', 'th']);
-const topLevelTags = new Set(['html', 'head', 'body']);
-const compactTags = new Set(['html', 'body']);
-const looseTags = new Set(['head', 'colgroup', 'caption']);
-const trailingTags = 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']);
+function isUriTypeAttribute(attrName, tag) {
+  return (
+    (/^(?:a|area|link|base)$/.test(tag) && attrName === 'href') ||
+    (tag === 'img' && /^(?:src|longdesc|usemap)$/.test(attrName)) ||
+    (tag === 'object' && /^(?:classid|codebase|data|usemap)$/.test(attrName)) ||
+    (tag === 'q' && attrName === 'cite') ||
+    (tag === 'blockquote' && attrName === 'cite') ||
+    ((tag === 'ins' || tag === 'del') && attrName === 'cite') ||
+    (tag === 'form' && attrName === 'action') ||
+    (tag === 'input' && (attrName === 'src' || attrName === 'usemap')) ||
+    (tag === 'head' && attrName === 'profile') ||
+    (tag === 'script' && (attrName === 'src' || attrName === 'for'))
+  );
+}
 
-function canRemoveParentTag(optionalStartTag, tag) {
-  switch (optionalStartTag) {
-    case 'html':
-    case 'head':
-      return true;
-    case 'body':
-      return !headerTags.has(tag);
-    case 'colgroup':
-      return tag === 'col';
-    case 'tbody':
-      return tag === 'tr';
+function isNumberTypeAttribute(attrName, tag) {
+  return (
+    (/^(?:a|area|object|button)$/.test(tag) && attrName === 'tabindex') ||
+    (tag === 'input' && (attrName === 'maxlength' || attrName === 'tabindex')) ||
+    (tag === 'select' && (attrName === 'size' || attrName === 'tabindex')) ||
+    (tag === 'textarea' && /^(?:rows|cols|tabindex)$/.test(attrName)) ||
+    (tag === 'colgroup' && attrName === 'span') ||
+    (tag === 'col' && attrName === 'span') ||
+    ((tag === 'th' || tag === 'td') && (attrName === 'rowspan' || attrName === 'colspan'))
+  );
+}
+
+function isLinkType(tag, attrs, value) {
+  if (tag !== 'link') return false;
+  const needle = String(value).toLowerCase();
+  for (let i = 0; i < attrs.length; i++) {
+    if (attrs[i].name.toLowerCase() === 'rel') {
+      const tokens = String(attrs[i].value).toLowerCase().split(/\s+/);
+      if (tokens.includes(needle)) return true;
+    }
   }
   return false;
 }
 
-function isStartTagMandatory(optionalEndTag, tag) {
-  switch (tag) {
-    case 'colgroup':
-      return optionalEndTag === 'colgroup';
-    case 'tbody':
-      return tableSectionTags.has(optionalEndTag);
+function isMediaQuery(tag, attrs, attrName) {
+  return attrName === 'media' && (isLinkType(tag, attrs, 'stylesheet') || isStyleSheet(tag, attrs));
+}
+
+function isSrcset(attrName, tag) {
+  return attrName === 'srcset' && srcsetTags.has(tag);
+}
+
+function isMetaViewport(tag, attrs) {
+  if (tag !== 'meta') {
+    return false;
+  }
+  for (let i = 0, len = attrs.length; i < len; i++) {
+    if (attrs[i].name === 'name' && attrs[i].value === 'viewport') {
+      return true;
+    }
   }
   return false;
 }
 
-function canRemovePrecedingTag(optionalEndTag, tag) {
-  switch (optionalEndTag) {
-    case 'html':
-    case 'head':
-    case 'body':
-    case 'colgroup':
-    case 'caption':
+function isContentSecurityPolicy(tag, attrs) {
+  if (tag !== 'meta') {
+    return false;
+  }
+  for (let i = 0, len = attrs.length; i < len; i++) {
+    if (attrs[i].name.toLowerCase() === 'http-equiv' && attrs[i].value.toLowerCase() === 'content-security-policy') {
       return true;
-    case 'li':
-    case 'optgroup':
-    case 'tr':
-      return tag === optionalEndTag;
-    case 'dt':
-    case 'dd':
-      return descriptionTags.has(tag);
-    case 'p':
-      return pBlockTags.has(tag);
-    case 'rb':
-    case 'rt':
-    case 'rp':
-      return rubyEndTagOmission.has(tag);
-    case 'rtc':
-      return rubyRtcEndTagOmission.has(tag);
-    case 'option':
-      return optionTag.has(tag);
-    case 'thead':
-    case 'tbody':
-      return tableContentTags.has(tag);
-    case 'tfoot':
-      return tag === 'tbody';
-    case 'td':
-    case 'th':
-      return cellTags.has(tag);
+    }
   }
   return false;
 }
 
-const reEmptyAttribute = new RegExp(
-  '^(?:class|id|style|title|lang|dir|on(?:focus|blur|change|click|dblclick|mouse(' +
-  '?:down|up|over|move|out)|key(?:press|down|up)))$');
-
 function canDeleteEmptyAttribute(tag, attrName, attrValue, options) {
   const isValueEmpty = !attrValue || /^\s*$/.test(attrValue);
   if (!isValueEmpty) {
@@ -1871,162 +1681,148 @@ function hasAttrName(name, attrs) {
   return false;
 }
 
-function canRemoveElement(tag, attrs) {
-  switch (tag) {
-    case 'textarea':
-      return false;
-    case 'audio':
-    case 'script':
-    case 'video':
-      if (hasAttrName('src', attrs)) {
-        return false;
+// Cleaners
+
+async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTMLSelf) {
+  // Apply early whitespace normalization if enabled
+  // Preserves special spaces (non-breaking space, hair space, etc.) for consistency with `collapseWhitespace`
+  if (options.collapseAttributeWhitespace) {
+    attrValue = attrValue.replace(/[ \n\r\t\f]+/g, ' ').replace(/^[ \n\r\t\f]+|[ \n\r\t\f]+$/g, '');
+  }
+
+  if (isEventAttribute(attrName, options)) {
+    attrValue = trimWhitespace(attrValue).replace(/^javascript:\s*/i, '');
+    try {
+      return await options.minifyJS(attrValue, true);
+    } catch (err) {
+      if (!options.continueOnMinifyError) {
+        throw err;
       }
-      break;
-    case 'iframe':
-      if (hasAttrName('src', attrs) || hasAttrName('srcdoc', attrs)) {
-        return false;
+      options.log && options.log(err);
+      return attrValue;
+    }
+  } else if (attrName === 'class') {
+    attrValue = trimWhitespace(attrValue);
+    if (options.sortClassName) {
+      attrValue = options.sortClassName(attrValue);
+    } else {
+      attrValue = collapseWhitespaceAll(attrValue);
+    }
+    return attrValue;
+  } else if (isUriTypeAttribute(attrName, tag)) {
+    attrValue = trimWhitespace(attrValue);
+    if (isLinkType(tag, attrs, 'canonical')) {
+      return attrValue;
+    }
+    try {
+      const out = await options.minifyURLs(attrValue);
+      return typeof out === 'string' ? out : attrValue;
+    } catch (err) {
+      if (!options.continueOnMinifyError) {
+        throw err;
       }
-      break;
-    case 'object':
-      if (hasAttrName('data', attrs)) {
-        return false;
+      options.log && options.log(err);
+      return attrValue;
+    }
+  } else if (isNumberTypeAttribute(attrName, tag)) {
+    return trimWhitespace(attrValue);
+  } else if (attrName === 'style') {
+    attrValue = trimWhitespace(attrValue);
+    if (attrValue) {
+      if (attrValue.endsWith(';') && !/&#?[0-9a-zA-Z]+;$/.test(attrValue)) {
+        attrValue = attrValue.replace(/\s*;$/, ';');
       }
-      break;
-    case 'applet':
-      if (hasAttrName('code', attrs)) {
-        return false;
+      try {
+        attrValue = await options.minifyCSS(attrValue, 'inline');
+      } catch (err) {
+        if (!options.continueOnMinifyError) {
+          throw err;
+        }
+        options.log && options.log(err);
       }
-      break;
-  }
-  return true;
-}
-
-/**
- * @param {string} str - Tag name or HTML-like element spec (e.g., “td” or “<span aria-hidden='true'>”)
- * @param {MinifierOptions} options - Options object for name normalization
- * @returns {{tag: string, attrs: Object.<string, string|undefined>|null}|null} Parsed spec or null if invalid
- */
-function parseElementSpec(str, options) {
-  if (typeof str !== 'string') {
-    return null;
-  }
-
-  const trimmed = str.trim();
-  if (!trimmed) {
-    return null;
-  }
-
-  // Simple tag name: “td”
-  if (!/[<>]/.test(trimmed)) {
-    return { tag: options.name(trimmed), attrs: null };
-  }
-
-  // HTML-like markup: “<span aria-hidden='true'>” or “<td></td>”
-  // Extract opening tag using regex
-  const match = trimmed.match(/^<([a-zA-Z][\w:-]*)((?:\s+[^>]*)?)>/);
-  if (!match) {
-    return null;
-  }
-
-  const tag = options.name(match[1]);
-  const attrString = match[2];
-
-  if (!attrString.trim()) {
-    return { tag, attrs: null };
-  }
-
-  // Parse attributes from string
-  const attrs = {};
-  const attrRegex = /([a-zA-Z][\w:-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>/]+)))?/g;
-  let attrMatch;
-
-  while ((attrMatch = attrRegex.exec(attrString))) {
-    const attrName = options.name(attrMatch[1]);
-    const attrValue = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4];
-    // Boolean attributes have no value (undefined)
-    attrs[attrName] = attrValue;
-  }
-
-  return {
-    tag,
-    attrs: Object.keys(attrs).length > 0 ? attrs : null
-  };
-}
-
-/**
- * @param {string[]} input - Array of element specifications from `removeEmptyElementsExcept` option
- * @param {MinifierOptions} options - Options object for parsing
- * @returns {Array<{tag: string, attrs: Object.<string, string|undefined>|null}>} Array of parsed element specs
- */
-function parseRemoveEmptyElementsExcept(input, options) {
-  if (!Array.isArray(input)) {
-    return [];
-  }
-
-  return input.map(item => {
-    if (typeof item === 'string') {
-      const spec = parseElementSpec(item, options);
-      if (!spec && options.log) {
-        options.log('Warning: Unable to parse “removeEmptyElementsExcept” specification: "' + item + '"');
-      }
-      return spec;
-    }
-    if (options.log) {
-      options.log('Warning: “removeEmptyElementsExcept” specification must be a string, received: ' + typeof item);
-    }
-    return null;
-  }).filter(Boolean);
-}
-
-/**
- * @param {string} tag - Element tag name
- * @param {HTMLAttribute[]} attrs - Array of element attributes
- * @param {Array<{tag: string, attrs: Object.<string, string|undefined>|null}>} preserveList - Parsed preserve specs
- * @returns {boolean} True if the empty element should be preserved
- */
-function shouldPreserveEmptyElement(tag, attrs, preserveList) {
-  for (const spec of preserveList) {
-    // Tag name must match
-    if (spec.tag !== tag) {
-      continue;
-    }
-
-    // If no attributes specified in spec, tag match is enough
-    if (!spec.attrs) {
-      return true;
     }
-
-    // Check if all specified attributes match
-    const allAttrsMatch = Object.entries(spec.attrs).every(([name, value]) => {
-      const attr = attrs.find(a => a.name === name);
-      if (!attr) {
-        return false; // Attribute not present
+    return attrValue;
+  } else if (isSrcset(attrName, tag)) {
+    // https://html.spec.whatwg.org/multipage/embedded-content.html#attr-img-srcset
+    attrValue = (await Promise.all(trimWhitespace(attrValue).split(/\s*,\s*/).map(async function (candidate) {
+      let url = candidate;
+      let descriptor = '';
+      const match = candidate.match(/\s+([1-9][0-9]*w|[0-9]+(?:\.[0-9]+)?x)$/);
+      if (match) {
+        url = url.slice(0, -match[0].length);
+        const num = +match[1].slice(0, -1);
+        const suffix = match[1].slice(-1);
+        if (num !== 1 || suffix !== 'x') {
+          descriptor = ' ' + num + suffix;
+        }
       }
-      // Boolean attribute in spec (undefined value) matches if attribute is present
-      if (value === undefined) {
-        return true;
+      try {
+        const out = await options.minifyURLs(url);
+        return (typeof out === 'string' ? out : url) + descriptor;
+      } catch (err) {
+        if (!options.continueOnMinifyError) {
+          throw err;
+        }
+        options.log && options.log(err);
+        return url + descriptor;
       }
-      // Valued attribute must match exactly
-      return attr.value === value;
+    }))).join(', ');
+  } else if (isMetaViewport(tag, attrs) && attrName === 'content') {
+    attrValue = attrValue.replace(/\s+/g, '').replace(/[0-9]+\.[0-9]+/g, function (numString) {
+      // 0.90000 → 0.9
+      // 1.0 → 1
+      // 1.0001 → 1.0001 (unchanged)
+      return (+numString).toString();
     });
-
-    if (allAttrsMatch) {
-      return true;
+  } else if (isContentSecurityPolicy(tag, attrs) && attrName.toLowerCase() === 'content') {
+    return collapseWhitespaceAll(attrValue);
+  } else if (options.customAttrCollapse && options.customAttrCollapse.test(attrName)) {
+    attrValue = trimWhitespace(attrValue.replace(/ ?[\n\r]+ ?/g, '').replace(/\s{2,}/g, options.conservativeCollapse ? ' ' : ''));
+  } else if (tag === 'script' && attrName === 'type') {
+    attrValue = trimWhitespace(attrValue.replace(/\s*;\s*/g, ';'));
+  } else if (isMediaQuery(tag, attrs, attrName)) {
+    attrValue = trimWhitespace(attrValue);
+    try {
+      return await options.minifyCSS(attrValue, 'media');
+    } catch (err) {
+      if (!options.continueOnMinifyError) {
+        throw err;
+      }
+      options.log && options.log(err);
+      return attrValue;
     }
+  } else if (tag === 'iframe' && attrName === 'srcdoc') {
+    // Recursively minify HTML content within `srcdoc` attribute
+    // Fast-path: Skip if nothing would change
+    if (!shouldMinifyInnerHTML(options)) {
+      return attrValue;
+    }
+    return minifyHTMLSelf(attrValue, options, true);
   }
-
-  return false;
+  return attrValue;
 }
 
-function canCollapseWhitespace(tag) {
-  return !/^(?:script|style|pre|textarea)$/.test(tag);
-}
+/**
+ * Choose appropriate quote character for an attribute value
+ * @param {string} attrValue - The attribute value
+ * @param {Object} options - Minifier options
+ * @returns {string} The chosen quote character (`"` or `'`)
+ */
+function chooseAttributeQuote(attrValue, options) {
+  if (typeof options.quoteCharacter !== 'undefined') {
+    return options.quoteCharacter === '\'' ? '\'' : '"';
+  }
 
-function canTrimWhitespace(tag) {
-  return !/^(?:pre|textarea)$/.test(tag);
+  // Count quotes in a single pass
+  let apos = 0, quot = 0;
+  for (let i = 0; i < attrValue.length; i++) {
+    if (attrValue[i] === "'") apos++;
+    else if (attrValue[i] === '"') quot++;
+  }
+  return apos < quot ? '\'' : '"';
 }
 
-async function normalizeAttr(attr, attrs, tag, options) {
+async function normalizeAttr(attr, attrs, tag, options, minifyHTML) {
   const attrName = options.name(attr.name);
   let attrValue = attr.value;
 
@@ -2038,7 +1834,7 @@ async function normalizeAttr(attr, attrs, tag, options) {
   }
 
   if ((options.removeRedundantAttributes &&
-    isAttributeRedundant(tag, attrName, attrValue, attrs)) ||
+      isAttributeRedundant(tag, attrName, attrValue, attrs)) ||
     (options.removeScriptTypeAttributes && tag === 'script' &&
       attrName === 'type' && isScriptTypeAttribute(attrValue) && !keepScriptTypeAttribute(attrValue)) ||
     (options.removeStyleLinkTypeAttributes && (tag === 'style' || tag === 'link') &&
@@ -2075,65 +1871,44 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
   let emittedAttrValue;
 
   if (typeof attrValue !== 'undefined' && (!options.removeAttributeQuotes ||
-    ~attrValue.indexOf(uidAttr) || !canRemoveAttributeQuotes(attrValue))) {
+    attrValue.indexOf(uidAttr) !== -1 || !canRemoveAttributeQuotes(attrValue))) {
     // Determine the appropriate quote character
     if (!options.preventAttributesEscaping) {
       // Normal mode: choose quotes and escape
-      if (typeof options.quoteCharacter === 'undefined') {
-        // Count quotes in a single pass instead of two regex operations
-        let apos = 0, quot = 0;
-        for (let i = 0; i < attrValue.length; i++) {
-          if (attrValue[i] === "'") apos++;
-          else if (attrValue[i] === '"') quot++;
-        }
-        attrQuote = apos < quot ? '\'' : '"';
-      } else {
-        attrQuote = options.quoteCharacter === '\'' ? '\'' : '"';
-      }
+      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
-      // EXCEPT when both quote types are present—then escape to prevent invalid HTML
+      // `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;
 
+      // Both quote types present: Escaping is required to guarantee valid HTML delimiter matching
       if (hasDoubleQuote && hasSingleQuote) {
-        // Both quote types present: `preventAttributesEscaping` is ignored to ensure valid HTML
-        // Choose the quote type with fewer occurrences and escape the other
-        if (typeof options.quoteCharacter === 'undefined') {
-          let apos = 0, quot = 0;
-          for (let i = 0; i < attrValue.length; i++) {
-            if (attrValue[i] === "'") apos++;
-            else if (attrValue[i] === '"') quot++;
-          }
-          attrQuote = apos < quot ? '\'' : '"';
-        } else {
-          attrQuote = options.quoteCharacter === '\'' ? '\'' : '"';
-        }
+        attrQuote = chooseAttributeQuote(attrValue, options);
         if (attrQuote === '"') {
           attrValue = attrValue.replace(/"/g, '&#34;');
         } else {
           attrValue = attrValue.replace(/'/g, '&#39;');
         }
+      // Auto quote selection: Prefer the opposite quote type when value contains one quote type, default to double quotes when none present
       } else if (typeof options.quoteCharacter === 'undefined') {
-        // Single or no quote type: Choose safe quote delimiter
         if (attrQuote === '"' && hasDoubleQuote && !hasSingleQuote) {
           attrQuote = "'";
         } else if (attrQuote === "'" && hasSingleQuote && !hasDoubleQuote) {
           attrQuote = '"';
+        // Fallback for invalid/unsupported attrQuote values (not `"`, `'`, or empty string): Choose safe default based on value content
         } else if (attrQuote !== '"' && attrQuote !== "'" && attrQuote !== '') {
-          // `attrQuote` is invalid/undefined (not `"`, `'`, or empty string)
-          // Set a safe default based on the value’s content
           if (hasSingleQuote && !hasDoubleQuote) {
-            attrQuote = '"'; // Value has single quotes, use double quotes as delimiter
+            attrQuote = '"';
           } else if (hasDoubleQuote && !hasSingleQuote) {
-            attrQuote = "'"; // Value has double quotes, use single quotes as delimiter
+            attrQuote = "'";
           } else {
-            attrQuote = '"'; // No quotes in value, default to double quotes
+            attrQuote = '"';
           }
         }
       } else {
@@ -2153,7 +1928,7 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
   }
 
   if (typeof attrValue === 'undefined' || (options.collapseBooleanAttributes &&
-    isBooleanAttribute(attrName.toLowerCase(), attrValue.toLowerCase()))) {
+    isBooleanAttribute(attrName.toLowerCase(), (attrValue || '').toLowerCase()))) {
     attrFragment = attrName;
     if (!isLast) {
       attrFragment += ' ';
@@ -2165,252 +1940,629 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
   return attr.customOpen + attrFragment + attr.customClose;
 }
 
-function identity(value) {
-  return value;
+// Imports
+
+
+// Tag omission rules
+
+function canRemoveParentTag(optionalStartTag, tag) {
+  switch (optionalStartTag) {
+    case 'html':
+    case 'head':
+      return true;
+    case 'body':
+      return !headerTags.has(tag);
+    case 'colgroup':
+      return tag === 'col';
+    case 'tbody':
+      return tag === 'tr';
+  }
+  return false;
 }
 
-function identityAsync(value) {
-  return Promise.resolve(value);
+function isStartTagMandatory(optionalEndTag, tag) {
+  switch (tag) {
+    case 'colgroup':
+      return optionalEndTag === 'colgroup';
+    case 'tbody':
+      return tableSectionTags.has(optionalEndTag);
+  }
+  return false;
 }
 
-function shouldMinifyInnerHTML(options) {
-  return Boolean(
-    options.collapseWhitespace ||
-    options.removeComments ||
-    options.removeOptionalTags ||
-    options.minifyJS !== identity ||
-    options.minifyCSS !== identityAsync ||
-    options.minifyURLs !== identity
-  );
+function canRemovePrecedingTag(optionalEndTag, tag) {
+  switch (optionalEndTag) {
+    case 'html':
+    case 'head':
+    case 'body':
+    case 'colgroup':
+    case 'caption':
+      return true;
+    case 'li':
+    case 'optgroup':
+    case 'tr':
+      return tag === optionalEndTag;
+    case 'dt':
+    case 'dd':
+      return descriptionTags.has(tag);
+    case 'p':
+      return pBlockTags.has(tag);
+    case 'rb':
+    case 'rt':
+    case 'rp':
+      return rubyEndTagOmission.has(tag);
+    case 'rtc':
+      return rubyRtcEndTagOmission.has(tag);
+    case 'option':
+      return optionTag.has(tag);
+    case 'thead':
+    case 'tbody':
+      return tableContentTags.has(tag);
+    case 'tfoot':
+      return tag === 'tbody';
+    case 'td':
+    case 'th':
+      return cellTags.has(tag);
+  }
+  return false;
 }
 
-/**
- * @param {Partial<MinifierOptions>} inputOptions - User-provided options
- * @returns {MinifierOptions} Normalized options with defaults applied
+// Element removal logic
+
+function canRemoveElement(tag, attrs) {
+  switch (tag) {
+    case 'textarea':
+      return false;
+    case 'audio':
+    case 'script':
+    case 'video':
+      if (hasAttrName('src', attrs)) {
+        return false;
+      }
+      break;
+    case 'iframe':
+      if (hasAttrName('src', attrs) || hasAttrName('srcdoc', attrs)) {
+        return false;
+      }
+      break;
+    case 'object':
+      if (hasAttrName('data', attrs)) {
+        return false;
+      }
+      break;
+    case 'applet':
+      if (hasAttrName('code', attrs)) {
+        return false;
+      }
+      break;
+  }
+  return true;
+}
+
+/**
+ * @param {string} str - Tag name or HTML-like element spec (e.g., “td” or “<span aria-hidden='true'>”)
+ * @param {MinifierOptions} options - Options object for name normalization
+ * @returns {{tag: string, attrs: Object.<string, string|undefined>|null}|null} Parsed spec or null if invalid
+ */
+function parseElementSpec(str, options) {
+  if (typeof str !== 'string') {
+    return null;
+  }
+
+  const trimmed = str.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  // Simple tag name: `td`
+  if (!/[<>]/.test(trimmed)) {
+    return { tag: options.name(trimmed), attrs: null };
+  }
+
+  // HTML-like markup: `<span aria-hidden='true'>` or `<td></td>`
+  // Extract opening tag using regex
+  const match = trimmed.match(/^<([a-zA-Z][\w:-]*)((?:\s+[^>]*)?)>/);
+  if (!match) {
+    return null;
+  }
+
+  const tag = options.name(match[1]);
+  const attrString = match[2];
+
+  if (!attrString.trim()) {
+    return { tag, attrs: null };
+  }
+
+  // Parse attributes from string
+  const attrs = {};
+  const attrRegex = /([a-zA-Z][\w:-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>/]+)))?/g;
+  let attrMatch;
+
+  while ((attrMatch = attrRegex.exec(attrString))) {
+    const attrName = options.name(attrMatch[1]);
+    const attrValue = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4];
+    // Boolean attributes have no value (undefined)
+    attrs[attrName] = attrValue;
+  }
+
+  return {
+    tag,
+    attrs: Object.keys(attrs).length > 0 ? attrs : null
+  };
+}
+
+/**
+ * @param {string[]} input - Array of element specifications from `removeEmptyElementsExcept` option
+ * @param {MinifierOptions} options - Options object for parsing
+ * @returns {Array<{tag: string, attrs: Object.<string, string|undefined>|null}>} Array of parsed element specs
+ */
+function parseRemoveEmptyElementsExcept(input, options) {
+  if (!Array.isArray(input)) {
+    return [];
+  }
+
+  return input.map(item => {
+    if (typeof item === 'string') {
+      const spec = parseElementSpec(item, options);
+      if (!spec && options.log) {
+        options.log('Warning: Unable to parse “removeEmptyElementsExcept” specification: "' + item + '"');
+      }
+      return spec;
+    }
+    if (options.log) {
+      options.log('Warning: “removeEmptyElementsExcept” specification must be a string, received: ' + typeof item);
+    }
+    return null;
+  }).filter(Boolean);
+}
+
+/**
+ * @param {string} tag - Element tag name
+ * @param {HTMLAttribute[]} attrs - Array of element attributes
+ * @param {Array<{tag: string, attrs: Object.<string, string|undefined>|null}>} preserveList - Parsed preserve specs
+ * @returns {boolean} True if the empty element should be preserved
+ */
+function shouldPreserveEmptyElement(tag, attrs, preserveList) {
+  for (const spec of preserveList) {
+    // Tag name must match
+    if (spec.tag !== tag) {
+      continue;
+    }
+
+    // If no attributes specified in spec, tag match is enough
+    if (!spec.attrs) {
+      return true;
+    }
+
+    // Check if all specified attributes match
+    const allAttrsMatch = Object.entries(spec.attrs).every(([name, value]) => {
+      const attr = attrs.find(a => a.name === name);
+      if (!attr) {
+        return false; // Attribute not present
+      }
+      // Boolean attribute in spec (undefined value) matches if attribute is present
+      if (value === undefined) {
+        return true;
+      }
+      // Valued attribute must match exactly
+      return attr.value === value;
+    });
+
+    if (allAttrsMatch) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// Imports
+
+
+// Lazy-load heavy dependencies only when needed
+
+let lightningCSSPromise;
+async function getLightningCSS() {
+  if (!lightningCSSPromise) {
+    lightningCSSPromise = import('lightningcss').then(m => m.transform);
+  }
+  return lightningCSSPromise;
+}
+
+let terserPromise;
+async function getTerser() {
+  if (!terserPromise) {
+    terserPromise = import('terser').then(m => m.minify);
+  }
+  return terserPromise;
+}
+
+// Minification caches
+
+const cssMinifyCache = new LRU(200);
+const jsMinifyCache = new LRU(200);
+
+// Type definitions
+
+/**
+ * @typedef {Object} HTMLAttribute
+ *  Representation of an attribute from the HTML parser.
+ *
+ * @prop {string} name
+ * @prop {string} [value]
+ * @prop {string} [quote]
+ * @prop {string} [customAssign]
+ * @prop {string} [customOpen]
+ * @prop {string} [customClose]
+ */
+
+/**
+ * @typedef {Object} MinifierOptions
+ *  Options that control how HTML is minified. All of these are optional
+ *  and usually default to a disabled/safe value unless noted.
+ *
+ * @prop {(tag: string, attrs: HTMLAttribute[], canCollapseWhitespace: (tag: string) => boolean) => boolean} [canCollapseWhitespace]
+ *  Predicate that determines whether whitespace inside a given element
+ *  can be collapsed.
+ *
+ *  Default: Built-in `canCollapseWhitespace` function
+ *
+ * @prop {(tag: string | null, attrs: HTMLAttribute[] | undefined, canTrimWhitespace: (tag: string) => boolean) => boolean} [canTrimWhitespace]
+ *  Predicate that determines whether leading/trailing whitespace around
+ *  the element may be trimmed.
+ *
+ *  Default: Built-in `canTrimWhitespace` function
+ *
+ * @prop {boolean} [caseSensitive]
+ *  When true, tag and attribute names are treated as case-sensitive.
+ *  Useful for custom HTML tags.
+ *  If false (default) names are lower-cased via the `name` function.
+ *
+ *  Default: `false`
+ *
+ *  @prop {boolean} [collapseAttributeWhitespace]
+ *  Collapse multiple whitespace characters within attribute values into a
+ *  single space. Also trims leading and trailing whitespace from attribute
+ *  values. Applied as an early normalization step before special attribute
+ *  handlers (CSS minification, class sorting, etc.) run.
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean} [collapseBooleanAttributes]
+ *  Collapse boolean attributes to their name only (for example
+ *  `disabled="disabled"` → `disabled`).
+ *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#collapse_boolean_attributes
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean} [collapseInlineTagWhitespace]
+ *  When false (default) whitespace around `inline` tags is preserved in
+ *  more cases. When true, whitespace around inline tags may be collapsed.
+ *  Must also enable `collapseWhitespace` to have effect.
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean} [collapseWhitespace]
+ *  Collapse multiple whitespace characters into one where allowed. Also
+ *  controls trimming behaviour in several code paths.
+ *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#collapse_whitespace
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean} [conservativeCollapse]
+ *  If true, be conservative when collapsing whitespace (preserve more
+ *  whitespace in edge cases). Affects collapse algorithms.
+ *  Must also enable `collapseWhitespace` to have effect.
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean} [continueOnMinifyError]
+ *  When set to `false`, minification errors may throw.
+ *  By default, the minifier will attempt to recover from minification
+ *  errors, or ignore them and preserve the original content.
+ *
+ *  Default: `true`
+ *
+ * @prop {boolean} [continueOnParseError]
+ *  When true, the parser will attempt to continue on recoverable parse
+ *  errors. Otherwise, parsing errors may throw.
+ *
+ *  Default: `false`
+ *
+ * @prop {RegExp[]} [customAttrAssign]
+ *  Array of regexes used to recognise custom attribute assignment
+ *  operators (e.g. `'<div flex?="{{mode != cover}}"></div>'`).
+ *  These are concatenated with the built-in assignment patterns.
+ *
+ *  Default: `[]`
+ *
+ * @prop {RegExp} [customAttrCollapse]
+ *  Regex matching attribute names whose values should be collapsed.
+ *  Basically used to remove newlines and excess spaces inside attribute values,
+ *  e.g. `/ng-class/`.
+ *
+ * @prop {[RegExp, RegExp][]} [customAttrSurround]
+ *  Array of `[openRegExp, closeRegExp]` pairs used by the parser to
+ *  detect custom attribute surround patterns (for non-standard syntaxes,
+ *  e.g. `<input {{#if value}}checked="checked"{{/if}}>`).
+ *
+ * @prop {RegExp[]} [customEventAttributes]
+ *  Array of regexes used to detect event handler attributes for `minifyJS`
+ *  (e.g. `ng-click`). The default matches standard `on…` event attributes.
+ *
+ *  Default: `[/^on[a-z]{3,}$/]`
+ *
+ * @prop {number} [customFragmentQuantifierLimit]
+ *  Limits the quantifier used when building a safe regex for custom
+ *  fragments to avoid ReDoS. See source use for details.
+ *
+ *  Default: `200`
+ *
+ * @prop {boolean} [decodeEntities]
+ *  When true, decodes HTML entities in text and attributes before
+ *  processing, and re-encodes ambiguous ampersands when outputting.
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean} [html5]
+ *  Parse and emit using HTML5 rules. Set to `false` to use non-HTML5
+ *  parsing behavior.
+ *
+ *  Default: `true`
+ *
+ * @prop {RegExp[]} [ignoreCustomComments]
+ *  Comments matching any pattern in this array of regexes will be
+ *  preserved when `removeComments` is enabled. The default preserves
+ *  “bang” comments and comments starting with `#`.
+ *
+ *  Default: `[/^!/, /^\s*#/]`
+ *
+ * @prop {RegExp[]} [ignoreCustomFragments]
+ *  Array of regexes used to identify fragments that should be
+ *  preserved (for example server templates). These fragments are temporarily
+ *  replaced during minification to avoid corrupting template code.
+ *  The default preserves ASP/PHP-style tags.
+ *
+ *  Default: `[/<%[\s\S]*?%>/, /<\?[\s\S]*?\?>/]`
+ *
+ * @prop {boolean} [includeAutoGeneratedTags]
+ *  If false, tags marked as auto-generated by the parser will be omitted
+ *  from output. Useful to skip injected tags.
+ *
+ *  Default: `true`
+ *
+ * @prop {ArrayLike<string>} [inlineCustomElements]
+ *  Collection of custom element tag names that should be treated as inline
+ *  elements for white-space handling, alongside the built-in inline elements.
+ *
+ *  Default: `[]`
+ *
+ * @prop {boolean} [keepClosingSlash]
+ *  Preserve the trailing slash in self-closing tags when present.
+ *
+ *  Default: `false`
+ *
+ * @prop {(message: unknown) => void} [log]
+ *  Logging function used by the minifier for warnings/errors/info.
+ *  You can directly provide `console.log`, but `message` may also be an `Error`
+ *  object or other non-string value.
+ *
+ *  Default: `() => {}` (no-op function)
+ *
+ * @prop {number} [maxInputLength]
+ *  The maximum allowed input length. Used as a guard against ReDoS via
+ *  pathological inputs. If the input exceeds this length an error is
+ *  thrown.
+ *
+ *  Default: No limit
+ *
+ * @prop {number} [maxLineLength]
+ *  Maximum line length for the output. When set the minifier will wrap
+ *  output to the given number of characters where possible.
+ *
+ *  Default: No limit
+ *
+ * @prop {boolean | Partial<import("lightningcss").TransformOptions<import("lightningcss").CustomAtRules>> | ((text: string, type?: string) => Promise<string> | string)} [minifyCSS]
+ *  When true, enables CSS minification for inline `<style>` tags or
+ *  `style` attributes. If an object is provided, it is passed to
+ *  [Lightning CSS](https://www.npmjs.com/package/lightningcss)
+ *  as transform options. If a function is provided, it will be used to perform
+ *  custom CSS minification. If disabled, CSS is not minified.
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean | import("terser").MinifyOptions | ((text: string, inline?: boolean) => Promise<string> | string)} [minifyJS]
+ *  When true, enables JS minification for `<script>` contents and
+ *  event handler attributes. If an object is provided, it is passed to
+ *  [terser](https://www.npmjs.com/package/terser) as minify options.
+ *  If a function is provided, it will be used to perform
+ *  custom JS minification. If disabled, JS is not minified.
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean | string | import("relateurl").Options | ((text: string) => Promise<string> | string)} [minifyURLs]
+ *  When true, enables URL rewriting/minification. If an object is provided,
+ *  it is passed to [relateurl](https://www.npmjs.com/package/relateurl)
+ *  as options. If a string is provided, it is treated as an `{ site: string }`
+ *  options object. If a function is provided, it will be used to perform
+ *  custom URL minification. If disabled, URLs are not minified.
+ *
+ *  Default: `false`
+ *
+ * @prop {(name: string) => string} [name]
+ *  Function used to normalise tag/attribute names. By default, this lowercases
+ *  names, unless `caseSensitive` is enabled.
+ *
+ *  Default: `(name) => name.toLowerCase()`,
+ *  or `(name) => name` (no-op function) if `caseSensitive` is enabled.
+ *
+ * @prop {boolean} [noNewlinesBeforeTagClose]
+ *  When wrapping lines, prevent inserting a newline directly before a
+ *  closing tag (useful to keep tags like `</a>` on the same line).
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean} [partialMarkup]
+ *  When true, treat input as a partial HTML fragment rather than a complete
+ *  document. This preserves stray end tags (closing tags without corresponding
+ *  opening tags) and prevents auto-closing of unclosed tags at the end of input.
+ *  Useful for minifying template fragments, SSI includes, or other partial HTML
+ *  that will be combined with other fragments.
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean} [preserveLineBreaks]
+ *  Preserve a single line break at the start/end of text nodes when
+ *  collapsing/trimming whitespace.
+ *  Must also enable `collapseWhitespace` to have effect.
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean} [preventAttributesEscaping]
+ *  When true, attribute values will not be HTML-escaped (dangerous for
+ *  untrusted input). By default, attributes are escaped.
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean} [processConditionalComments]
+ *  When true, conditional comments (for example `<!--[if IE]> … <![endif]-->`)
+ *  will have their inner content processed by the minifier.
+ *  Useful to minify HTML that appears inside conditional comments.
+ *
+ *  Default: `false`
+ *
+ * @prop {string[]} [processScripts]
+ *  Array of `type` attribute values for `<script>` elements whose contents
+ *  should be processed as HTML
+ *  (e.g. `text/ng-template`, `text/x-handlebars-template`, etc.).
+ *  When present, the contents of matching script tags are recursively minified,
+ *  like normal HTML content.
+ *
+ *  Default: `[]`
+ *
+ * @prop {"\"" | "'"} [quoteCharacter]
+ *  Preferred quote character for attribute values. If unspecified the
+ *  minifier picks the safest quote based on the attribute value.
+ *
+ *  Default: Auto-detected
+ *
+ * @prop {boolean} [removeAttributeQuotes]
+ *  Remove quotes around attribute values where it is safe to do so.
+ *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#remove_attribute_quotes
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean} [removeComments]
+ *  Remove HTML comments. Comments that match `ignoreCustomComments` will
+ *  still be preserved.
+ *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#remove_comments
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean | ((attrName: string, tag: string) => boolean)} [removeEmptyAttributes]
+ *  If true, removes attributes whose values are empty (some attributes
+ *  are excluded by name). Can also be a function to customise which empty
+ *  attributes are removed.
+ *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#remove_empty_or_blank_attributes
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean} [removeEmptyElements]
+ *  Remove elements that are empty and safe to remove (for example
+ *  `<script />` without `src`).
+ *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#remove_empty_elements
+ *
+ *  Default: `false`
+ *
+ * @prop {string[]} [removeEmptyElementsExcept]
+ *  Specifies empty elements to preserve when `removeEmptyElements` is enabled.
+ *  Has no effect unless `removeEmptyElements: true`.
+ *
+ *  Accepts tag names or HTML-like element specifications:
+ *
+ *  * Tag name only: `["td", "span"]`—preserves all empty elements of these types
+ *  * With valued attributes: `["<span aria-hidden='true'>"]`—preserves only when attribute values match
+ *  * With boolean attributes: `["<input disabled>"]`—preserves only when boolean attribute is present
+ *  * Mixed: `["<button type='button' disabled>"]`—all specified attributes must match
+ *
+ *  Attribute matching:
+ *
+ *  * All specified attributes must be present and match (valued attributes must have exact values)
+ *  * Additional attributes on the element are allowed
+ *  * Attribute name matching respects the `caseSensitive` option
+ *  * Supports double quotes, single quotes, and unquoted attribute values in specifications
+ *
+ *  Limitations:
+ *
+ *  * Self-closing syntax (e.g., `["<span/>"]`) is not supported; use `["span"]` instead
+ *  * Definitions containing `>` within quoted attribute values (e.g., `["<span title='a>b'>"]`) are not supported
+ *
+ *  Default: `[]`
+ *
+ * @prop {boolean} [removeOptionalTags]
+ *  Drop optional start/end tags where the HTML specification permits it
+ *  (for example `</li>`, optional `<html>` etc.).
+ *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#remove_optional_tags
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean} [removeRedundantAttributes]
+ *  Remove attributes that are redundant because they match the element’s
+ *  default values (for example `<button type="submit">`).
+ *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#remove_redundant_attributes
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean} [removeScriptTypeAttributes]
+ *  Remove `type` attributes from `<script>` when they are unnecessary
+ *  (e.g. `type="text/javascript"`).
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean} [removeStyleLinkTypeAttributes]
+ *  Remove `type` attributes from `<style>` and `<link>` elements when
+ *  they are unnecessary (e.g. `type="text/css"`).
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean} [removeTagWhitespace]
+ *  **Note that this will result in invalid HTML!**
+ *
+ *  When true, extra whitespace between tag name and attributes (or before
+ *  the closing bracket) will be removed where possible. Affects output spacing
+ *  such as the space used in the short doctype representation.
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean | ((tag: string, attrs: HTMLAttribute[]) => void)} [sortAttributes]
+ *  When true, enables sorting of attributes. If a function is provided it
+ *  will be used as a custom attribute sorter, which should mutate `attrs`
+ *  in-place to the desired order. If disabled, the minifier will attempt to
+ *  preserve the order from the input.
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean | ((value: string) => string)} [sortClassName]
+ *  When true, enables sorting of class names inside `class` attributes.
+ *  If a function is provided it will be used to transform/sort the class
+ *  name string. If disabled, the minifier will attempt to preserve the
+ *  class-name order from the input.
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean} [trimCustomFragments]
+ *  When true, whitespace around ignored custom fragments may be trimmed
+ *  more aggressively. This affects how preserved fragments interact with
+ *  surrounding whitespace collapse.
+ *
+ *  Default: `false`
+ *
+ * @prop {boolean} [useShortDoctype]
+ *  Replace the HTML doctype with the short `<!doctype html>` form.
+ *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#use_short_doctype
+ *
+ *  Default: `false`
  */
-const processOptions = (inputOptions) => {
-  const options = {
-    name: function (name) {
-      return name.toLowerCase();
-    },
-    canCollapseWhitespace,
-    canTrimWhitespace,
-    continueOnMinifyError: true,
-    html5: true,
-    ignoreCustomComments: [
-      /^!/,
-      /^\s*#/
-    ],
-    ignoreCustomFragments: [
-      /<%[\s\S]*?%>/,
-      /<\?[\s\S]*?\?>/
-    ],
-    includeAutoGeneratedTags: true,
-    log: identity,
-    minifyCSS: identityAsync,
-    minifyJS: identity,
-    minifyURLs: identity
-  };
-
-  Object.keys(inputOptions).forEach(function (key) {
-    const option = inputOptions[key];
-
-    if (key === 'caseSensitive') {
-      if (option) {
-        options.name = identity;
-      }
-    } else if (key === 'log') {
-      if (typeof option === 'function') {
-        options.log = option;
-      }
-    } else if (key === 'minifyCSS' && typeof option !== 'function') {
-      if (!option) {
-        return;
-      }
-
-      const lightningCssOptions = typeof option === 'object' ? option : {};
-
-      options.minifyCSS = async function (text, type) {
-        // Fast path: Nothing to minify
-        if (!text || !text.trim()) {
-          return text;
-        }
-        text = await replaceAsync(
-          text,
-          /(url\s*\(\s*)(?:"([^"]*)"|'([^']*)'|([^\s)]+))(\s*\))/ig,
-          async function (match, prefix, dq, sq, unq, suffix) {
-            const quote = dq != null ? '"' : (sq != null ? "'" : '');
-            const url = dq ?? sq ?? unq ?? '';
-            try {
-              const out = await options.minifyURLs(url);
-              return prefix + quote + (typeof out === 'string' ? out : url) + quote + suffix;
-            } catch (err) {
-              if (!options.continueOnMinifyError) {
-                throw err;
-              }
-              options.log && options.log(err);
-              return match;
-            }
-          }
-        );
-        // Cache key: wrapped content, type, options signature
-        const inputCSS = wrapCSS(text, type);
-        const cssSig = stableStringify({ type, opts: lightningCssOptions, cont: !!options.continueOnMinifyError });
-        // For large inputs, use length and content fingerprint (first/last 50 chars) to prevent collisions
-        const cssKey = inputCSS.length > 2048
-          ? (inputCSS.length + '|' + inputCSS.slice(0, 50) + inputCSS.slice(-50) + '|' + type + '|' + cssSig)
-          : (inputCSS + '|' + type + '|' + cssSig);
-
-        try {
-          const cached = cssMinifyCache.get(cssKey);
-          if (cached) {
-            return cached;
-          }
-
-          const transformCSS = await getLightningCSS();
-          const result = transformCSS({
-            filename: 'input.css',
-            code: Buffer.from(inputCSS),
-            minify: true,
-            errorRecovery: !!options.continueOnMinifyError,
-            ...lightningCssOptions
-          });
-
-          const outputCSS = unwrapCSS(result.code.toString(), type);
-
-          // If Lightning CSS removed significant content that looks like template syntax or UIDs, return original
-          // This preserves:
-          // 1. Template code like `<?php ?>`, `<%= %>`, `{{ }}`, etc. (contain `<` or `>` but not `CDATA`)
-          // 2. UIDs representing custom fragments (only lowercase letters and digits, no spaces)
-          // CDATA sections, HTML entities, and other invalid CSS are allowed to be removed
-          const isCDATA = text.includes('<![CDATA[');
-          const uidPattern = /[a-z0-9]{10,}/; // UIDs are long alphanumeric strings
-          const hasUID = uidPattern.test(text) && !isCDATA; // Exclude CDATA from UID detection
-          const looksLikeTemplate = (text.includes('<') || text.includes('>')) && !isCDATA;
-
-          // Preserve if output is empty and input had template syntax or UIDs
-          // This catches cases where Lightning CSS removed content that should be preserved
-          const finalOutput = (text.trim() && !outputCSS.trim() && (looksLikeTemplate || hasUID)) ? text : outputCSS;
-
-          cssMinifyCache.set(cssKey, finalOutput);
-          return finalOutput;
-        } catch (err) {
-          cssMinifyCache.delete(cssKey);
-          if (!options.continueOnMinifyError) {
-            throw err;
-          }
-          options.log && options.log(err);
-          return text;
-        }
-      };
-    } else if (key === 'minifyJS' && typeof option !== 'function') {
-      if (!option) {
-        return;
-      }
-
-      const terserOptions = typeof option === 'object' ? option : {};
-
-      terserOptions.parse = {
-        ...terserOptions.parse,
-        bare_returns: false
-      };
-
-      options.minifyJS = async function (text, inline) {
-        const start = text.match(/^\s*<!--.*/);
-        const code = start ? text.slice(start[0].length).replace(/\n\s*-->\s*$/, '') : text;
-
-        terserOptions.parse.bare_returns = inline;
-
-        let jsKey;
-        try {
-          // Fast path: Avoid invoking Terser for empty/whitespace-only content
-          if (!code || !code.trim()) {
-            return '';
-          }
-          // Cache key: content, inline, options signature (subset)
-          const terserSig = stableStringify({
-            compress: terserOptions.compress,
-            mangle: terserOptions.mangle,
-            ecma: terserOptions.ecma,
-            toplevel: terserOptions.toplevel,
-            module: terserOptions.module,
-            keep_fnames: terserOptions.keep_fnames,
-            format: terserOptions.format,
-            cont: !!options.continueOnMinifyError,
-          });
-          // For large inputs, use length and content fingerprint (first/last 50 chars) to prevent collisions
-          jsKey = (code.length > 2048 ? (code.length + '|' + code.slice(0, 50) + code.slice(-50) + '|') : (code + '|')) + (inline ? '1' : '0') + '|' + terserSig;
-          const cached = jsMinifyCache.get(jsKey);
-          if (cached) {
-            return await cached;
-          }
-          const inFlight = (async () => {
-            const terser = await getTerser();
-            const result = await terser(code, terserOptions);
-            return result.code.replace(RE_TRAILING_SEMICOLON, '');
-          })();
-          jsMinifyCache.set(jsKey, inFlight);
-          const resolved = await inFlight;
-          jsMinifyCache.set(jsKey, resolved);
-          return resolved;
-        } catch (err) {
-          if (jsKey) jsMinifyCache.delete(jsKey);
-          if (!options.continueOnMinifyError) {
-            throw err;
-          }
-          options.log && options.log(err);
-          return text;
-        }
-      };
-    } else if (key === 'minifyURLs' && typeof option !== 'function') {
-      if (!option) {
-        return;
-      }
-
-      let relateUrlOptions = option;
-
-      if (typeof option === 'string') {
-        relateUrlOptions = { site: option };
-      } else if (typeof option !== 'object') {
-        relateUrlOptions = {};
-      }
-
-      // Cache RelateURL instance for reuse (expensive to create)
-      const relateUrlInstance = new RelateURL(relateUrlOptions.site || '', relateUrlOptions);
-
-      options.minifyURLs = function (text) {
-        // 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;
-        }
-
-        try {
-          return relateUrlInstance.relate(text);
-        } catch (err) {
-          if (!options.continueOnMinifyError) {
-            throw err;
-          }
-          options.log && options.log(err);
-          return text;
-        }
-      };
-    } else {
-      options[key] = option;
-    }
-  });
-  return options;
-};
-
-function uniqueId(value) {
-  let id;
-  do {
-    id = Math.random().toString(36).replace(/^0\.[0-9]*/, '');
-  } while (~value.indexOf(id));
-  return id;
-}
-
-const specialContentTags = new Set(['script', 'style']);
 
 async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupChunks) {
   const attrChains = options.sortAttributes && Object.create(null);
@@ -2483,8 +2635,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, just skip it—we’ll still have partial frequency data from what we could parse
       if (!options.continueOnParseError) {
         throw err;
       }
@@ -2493,7 +2644,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.
+  // This is safe because `createSortFns` is called before custom fragment UID markers (`uidAttr`) are added.
   // Note: `htmlmin:ignore` UID markers (uidIgnore) already exist and are expanded for analysis.
   const firstPassOptions = Object.assign({}, options, {
     // Disable sorting for the analysis pass
@@ -2536,8 +2687,7 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
       uidReplacePattern.lastIndex = 0;
     }
 
-    // First pass minification applies attribute transformations
-    // like removeStyleLinkTypeAttributes for accurate frequency analysis
+    // 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
@@ -2558,16 +2708,30 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
     for (const tag in attrChains) {
       attrSorters[tag] = attrChains[tag].createSorter();
     }
+    // Memoize sorted attribute orders—attribute sets often repeat in templates
+    const attrOrderCache = new LRU(200);
+
     options.sortAttributes = function (tag, attrs) {
       const sorter = attrSorters[tag];
       if (sorter) {
-        const attrMap = Object.create(null);
         const names = attrNames(attrs);
+
+        // Create order-independent cache key from tag and sorted attribute names
+        const cacheKey = tag + ':' + names.slice().sort().join(',');
+        let sortedNames = attrOrderCache.get(cacheKey);
+
+        if (sortedNames === undefined) {
+          // Only sort if not in cache—need to clone names since sort mutates in place
+          sortedNames = sorter.sort(names.slice());
+          attrOrderCache.set(cacheKey, sortedNames);
+        }
+
+        // Apply the sorted order to attrs
+        const attrMap = Object.create(null);
         names.forEach(function (name, index) {
           (attrMap[name] || (attrMap[name] = [])).push(attrs[index]);
         });
-        const sorted = sorter.sort(names);
-        sorted.forEach(function (name, index) {
+        sortedNames.forEach(function (name, index) {
           attrs[index] = attrMap[name].shift();
         });
       }
@@ -2668,10 +2832,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-emoj-cthulhu-filled content
+  // 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
   value = value.replace(/<!-- htmlmin:ignore -->([\s\S]*?)<!-- htmlmin:ignore -->/g, function (match, group1) {
     if (!uidIgnore) {
       uidIgnore = uniqueId(value);
@@ -2879,7 +3041,7 @@ async function minifyHTML(value, options, partialMarkup) {
 
       const parts = [];
       for (let i = attrs.length, isLast = true; --i >= 0;) {
-        const normalized = await normalizeAttr(attrs[i], attrs, tag, options);
+        const normalized = await normalizeAttr(attrs[i], attrs, tag, options, minifyHTML);
         if (normalized) {
           parts.push(buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr));
           isLast = false;
@@ -2954,7 +3116,7 @@ async function minifyHTML(value, options, partialMarkup) {
         }
 
         if (!preserve) {
-          // Remove last “element” from buffer
+          // Remove last element from buffer
           removeStartTag();
           optionalStartTag = '';
           optionalEndTag = '';
@@ -3038,7 +3200,7 @@ async function minifyHTML(value, options, partialMarkup) {
         }
       }
       if (specialContentTags.has(currentTag) && (options.processScripts || hasJsonScriptType(currentAttrs))) {
-        text = await processScript(text, options, currentAttrs);
+        text = await processScript(text, options, currentAttrs, minifyHTML);
       }
       if (isExecutableScript(currentTag, currentAttrs)) {
         text = await options.minifyJS(text);
@@ -3092,7 +3254,7 @@ async function minifyHTML(value, options, partialMarkup) {
       const prefix = nonStandard ? '<!' : '<!--';
       const suffix = nonStandard ? '>' : '-->';
       if (isConditionalComment(text)) {
-        text = prefix + await cleanConditionalComment(text, options) + suffix;
+        text = prefix + await cleanConditionalComment(text, options, minifyHTML) + suffix;
       } else if (options.removeComments) {
         if (isIgnoredComment(text, options)) {
           text = '<!--' + text + '-->';
@@ -3279,7 +3441,12 @@ function joinResultSegments(results, options, restoreCustom, restoreIgnore) {
  */
 const minify = async function (value, options) {
   const start = Date.now();
-  options = processOptions(options || {});
+  options = processOptions(options || {}, {
+    getLightningCSS,
+    getTerser,
+    cssMinifyCache,
+    jsMinifyCache
+  });
   const result = await minifyHTML(value, options);
   options.log('minified in: ' + (Date.now() - start) + 'ms');
   return result;