html-minifier-next 4.12.2 → 4.13.0

package/src/htmlminifier.js

@@ -1,10 +1,61 @@
-import { decodeHTMLStrict, decodeHTML } from 'entities';
-import RelateURL from 'relateurl';
+// Imports
+
+import { decodeHTML } from 'entities';
 import { HTMLParser, endTag } from './htmlparser.js';
 import TokenChain from './tokenchain.js';
-import { replaceAsync } from './utils.js';
 import { presets, getPreset, getPresetNames } from './presets.js';
 
+import { LRU, identity, uniqueId } from './lib/utils.js';
+
+import {
+  inlineElementsToKeepWhitespaceAround,
+  inlineElementsToKeepWhitespaceWithin,
+  specialContentTags,
+  htmlTags,
+  optionalStartTags,
+  optionalEndTags,
+  topLevelTags,
+  compactTags,
+  looseTags,
+  trailingTags,
+  pInlineTags
+} from './lib/constants.js';
+
+import {
+  trimWhitespace,
+  collapseWhitespaceAll,
+  collapseWhitespace,
+  collapseWhitespaceSmart,
+  canCollapseWhitespace,
+  canTrimWhitespace
+} from './lib/whitespace.js';
+
+import {
+  isConditionalComment,
+  isIgnoredComment,
+  isExecutableScript,
+  isStyleSheet,
+  normalizeAttr,
+  buildAttr
+} from './lib/attributes.js';
+
+import {
+  canRemoveParentTag,
+  isStartTagMandatory,
+  canRemovePrecedingTag,
+  canRemoveElement,
+  parseRemoveEmptyElementsExcept,
+  shouldPreserveEmptyElement
+} from './lib/elements.js';
+
+import {
+  cleanConditionalComment,
+  hasJsonScriptType,
+  processScript
+} from './lib/content.js';
+
+import { processOptions } from './lib/options.js';
+
 // Lazy-load heavy dependencies only when needed
 
 let lightningCSSPromise;
@@ -23,6 +74,11 @@ async function getTerser() {
   return terserPromise;
 }
 
+// Minification caches
+
+const cssMinifyCache = new LRU(200);
+const jsMinifyCache = new LRU(200);
+
 // Type definitions
 
 /**
@@ -405,1212 +461,6 @@ async function getTerser() {
  *  Default: `false`
  */
 
-// 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;
-const RE_NBSP_LEADING_GROUP = /(^|\xA0+)[^\xA0]+/g;
-const RE_NBSP_LEAD_GROUP = /(\xA0+)[^\xA0]+/g;
-const RE_NBSP_TRAILING_GROUP = /[^\xA0]+(\xA0+)/g;
-const RE_NBSP_TRAILING_STRIP = /[^\xA0]+$/;
-const RE_CONDITIONAL_COMMENT = /^\[if\s[^\]]+]|\[endif]$/;
-const RE_EVENT_ATTR_DEFAULT = /^on[a-z]{3,}$/;
-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 + '}';
-}
-
-// 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); }
-}
-
-// Per-process caches
-const jsMinifyCache = new LRU(200);
-const cssMinifyCache = new LRU(200);
-
-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, '');
-};
-
-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:
-  return str.replace(RE_ALL_WS_NBSP, function (spaces) {
-    return spaces === '\t' ? '\t' : spaces.replace(RE_NBSP_LEADING_GROUP, '$1 ');
-  });
-}
-
-function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll) {
-  let lineBreakBefore = ''; let lineBreakAfter = '';
-
-  if (!str) return str;
-
-  if (options.preserveLineBreaks) {
-    str = str.replace(/^[ \n\r\t\f]*?[\n\r][ \n\r\t\f]*/, function () {
-      lineBreakBefore = '\n';
-      return '';
-    }).replace(/[ \n\r\t\f]*?[\n\r][ \n\r\t\f]*$/, function () {
-      lineBreakAfter = '\n';
-      return '';
-    });
-  }
-
-  if (trimLeft) {
-    // Non-breaking space is specifically handled inside the replacer function here:
-    str = str.replace(/^[ \n\r\t\f\xA0]+/, function (spaces) {
-      const conservative = !lineBreakBefore && options.conservativeCollapse;
-      if (conservative && spaces === '\t') {
-        return '\t';
-      }
-      return spaces.replace(/^[^\xA0]+/, '').replace(RE_NBSP_LEAD_GROUP, '$1 ') || (conservative ? ' ' : '');
-    });
-  }
-
-  if (trimRight) {
-    // Non-breaking space is specifically handled inside the replacer function here:
-    str = str.replace(/[ \n\r\t\f\xA0]+$/, function (spaces) {
-      const conservative = !lineBreakAfter && options.conservativeCollapse;
-      if (conservative && spaces === '\t') {
-        return '\t';
-      }
-      return spaces.replace(RE_NBSP_TRAILING_GROUP, ' $1').replace(RE_NBSP_TRAILING_STRIP, '') || (conservative ? ' ' : '');
-    });
-  }
-
-  if (collapseAll) {
-    // Strip non-space whitespace then compress spaces to one
-    str = collapseWhitespaceAll(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']);
-
-function collapseWhitespaceSmart(str, prevTag, nextTag, options, inlineElements, inlineTextSet) {
-  let trimLeft = prevTag && !inlineElementsToKeepWhitespace.has(prevTag);
-  if (trimLeft && !options.collapseInlineTagWhitespace) {
-    trimLeft = prevTag.charAt(0) === '/' ? !inlineElements.has(prevTag.slice(1)) : !inlineTextSet.has(prevTag);
-  }
-  let trimRight = nextTag && !inlineElementsToKeepWhitespace.has(nextTag);
-  if (trimRight && !options.collapseInlineTagWhitespace) {
-    trimRight = nextTag.charAt(0) === '/' ? !inlineTextSet.has(nextTag.slice(1)) : !inlineElements.has(nextTag);
-  }
-  return collapseWhitespace(str, options, trimLeft, trimRight, prevTag && nextTag);
-}
-
-function isConditionalComment(text) {
-  return RE_CONDITIONAL_COMMENT.test(text);
-}
-
-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 isEventAttribute(attrName, options) {
-  const patterns = options.customEventAttributes;
-  if (patterns) {
-    for (let i = patterns.length; i--;) {
-      if (patterns[i].test(attrName)) {
-        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);
-}
-
-function attributesInclude(attributes, attribute) {
-  for (let i = attributes.length; i--;) {
-    if (attributes[i].name.toLowerCase() === attribute) {
-      return true;
-    }
-  }
-  return false;
-}
-
-// 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' }
-};
-
-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;
-  }
-
-  // Check tag-specific defaults
-  return tagDefaults[tag]?.[attrName] === attrValue;
-}
-
-// 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'
-]);
-
-function isScriptTypeAttribute(attrValue = '') {
-  attrValue = trimWhitespace(attrValue.split(/;/, 2)[0]).toLowerCase();
-  return attrValue === '' || executableScriptsMimetypes.has(attrValue);
-}
-
-function keepScriptTypeAttribute(attrValue = '') {
-  attrValue = trimWhitespace(attrValue.split(/;/, 2)[0]).toLowerCase();
-  return keepScriptsMimetypes.has(attrValue);
-}
-
-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;
-}
-
-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') {
-      return isStyleLinkTypeAttribute(attrs[i].value);
-    }
-  }
-  return true;
-}
-
-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']);
-
-function isBooleanAttribute(attrName, attrValue) {
-  return isSimpleBoolean.has(attrName) || (attrName === 'draggable' && !isBooleanValue.has(attrValue));
-}
-
-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 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 isMediaQuery(tag, attrs, attrName) {
-  return attrName === 'media' && (isLinkType(tag, attrs, 'stylesheet') || isStyleSheet(tag, attrs));
-}
-
-const srcsetTags = new Set(['img', 'source']);
-
-function isSrcset(attrName, tag) {
-  return attrName === 'srcset' && srcsetTags.has(tag);
-}
-
-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, '');
-    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;
-      }
-      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*;$/, ';');
-      }
-      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;
-        }
-      }
-      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;
-      }
-    }))).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;
-    }
-    return minifyHTMLSelf(attrValue, options, true);
-  }
-  return attrValue;
-}
-
-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;
-    }
-  }
-}
-
-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;
-    }
-  }
-}
-
-// 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) {
-  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;
-}
-
-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',
-]);
-
-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;
-  }
-}
-
-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;
-}
-
-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;
-}
-
-// 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 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 isStartTagMandatory(optionalEndTag, tag) {
-  switch (tag) {
-    case 'colgroup':
-      return optionalEndTag === 'colgroup';
-    case 'tbody':
-      return tableSectionTags.has(optionalEndTag);
-  }
-  return false;
-}
-
-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;
-}
-
-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) {
-    return false;
-  }
-  if (typeof options.removeEmptyAttributes === 'function') {
-    return options.removeEmptyAttributes(attrName, tag);
-  }
-  return (tag === 'input' && attrName === 'value') || reEmptyAttribute.test(attrName);
-}
-
-function hasAttrName(name, attrs) {
-  for (let i = attrs.length - 1; i >= 0; i--) {
-    if (attrs[i].name === name) {
-      return true;
-    }
-  }
-  return false;
-}
-
-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;
-}
-
-function canCollapseWhitespace(tag) {
-  return !/^(?:script|style|pre|textarea)$/.test(tag);
-}
-
-function canTrimWhitespace(tag) {
-  return !/^(?:pre|textarea)$/.test(tag);
-}
-
-async function normalizeAttr(attr, attrs, tag, options) {
-  const attrName = options.name(attr.name);
-  let attrValue = attr.value;
-
-  if (options.decodeEntities && attrValue) {
-    // Fast path: Only decode when entities are present
-    if (attrValue.indexOf('&') !== -1) {
-      attrValue = decodeHTMLStrict(attrValue);
-    }
-  }
-
-  if ((options.removeRedundantAttributes &&
-    isAttributeRedundant(tag, attrName, attrValue, attrs)) ||
-    (options.removeScriptTypeAttributes && tag === 'script' &&
-      attrName === 'type' && isScriptTypeAttribute(attrValue) && !keepScriptTypeAttribute(attrValue)) ||
-    (options.removeStyleLinkTypeAttributes && (tag === 'style' || tag === 'link') &&
-      attrName === 'type' && isStyleLinkTypeAttribute(attrValue))) {
-    return;
-  }
-
-  if (attrValue) {
-    attrValue = await cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTML);
-  }
-
-  if (options.removeEmptyAttributes &&
-    canDeleteEmptyAttribute(tag, attrName, attrValue, options)) {
-    return;
-  }
-
-  if (options.decodeEntities && attrValue && attrValue.indexOf('&') !== -1) {
-    attrValue = attrValue.replace(RE_AMP_ENTITY, '&amp;$1');
-  }
-
-  return {
-    attr,
-    name: attrName,
-    value: attrValue
-  };
-}
-
-function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
-  const attrName = normalized.name;
-  let attrValue = normalized.value;
-  const attr = normalized.attr;
-  let attrQuote = attr.quote;
-  let attrFragment;
-  let emittedAttrValue;
-
-  if (typeof attrValue !== 'undefined' && (!options.removeAttributeQuotes ||
-    ~attrValue.indexOf(uidAttr) || !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 === '\'' ? '\'' : '"';
-      }
-      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
-      const hasDoubleQuote = attrValue.indexOf('"') !== -1;
-      const hasSingleQuote = attrValue.indexOf("'") !== -1;
-
-      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 === '\'' ? '\'' : '"';
-        }
-        if (attrQuote === '"') {
-          attrValue = attrValue.replace(/"/g, '&#34;');
-        } else {
-          attrValue = attrValue.replace(/'/g, '&#39;');
-        }
-      } 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 = '"';
-        } 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
-          } else if (hasDoubleQuote && !hasSingleQuote) {
-            attrQuote = "'"; // Value has double quotes, use single quotes as delimiter
-          } else {
-            attrQuote = '"'; // No quotes in value, default to double quotes
-          }
-        }
-      } else {
-        attrQuote = options.quoteCharacter === '\'' ? '\'' : '"';
-      }
-    }
-    emittedAttrValue = attrQuote + attrValue + attrQuote;
-    if (!isLast && !options.removeTagWhitespace) {
-      emittedAttrValue += ' ';
-    }
-  } else if (isLast && !hasUnarySlash) {
-    // Last attribute in a non-self-closing tag: no space needed
-    emittedAttrValue = attrValue;
-  } else {
-    // Not last attribute, or is a self-closing tag: add space
-    emittedAttrValue = attrValue + ' ';
-  }
-
-  if (typeof attrValue === 'undefined' || (options.collapseBooleanAttributes &&
-    isBooleanAttribute(attrName.toLowerCase(), attrValue.toLowerCase()))) {
-    attrFragment = attrName;
-    if (!isLast) {
-      attrFragment += ' ';
-    }
-  } else {
-    attrFragment = attrName + attr.customAssign + emittedAttrValue;
-  }
-
-  return attr.customOpen + attrFragment + attr.customClose;
-}
-
-function identity(value) {
-  return value;
-}
-
-function identityAsync(value) {
-  return Promise.resolve(value);
-}
-
-function shouldMinifyInnerHTML(options) {
-  return Boolean(
-    options.collapseWhitespace ||
-    options.removeComments ||
-    options.removeOptionalTags ||
-    options.minifyJS !== identity ||
-    options.minifyCSS !== identityAsync ||
-    options.minifyURLs !== identity
-  );
-}
-
-/**
- * @param {Partial<MinifierOptions>} inputOptions - User-provided options
- * @returns {MinifierOptions} Normalized options with defaults applied
- */
-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);
   const classChain = options.sortClassName && new TokenChain();
@@ -1682,8 +532,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;
       }
@@ -1692,7 +541,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
@@ -1735,8 +584,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
@@ -1757,16 +605,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();
         });
       }
@@ -1867,10 +729,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);
@@ -2078,7 +938,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;
@@ -2153,7 +1013,7 @@ async function minifyHTML(value, options, partialMarkup) {
         }
 
         if (!preserve) {
-          // Remove last “element” from buffer
+          // Remove last element from buffer
           removeStartTag();
           optionalStartTag = '';
           optionalEndTag = '';
@@ -2237,7 +1097,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);
@@ -2291,7 +1151,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 + '-->';
@@ -2478,7 +1338,12 @@ function joinResultSegments(results, options, restoreCustom, restoreIgnore) {
  */
 export 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;