html-minifier-next 5.1.2 → 5.1.4

package/dist/htmlminifier.cjs

@@ -2,6 +2,106 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+// 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 + '}';
+}
+
+// LRU cache for strings and promises
+
+class LRU {
+  constructor(limit = 200) {
+    this.limit = limit;
+    this.map = new Map();
+  }
+  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); }
+}
+
+// Unique ID generator
+
+function uniqueId(value) {
+  let id;
+  do {
+    id = 'u' + crypto.randomUUID().replace(/-/g, '');
+  } while (~value.indexOf(id));
+  return id;
+}
+
+// Identity and transform functions
+
+function identity(value) {
+  return value;
+}
+
+function isThenable(value) {
+  return value != null && typeof value === 'object' && typeof value.then === 'function';
+}
+
+function lowercase(value) {
+  return value.toLowerCase();
+}
+
+// Replace async helper
+
+/**
+ * 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 = [];
+
+  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());
+}
+
+// String patterns to RegExp conversion (for JSON config support)
+
+function parseRegExp(value) {
+  if (typeof value === 'string') {
+    if (!value) return undefined; // Empty string = not configured
+    const match = value.match(/^\/(.+)\/([dgimsuvy]*)$/);
+    if (match) {
+      return new RegExp(match[1], match[2]);
+    }
+    return new RegExp(value);
+  }
+  return value;
+}
+
 /*
  * HTML Parser By John Resig (ejohn.org)
  * Modified by Juriy “kangax” Zaytsev
@@ -9,6 +109,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
  * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js
  */
 
+
 /*
  * Use like so:
  *
@@ -84,6 +185,23 @@ const preCompiledStackedTags = {
 // Cache for compiled attribute regexes per handler configuration
 const attrRegexCache = new WeakMap();
 
+// O(n) helper: Strip all occurrences of `open…close` delimiters, keeping inner content
+// Used instead of a regex replace to avoid O(n²) behavior on adversarial inputs
+function stripDelimited(str, open, close) {
+  let result = '';
+  let i = 0;
+  while (i < str.length) {
+    const start = str.indexOf(open, i);
+    if (start === -1) { result += str.slice(i); break; }
+    result += str.slice(i, start);
+    const end = str.indexOf(close, start + open.length);
+    if (end === -1) { result += str.slice(start); break; }
+    result += str.slice(start + open.length, end);
+    i = end + close.length;
+  }
+  return result;
+}
+
 function buildAttrRegex(handler) {
   let pattern = singleAttrIdentifier.source +
     '(?:\\s*(' + joinSingleAttrAssigns(handler) + ')' +
@@ -155,9 +273,10 @@ class HTMLParser {
 
     // Sticky regex versions for position-based matching (avoids string slicing)
     const startTagOpenY = new RegExp(startTagOpen.source.slice(1), 'y');
+    // `\s*` with sticky flag is O(n) at worst—no retry from different positions possible
     const startTagCloseY = /\s*(\/?)>/y;
     const endTagY = new RegExp(endTag.source.slice(1), 'y');
-    const doctypeY = /<!DOCTYPE\s?[^>]+>/iy;
+    const doctypeY = /<!DOCTYPE[^<>]+>/iy;
     const commentTestY = /<!--/y;
     const conditionalTestY = /<!\[/y;
 
@@ -232,7 +351,8 @@ class HTMLParser {
 
             if (commentEnd >= 0) {
               if (handler.comment) {
-                await handler.comment(fullHtml.substring(pos + 4, commentEnd));
+                const result = handler.comment(fullHtml.substring(pos + 4, commentEnd));
+                if (isThenable(result)) await result;
               }
               advance(commentEnd + 3 - pos);
               prevTag = '';
@@ -248,7 +368,8 @@ class HTMLParser {
 
             if (conditionalEnd >= 0) {
               if (handler.comment) {
-                await handler.comment(fullHtml.substring(pos + 2, conditionalEnd + 1), true /* Non-standard */);
+                const result = handler.comment(fullHtml.substring(pos + 2, conditionalEnd + 1), true /* Non-standard */);
+                if (isThenable(result)) await result;
               }
               advance(conditionalEnd + 2 - pos);
               prevTag = '';
@@ -326,7 +447,8 @@ class HTMLParser {
         }
 
         if (handler.chars) {
-          await handler.chars(text, prevTag, nextTag, prevAttrs, nextAttrs);
+          const result = handler.chars(text, prevTag, nextTag, prevAttrs, nextAttrs);
+          if (isThenable(result)) await result;
         }
         prevTag = '';
         prevAttrs = [];
@@ -340,12 +462,11 @@ class HTMLParser {
         if (m && m.index === 0) {
           let text = m[1];
           if (stackedTag !== 'script' && stackedTag !== 'style' && stackedTag !== 'noscript') {
-            text = text
-              .replace(/<!--([\s\S]*?)-->/g, '$1')
-              .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
+            text = stripDelimited(stripDelimited(text, '<!--', '-->'), '<![CDATA[', ']]>');
           }
           if (handler.chars) {
-            await handler.chars(text);
+            const result = handler.chars(text);
+            if (isThenable(result)) await result;
           }
           // Advance HTML past the matched special tag content and its closing tag
           advance(m[0].length);
@@ -353,7 +474,8 @@ class HTMLParser {
         } else {
           // No closing tag found; to avoid infinite loop, break similarly to previous behavior
           if (handler.continueOnParseError && handler.chars && pos < fullLength) {
-            await handler.chars(fullHtml[pos], prevTag, '', prevAttrs, []);
+            const result = handler.chars(fullHtml[pos], prevTag, '', prevAttrs, []);
+            if (isThenable(result)) await result;
             advance(1);
           } else {
             break;
@@ -365,7 +487,8 @@ class HTMLParser {
         if (handler.continueOnParseError) {
           // Skip the problematic character and continue
           if (handler.chars) {
-            await handler.chars(fullHtml[pos], prevTag, '', prevAttrs, []);
+            const result = handler.chars(fullHtml[pos], prevTag, '', prevAttrs, []);
+            if (isThenable(result)) await result;
           }
           advance(1);
           prevTag = '';
@@ -913,106 +1036,6 @@ function getPresetNames() {
   return Object.keys(presets);
 }
 
-// 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 + '}';
-}
-
-// LRU cache for strings and promises
-
-class LRU {
-  constructor(limit = 200) {
-    this.limit = limit;
-    this.map = new Map();
-  }
-  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); }
-}
-
-// 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 and transform functions
-
-function identity(value) {
-  return value;
-}
-
-function identityAsync(value) {
-  return Promise.resolve(value);
-}
-
-function lowercase(value) {
-  return value.toLowerCase();
-}
-
-// Replace async helper
-
-/**
- * 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 = [];
-
-  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());
-}
-
-// String patterns to RegExp conversion (for JSON config support)
-
-function parseRegExp(value) {
-  if (typeof value === 'string') {
-    if (!value) return undefined; // Empty string = not configured
-    const match = value.match(/^\/(.+)\/([dgimsuvy]*)$/);
-    if (match) {
-      return new RegExp(match[1], match[2]);
-    }
-    return new RegExp(value);
-  }
-  return value;
-}
-
 // Regex patterns (to avoid repeated allocations in hot paths)
 
 const RE_WS_START = /^[ \n\r\t\f]+/;
@@ -1665,7 +1688,7 @@ function shouldMinifyInnerHTML(options) {
     options.removeComments ||
     options.removeOptionalTags ||
     options.minifyJS !== identity ||
-    options.minifyCSS !== identityAsync ||
+    options.minifyCSS !== identity ||
     options.minifyURLs !== identity ||
     options.minifySVG
   );
@@ -1692,7 +1715,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
     canTrimWhitespace,
     ...optionDefaults,
     log: identity,
-    minifyCSS: identityAsync,
+    minifyCSS: identity,
     minifyJS: identity,
     minifyURLs: identity,
     minifySVG: null
@@ -2330,7 +2353,9 @@ function hasAttrName(name, attrs) {
 
 // Cleaners
 
-async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTMLSelf) {
+// Returns the cleaned attribute value directly (sync) or as a Promise (async);
+// callers must handle both cases—use `isThenable()` to distinguish
+function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTMLSelf) {
   // Apply early whitespace normalization if enabled
   // Preserves special spaces (no-break space, hair space, etc.) for consistency with `collapseWhitespace`
   if (options.collapseAttributeWhitespace) {
@@ -2345,16 +2370,18 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
 
   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;
-      }
-      options.log && options.log(err);
-      return attrValue;
+    const result = options.minifyJS(attrValue, true);
+    if (isThenable(result)) {
+      return result.catch(err => {
+        if (!options.continueOnMinifyError) throw err;
+        options.log && options.log(err);
+        return attrValue;
+      });
     }
-  } else if (attrName === 'class') {
+    return result;
+  }
+
+  if (attrName === 'class') {
     attrValue = trimWhitespace(attrValue);
     if (options.sortClassNames) {
       attrValue = options.sortClassNames(attrValue);
@@ -2362,47 +2389,63 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
       attrValue = collapseWhitespaceAll(attrValue);
     }
     return attrValue;
-  } else if (isUriTypeAttribute(attrName, tag)) {
+  }
+
+  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;
+    const result = options.minifyURLs(attrValue);
+    if (isThenable(result)) {
+      return result
+        .then(out => 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 typeof result === 'string' ? result : attrValue;
+  }
+
+  if (isNumberTypeAttribute(attrName, tag)) {
     return trimWhitespace(attrValue);
-  } else if (attrName === 'style') {
+  }
+
+  if (attrName === 'style') {
     attrValue = trimWhitespace(attrValue);
     if (attrValue) {
       if (attrValue.endsWith(';') && !/&#?[0-9a-zA-Z]+;$/.test(attrValue)) {
         attrValue = attrValue.replace(/\s*;$/, ';');
       }
-      try {
-        attrValue = await options.minifyCSS(attrValue, 'inline');
-        // After minification, check if CSS consists entirely of invalid properties (no values)
-        // I.e., `color:` or `margin:;padding:` should be treated as empty
-        if (attrValue && /^(?:[a-z-]+:[;\s]*)+$/i.test(attrValue)) {
-          attrValue = '';
-        }
-      } catch (err) {
-        if (!options.continueOnMinifyError) {
-          throw err;
-        }
-        options.log && options.log(err);
+      const originalAttrValue = attrValue;
+      const cssResult = options.minifyCSS(attrValue, 'inline');
+      if (isThenable(cssResult)) {
+        return cssResult
+          .then(minified => {
+            // After minification, check if CSS consists entirely of invalid properties (no values)
+            // I.e., `color:` or `margin:;padding:` should be treated as empty
+            if (minified && /^(?:[a-z-]+:[;\s]*)+$/i.test(minified)) return '';
+            return minified;
+          })
+          .catch(err => {
+            if (!options.continueOnMinifyError) throw err;
+            options.log && options.log(err);
+            return originalAttrValue;
+          });
       }
+      // Sync path (`minifyCSS` disabled—identity function)
+      if (cssResult && /^(?:[a-z-]+:[;\s]*)+$/i.test(cssResult)) return '';
+      return cssResult != null ? cssResult : attrValue;
     }
     return attrValue;
-  } else if (isSrcset(attrName, tag)) {
+  }
+
+  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) {
+    const candidates = trimWhitespace(attrValue).split(/\s*,\s*/);
+    const processed = candidates.map(candidate => {
       let url = candidate;
       let descriptor = '';
       const match = candidate.match(/\s+([1-9][0-9]*w|[0-9]+(?:\.[0-9]+)?x)$/);
@@ -2414,47 +2457,65 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
           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;
+      const out = options.minifyURLs(url);
+      if (isThenable(out)) {
+        return out
+          .then(result => (typeof result === 'string' ? result : 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) {
+      return (typeof out === 'string' ? out : url) + descriptor;
+    });
+    if (processed.some(isThenable)) {
+      return Promise.all(processed).then(results => results.join(', '));
+    }
+    return processed.join(', ');
+  }
+
+  if (isMetaViewport(tag, attrs) && attrName === 'content') {
+    return 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') {
+  }
+
+  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)) {
+  }
+
+  if (options.customAttrCollapse && options.customAttrCollapse.test(attrName)) {
+    return trimWhitespace(attrValue.replace(/ ?[\n\r]+ ?/g, '').replace(/\s{2,}/g, options.conservativeCollapse ? ' ' : ''));
+  }
+
+  if (tag === 'script' && attrName === 'type') {
+    return trimWhitespace(attrValue.replace(/\s*;\s*/g, ';'));
+  }
+
+  if (isMediaQuery(tag, attrs, attrName)) {
     attrValue = trimWhitespace(attrValue);
     // Only minify actual media queries (those with features in parentheses)
     // Skip simple media types like `all`, `screen`, `print` which are already minimal
     if (!/[()]/.test(attrValue)) {
       return attrValue;
     }
-    try {
-      return await options.minifyCSS(attrValue, 'media');
-    } catch (err) {
-      if (!options.continueOnMinifyError) {
-        throw err;
-      }
-      options.log && options.log(err);
-      return attrValue;
+    const originalAttrValue = attrValue;
+    const cssResult = options.minifyCSS(attrValue, 'media');
+    if (isThenable(cssResult)) {
+      return cssResult.catch(err => {
+        if (!options.continueOnMinifyError) throw err;
+        options.log && options.log(err);
+        return originalAttrValue;
+      });
     }
-  } else if (tag === 'iframe' && attrName === 'srcdoc') {
+    return cssResult != null ? cssResult : attrValue;
+  }
+
+  if (tag === 'iframe' && attrName === 'srcdoc') {
     // Recursively minify HTML content within `srcdoc` attribute
     // Fast-path: Skip if nothing would change
     if (!shouldMinifyInnerHTML(options)) {
@@ -2462,6 +2523,7 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
     }
     return minifyHTMLSelf(attrValue, options, true);
   }
+
   return attrValue;
 }
 
@@ -2485,17 +2547,24 @@ function chooseAttributeQuote(attrValue, options) {
   return apos < quot ? '\'' : '"';
 }
 
-async function normalizeAttr(attr, attrs, tag, options, minifyHTML) {
+// Returns the normalized attribute object directly (sync) or as a Promise (async);
+// callers must handle both cases—use `isThenable()` to distinguish
+function normalizeAttr(attr, attrs, tag, options, minifyHTML) {
   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 = (await getDecodeHTMLStrict())(attrValue);
-    }
+  // Entity decoding requires a lazy import—async only when `&` is present
+  if (options.decodeEntities && attrValue && attrValue.indexOf('&') !== -1) {
+    return getDecodeHTMLStrict().then(decode => {
+      return normalizeAttrContinue(attrName, decode(attrValue), attr, attrs, tag, options, minifyHTML);
+    });
   }
 
+  return normalizeAttrContinue(attrName, attrValue, attr, attrs, tag, options, minifyHTML);
+}
+
+// Internal: Handles attribute normalization after entity decoding (if any)
+function normalizeAttrContinue(attrName, attrValue, attr, attrs, tag, options, minifyHTML) {
   if ((options.removeRedundantAttributes &&
        isAttributeRedundant(tag, attrName, attrValue, attrs)) ||
       (options.removeScriptTypeAttributes && tag === 'script' &&
@@ -2506,9 +2575,18 @@ async function normalizeAttr(attr, attrs, tag, options, minifyHTML) {
   }
 
   if (attrValue) {
-    attrValue = await cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTML);
+    const cleaned = cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTML);
+    if (isThenable(cleaned)) {
+      return cleaned.then(v => normalizeAttrFinish(attrName, v, attr, tag, options));
+    }
+    return normalizeAttrFinish(attrName, cleaned, attr, tag, options);
   }
 
+  return normalizeAttrFinish(attrName, attrValue, attr, tag, options);
+}
+
+// Internal: Final checks and result assembly after value cleaning
+function normalizeAttrFinish(attrName, attrValue, attr, tag, options) {
   if (options.removeEmptyAttributes &&
       canDeleteEmptyAttribute(tag, attrName, attrValue, options)) {
     return;
@@ -3734,31 +3812,47 @@ async function minifyHTML(value, options, partialMarkup) {
   let removeEmptyElementsExcept;
   if (options.removeEmptyElementsExcept && !Array.isArray(options.removeEmptyElementsExcept)) {
     if (options.log) {
-      options.log('Warning: “removeEmptyElementsExcept” option must be an array, received: ' + typeof options.removeEmptyElementsExcept);
+      options.log('Warning: `removeEmptyElementsExcept` option must be an array, received: ' + typeof options.removeEmptyElementsExcept);
     }
     removeEmptyElementsExcept = [];
   } else {
     removeEmptyElementsExcept = parseRemoveEmptyElementsExcept(options.removeEmptyElementsExcept, options) || [];
   }
 
-  // Temporarily replace ignored chunks with comments, so that we don’t have to worry what’s there.
-  // For all we care there might be completely-horribly-broken-alien-non-html-emoji-cthulhu-filled content
-  value = value.replace(/<!-- htmlmin:ignore -->([\s\S]*?)<!-- htmlmin:ignore -->/g, function (match, group1) {
-    if (!uidIgnore) {
-      uidIgnore = uniqueId(value);
-      const pattern = new RegExp('^' + uidIgnore + '([0-9]+)$');
-      uidIgnorePlaceholderPattern = new RegExp('^<!--' + uidIgnore + '(\\d+)-->$');
-      if (options.ignoreCustomComments) {
-        options.ignoreCustomComments = options.ignoreCustomComments.slice();
-      } else {
-        options.ignoreCustomComments = [];
+  // Temporarily replace ignored chunks with comments, so that we don’t have to worry what’s there;
+  // for all we care there might be completely-horribly-broken-alien-non-html-emoji-cthulhu-filled content
+  if (value.indexOf('<!-- htmlmin:ignore -->') !== -1) {
+    // Use `indexOf`-based O(n) loop instead of a global regex with [\s\S]*? to avoid O(n²)
+    // backtracking on adversarial HTML with many `<!--` prefixes but no closing marker
+    const ignoreMarker = '<!-- htmlmin:ignore -->';
+    const ignoreMarkerLen = ignoreMarker.length;
+    let ignoreResult = '';
+    let ignorePos = 0;
+    while (ignorePos < value.length) {
+      const ignoreStart = value.indexOf(ignoreMarker, ignorePos);
+      if (ignoreStart === -1) { ignoreResult += value.slice(ignorePos); break; }
+      ignoreResult += value.slice(ignorePos, ignoreStart);
+      const ignoreEnd = value.indexOf(ignoreMarker, ignoreStart + ignoreMarkerLen);
+      if (ignoreEnd === -1) { ignoreResult += value.slice(ignoreStart); break; }
+      const group1 = value.slice(ignoreStart + ignoreMarkerLen, ignoreEnd);
+      if (!uidIgnore) {
+        uidIgnore = uniqueId(value);
+        const pattern = new RegExp('^' + uidIgnore + '([0-9]+)$');
+        uidIgnorePlaceholderPattern = new RegExp('^<!--' + uidIgnore + '(\\d+)-->$');
+        if (options.ignoreCustomComments) {
+          options.ignoreCustomComments = options.ignoreCustomComments.slice();
+        } else {
+          options.ignoreCustomComments = [];
+        }
+        options.ignoreCustomComments.push(pattern);
       }
-      options.ignoreCustomComments.push(pattern);
+      const token = '<!--' + uidIgnore + ignoredMarkupChunks.length + '-->';
+      ignoredMarkupChunks.push(group1);
+      ignoreResult += token;
+      ignorePos = ignoreEnd + ignoreMarkerLen;
     }
-    const token = '<!--' + uidIgnore + ignoredMarkupChunks.length + '-->';
-    ignoredMarkupChunks.push(group1);
-    return token;
-  });
+    value = ignoreResult;
+  }
 
   // Create sort functions after `htmlmin:ignore` processing but before custom fragment UID markers
   // This allows proper frequency analysis with access to ignored content via UID tokens
@@ -3993,9 +4087,8 @@ async function minifyHTML(value, options, partialMarkup) {
         options.sortAttributes(tag, attrs);
       }
 
-      const normalizedAttrs = await Promise.all(
-        attrs.map(attr => normalizeAttr(attr, attrs, tag, options, minifyHTML))
-      );
+      const attrResults = attrs.map(attr => normalizeAttr(attr, attrs, tag, options, minifyHTML));
+      const normalizedAttrs = attrResults.some(isThenable) ? await Promise.all(attrResults) : attrResults;
       const parts = [];
       let isLast = true;
       for (let i = normalizedAttrs.length - 1; i >= 0; i--) {
@@ -4123,207 +4216,225 @@ async function minifyHTML(value, options, partialMarkup) {
         }
       }
     },
-    chars: async function (text, prevTag, nextTag, prevAttrs, nextAttrs) {
+    chars: function (text, prevTag, nextTag, prevAttrs, nextAttrs) {
       prevTag = prevTag === '' ? 'comment' : prevTag;
       nextTag = nextTag === '' ? 'comment' : nextTag;
       prevAttrs = prevAttrs || [];
       nextAttrs = nextAttrs || [];
-      if (options.decodeEntities && text && !specialContentElements.has(currentTag)) {
-        if (text.indexOf('&') !== -1) {
-          text = (await getDecodeHTML())(text);
-        }
-      }
-      // Trim outermost newline-based whitespace inside `pre`/`textarea` elements
-      // This removes trailing newlines often added by template engines before closing tags
-      // Only trims single trailing newlines (multiple newlines are likely intentional formatting)
-      if (options.collapseWhitespace && stackNoTrimWhitespace.length) {
-        const topTag = stackNoTrimWhitespace[stackNoTrimWhitespace.length - 1];
-        if (preTextareaDepth > 0) {
-          // Trim trailing whitespace only if it ends with a single newline (not multiple)
-          // Multiple newlines are likely intentional formatting, single newline is often a template artifact
-          // Treat CRLF (`\r\n`), CR (`\r`), and LF (`\n`) as single line-ending units
-          if (nextTag && nextTag === '/' + topTag && /[^\r\n](?:\r\n|\r|\n)[ \t]*$/.test(text)) {
-            text = text.replace(/(?:\r\n|\r|\n)[ \t]*$/, '');
+
+      // Detect whether any async work is actually needed for this text node
+      const needsDecode = options.decodeEntities && text && !specialContentElements.has(currentTag) && text.indexOf('&') !== -1;
+      const needsProcessScript = specialContentElements.has(currentTag) && (options.processScripts || hasJsonScriptType(currentAttrs));
+      const needsMinifyJS = options.minifyJS !== identity && isExecutableScript(currentTag, currentAttrs);
+      const needsMinifyCSS = options.minifyCSS !== identity && isStyleElement(currentTag, currentAttrs);
+
+      // Whitespace collapsing phase (sync); captures `prevTag`/`nextTag`/`prevAttrs`/`nextAttrs` from outer scope
+      function charsCollapse(text) {
+        // Trim outermost newline-based whitespace inside `pre`/`textarea` elements
+        // This removes trailing newlines often added by template engines before closing tags
+        // Only trims single trailing newlines (multiple newlines are likely intentional formatting)
+        if (options.collapseWhitespace && stackNoTrimWhitespace.length) {
+          const topTag = stackNoTrimWhitespace[stackNoTrimWhitespace.length - 1];
+          if (preTextareaDepth > 0) {
+            // Trim trailing whitespace only if it ends with a single newline (not multiple)
+            // Multiple newlines are likely intentional formatting, single newline is often a template artifact
+            // Treat CRLF (`\r\n`), CR (`\r`), and LF (`\n`) as single line-ending units
+            if (nextTag && nextTag === '/' + topTag && /[^\r\n](?:\r\n|\r|\n)[ \t]*$/.test(text)) {
+              text = text.replace(/(?:\r\n|\r|\n)[ \t]*$/, '');
+            }
           }
         }
-      }
-      if (options.collapseWhitespace) {
-        if (!stackNoTrimWhitespace.length) {
-          if (prevTag === 'comment') {
-            const prevComment = buffer[buffer.length - 1];
-            if (!uidIgnore || prevComment.indexOf(uidIgnore) === -1) {
-              if (!prevComment) {
-                prevTag = charsPrevTag;
-              }
-              if (buffer.length > 1 && (!prevComment || (!options.conservativeCollapse && / $/.test(currentChars)))) {
-                const charsIndex = buffer.length - 2;
-                buffer[charsIndex] = buffer[charsIndex].replace(/\s+$/, function (trailingSpaces) {
-                  text = trailingSpaces + text;
-                  return '';
-                });
+        if (options.collapseWhitespace) {
+          if (!stackNoTrimWhitespace.length) {
+            if (prevTag === 'comment') {
+              const prevComment = buffer[buffer.length - 1];
+              if (!uidIgnore || prevComment.indexOf(uidIgnore) === -1) {
+                if (!prevComment) {
+                  prevTag = charsPrevTag;
+                }
+                if (buffer.length > 1 && (!prevComment || (!options.conservativeCollapse && / $/.test(currentChars)))) {
+                  const charsIndex = buffer.length - 2;
+                  buffer[charsIndex] = buffer[charsIndex].replace(/\s+$/, function (trailingSpaces) {
+                    text = trailingSpaces + text;
+                    return '';
+                  });
+                }
               }
             }
-          }
-          if (prevTag) {
-            if (prevTag === '/nobr' || prevTag === 'wbr') {
-              if (/^\s/.test(text)) {
-                let tagIndex = buffer.length - 1;
-                while (tagIndex > 0 && buffer[tagIndex].lastIndexOf('<' + prevTag) !== 0) {
-                  tagIndex--;
+            if (prevTag) {
+              if (prevTag === '/nobr' || prevTag === 'wbr') {
+                if (/^\s/.test(text)) {
+                  let tagIndex = buffer.length - 1;
+                  while (tagIndex > 0 && buffer[tagIndex].lastIndexOf('<' + prevTag) !== 0) {
+                    tagIndex--;
+                  }
+                  trimTrailingWhitespace(tagIndex - 1, 'br');
                 }
-                trimTrailingWhitespace(tagIndex - 1, 'br');
+              } else if (inlineTextSet.has(prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag)) {
+                text = collapseWhitespace(text, options, /(?:^|\s)$/.test(currentChars));
               }
-            } else if (inlineTextSet.has(prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag)) {
-              text = collapseWhitespace(text, options, /(?:^|\s)$/.test(currentChars));
+            }
+            if (prevTag || nextTag) {
+              text = collapseWhitespaceSmart(text, prevTag, nextTag, prevAttrs, nextAttrs, options, inlineElements, inlineTextSet);
+            } else {
+              text = collapseWhitespace(text, options, true, true);
+            }
+            if (!text && /\s$/.test(currentChars) && prevTag && prevTag.charAt(0) === '/') {
+              trimTrailingWhitespace(buffer.length - 1, nextTag);
             }
           }
-          if (prevTag || nextTag) {
-            text = collapseWhitespaceSmart(text, prevTag, nextTag, prevAttrs, nextAttrs, options, inlineElements, inlineTextSet);
-          } else {
-            text = collapseWhitespace(text, options, true, true);
+          if (!stackNoCollapseWhitespace.length && nextTag !== 'html' && !(prevTag && nextTag)) {
+            text = collapseWhitespace(text, options, false, false, true);
           }
-          if (!text && /\s$/.test(currentChars) && prevTag && prevTag.charAt(0) === '/') {
-            trimTrailingWhitespace(buffer.length - 1, nextTag);
+        }
+        return text;
+      }
+
+      // Finalization phase (sync): Optional tag handling, entity re-encoding, buffer push
+      function charsFinalize(text) {
+        if (options.removeOptionalTags && text) {
+          // `<html>` may be omitted if first thing inside is not a comment
+          // `<body>` may be omitted if first thing inside is not space, comment, `<meta>`, `<link>`, `<script>`, `<style>`, or `<template>`
+          if (optionalStartTag === 'html' || (optionalStartTag === 'body' && !/^\s/.test(text))) {
+            removeStartTag();
+          }
+          optionalStartTag = '';
+          // `</html>` or `</body>` may be omitted if not followed by comment
+          // `</head>`, `</colgroup>`, or `</caption>` may be omitted if not followed by space or comment
+          if (optionalEndTagEmitted && (compactElements.has(optionalEndTag) || (looseElements.has(optionalEndTag) && !/^\s/.test(text)))) {
+            removeEndTag();
+          }
+          // Don’t reset `optionalEndTag` if text is only whitespace and will be collapsed (not conservatively)
+          if (!/^\s+$/.test(text) || !options.collapseWhitespace || options.conservativeCollapse) {
+            optionalEndTag = '';
+            optionalEndTagEmitted = false;
           }
         }
-        if (!stackNoCollapseWhitespace.length && nextTag !== 'html' && !(prevTag && nextTag)) {
-          text = collapseWhitespace(text, options, false, false, true);
+        charsPrevTag = /^\s*$/.test(text) ? prevTag : 'comment';
+        if (options.decodeEntities && text && !specialContentElements.has(currentTag)) {
+          // Escape any `&` symbols that start either:
+          // 1. a legacy-named character reference (i.e., one that doesn’t end with `;`)
+          // 2. or any other character reference (i.e., one that does end with `;`)
+          // Note that `&` can be escaped as `&amp`, without the semicolon.
+          // https://mathiasbynens.be/notes/ambiguous-ampersands
+          if (text.indexOf('&') !== -1) {
+            text = text.replace(RE_LEGACY_ENTITIES, '&amp$1');
+          }
+          if (text.indexOf('<') !== -1) {
+            text = text.replace(RE_ESCAPE_LT, '&lt;');
+          }
         }
+        if (uidPattern && options.collapseWhitespace && stackNoTrimWhitespace.length) {
+          text = text.replace(uidPattern, function (match, prefix, index) {
+            return ignoredCustomMarkupChunks[+index][0];
+          });
+        }
+        currentChars += text;
+        if (text) {
+          hasChars = true;
+        }
+        buffer.push(text);
       }
-      if (specialContentElements.has(currentTag) && (options.processScripts || hasJsonScriptType(currentAttrs))) {
-        text = await processScript(text, options, currentAttrs, minifyHTML);
-      }
-      if (isExecutableScript(currentTag, currentAttrs)) {
-        text = await options.minifyJS(text);
-      }
-      if (isStyleElement(currentTag, currentAttrs)) {
-        text = await options.minifyCSS(text);
+
+      // Fast path: All work is sync—skip async machinery entirely
+      if (!needsDecode && !needsProcessScript && !needsMinifyJS && !needsMinifyCSS) {
+        charsFinalize(charsCollapse(text));
+        return;
       }
-      if (options.removeOptionalTags && text) {
-        // `<html>` may be omitted if first thing inside is not a comment
-        // `<body>` may be omitted if first thing inside is not space, comment, `<meta>`, `<link>`, `<script>`, `<style>`, or `<template>`
-        if (optionalStartTag === 'html' || (optionalStartTag === 'body' && !/^\s/.test(text))) {
-          removeStartTag();
-        }
-        optionalStartTag = '';
-        // `</html>` or `</body>` may be omitted if not followed by comment
-        // `</head>`, `</colgroup>`, or `</caption>` may be omitted if not followed by space or comment
-        if (optionalEndTagEmitted && (compactElements.has(optionalEndTag) || (looseElements.has(optionalEndTag) && !/^\s/.test(text)))) {
-          removeEndTag();
+
+      // Slow path: At least one async step required
+      return (async () => {
+        if (needsDecode) {
+          text = (await getDecodeHTML())(text);
         }
-        // Don't reset optionalEndTag if text is only whitespace and will be collapsed (not conservatively)
-        if (!/^\s+$/.test(text) || !options.collapseWhitespace || options.conservativeCollapse) {
-          optionalEndTag = '';
-          optionalEndTagEmitted = false;
+        text = charsCollapse(text);
+        if (needsProcessScript) {
+          text = await processScript(text, options, currentAttrs, minifyHTML);
         }
-      }
-      charsPrevTag = /^\s*$/.test(text) ? prevTag : 'comment';
-      if (options.decodeEntities && text && !specialContentElements.has(currentTag)) {
-        // Escape any `&` symbols that start either:
-        // 1. a legacy-named character reference (i.e., one that doesn’t end with `;`)
-        // 2. or any other character reference (i.e., one that does end with `;`)
-        // Note that `&` can be escaped as `&amp`, without the semicolon.
-        // https://mathiasbynens.be/notes/ambiguous-ampersands
-        if (text.indexOf('&') !== -1) {
-          text = text.replace(RE_LEGACY_ENTITIES, '&amp$1');
+        if (needsMinifyJS) {
+          text = await options.minifyJS(text);
         }
-        if (text.indexOf('<') !== -1) {
-          text = text.replace(RE_ESCAPE_LT, '&lt;');
+        if (needsMinifyCSS) {
+          text = await options.minifyCSS(text);
         }
-      }
-      if (uidPattern && options.collapseWhitespace && stackNoTrimWhitespace.length) {
-        text = text.replace(uidPattern, function (match, prefix, index) {
-          return ignoredCustomMarkupChunks[+index][0];
-        });
-      }
-      currentChars += text;
-      if (text) {
-        hasChars = true;
-      }
-      buffer.push(text);
+        charsFinalize(text);
+      })();
     },
-    comment: async function (text, nonStandard) {
+    comment: function (text, nonStandard) {
       const prefix = nonStandard ? '<!' : '<!--';
       const suffix = nonStandard ? '>' : '-->';
-      if (isConditionalComment(text)) {
-        text = prefix + await cleanConditionalComment(text, options, minifyHTML) + suffix;
-      } else if (options.removeComments) {
-        if (isIgnoredComment(text, options)) {
-          text = '<!--' + text + '-->';
-        } else {
-          text = '';
+
+      // Finalization phase (sync): Optional tag handling, `htmlmin:ignore` whitespace collapsing, buffer push
+      function commentFinalize(comment) {
+        if (options.removeOptionalTags && comment) {
+          // Preceding comments suppress tag omissions
+          optionalStartTag = '';
+          optionalEndTag = '';
+          optionalEndTagEmitted = false;
         }
-      } else {
-        text = prefix + text + suffix;
-      }
-      if (options.removeOptionalTags && text) {
-        // Preceding comments suppress tag omissions
-        optionalStartTag = '';
-        optionalEndTag = '';
-        optionalEndTagEmitted = false;
-      }
 
-      // Optimize whitespace collapsing between consecutive `htmlmin:ignore` placeholder comments
-      if (options.collapseWhitespace && text && uidIgnorePlaceholderPattern) {
-        if (uidIgnorePlaceholderPattern.test(text)) {
-          // Check if previous buffer items are: [ignore-placeholder, whitespace-only text]
-          if (buffer.length >= 2) {
-            const prevText = buffer[buffer.length - 1];
-            const prevComment = buffer[buffer.length - 2];
-
-            // Check if previous item is whitespace-only and item before that is ignore-placeholder
-            if (prevText && /^\s+$/.test(prevText) && prevComment && uidIgnorePlaceholderPattern.test(prevComment)) {
-              // Extract the index from both placeholders to check their content
-              const currentMatch = text.match(uidIgnorePlaceholderPattern);
-              const prevMatch = prevComment.match(uidIgnorePlaceholderPattern);
-
-              if (currentMatch && prevMatch) {
-                const currentIndex = +currentMatch[1];
-                const prevIndex = +prevMatch[1];
-
-                // Defensive bounds check to ensure indices are valid
-                if (currentIndex < ignoredMarkupChunks.length && prevIndex < ignoredMarkupChunks.length) {
-                  const currentContent = ignoredMarkupChunks[currentIndex];
-                  const prevContent = ignoredMarkupChunks[prevIndex];
-
-                  // Only collapse whitespace if both blocks contain HTML (start with `<`)
-                  // Don’t collapse if either contains plain text, as that would change meaning
-                  // Note: This check will match HTML comments (`<!-- … -->`), but the tag name
-                  // regex below requires starting with a letter, so comments are intentionally
-                  // excluded by the `currentTagMatch && prevTagMatch` guard
-                  if (currentContent && prevContent && /^\s*</.test(currentContent) && /^\s*</.test(prevContent)) {
-                    // Extract tag names from the HTML content (excludes comments, processing instructions, etc.)
-                    const currentTagMatch = currentContent.match(/^\s*<([a-zA-Z][\w:-]*)/);
-                    const prevTagMatch = prevContent.match(/^\s*<([a-zA-Z][\w:-]*)/);
-
-                    // Only collapse if both matched valid element tags (not comments/text)
-                    // and both tags are block-level (inline elements need whitespace preserved)
-                    if (currentTagMatch && prevTagMatch) {
-                      const currentTag = options.name(currentTagMatch[1]);
-                      const prevTag = options.name(prevTagMatch[1]);
-
-                      // Don’t collapse between inline elements
-                      if (!inlineElements.has(currentTag) && !inlineElements.has(prevTag)) {
-                        // Collapse whitespace respecting context rules
-                        let collapsedText = prevText;
-
-                        // Apply `collapseWhitespace` with appropriate context
-                        if (!stackNoTrimWhitespace.length && !stackNoCollapseWhitespace.length) {
-                          // Not in pre or other no-collapse context
-                          if (options.preserveLineBreaks && /[\n\r]/.test(prevText)) {
-                            // Preserve line break as single newline
-                            collapsedText = '\n';
-                          } else if (options.conservativeCollapse) {
-                            // Conservative mode: keep single space
-                            collapsedText = ' ';
-                          } else {
-                            // Aggressive mode: remove all whitespace
-                            collapsedText = '';
+        // Optimize whitespace collapsing between consecutive `htmlmin:ignore` placeholder comments
+        if (options.collapseWhitespace && comment && uidIgnorePlaceholderPattern) {
+          if (uidIgnorePlaceholderPattern.test(comment)) {
+            // Check if previous buffer items are: [ignore-placeholder, whitespace-only text]
+            if (buffer.length >= 2) {
+              const prevText = buffer[buffer.length - 1];
+              const prevComment = buffer[buffer.length - 2];
+
+              // Check if previous item is whitespace-only and item before that is ignore-placeholder
+              if (prevText && /^\s+$/.test(prevText) && prevComment && uidIgnorePlaceholderPattern.test(prevComment)) {
+                // Extract the index from both placeholders to check their content
+                const currentMatch = comment.match(uidIgnorePlaceholderPattern);
+                const prevMatch = prevComment.match(uidIgnorePlaceholderPattern);
+
+                if (currentMatch && prevMatch) {
+                  const currentIndex = +currentMatch[1];
+                  const prevIndex = +prevMatch[1];
+
+                  // Defensive bounds check to ensure indices are valid
+                  if (currentIndex < ignoredMarkupChunks.length && prevIndex < ignoredMarkupChunks.length) {
+                    const currentContent = ignoredMarkupChunks[currentIndex];
+                    const prevContent = ignoredMarkupChunks[prevIndex];
+
+                    // Only collapse whitespace if both blocks contain HTML (start with `<`)
+                    // Don’t collapse if either contains plain text, as that would change meaning
+                    // Note: This check will match HTML comments (`<!-- … -->`), but the tag name
+                    // regex below requires starting with a letter, so comments are intentionally
+                    // excluded by the `currentTagMatch && prevTagMatch` guard
+                    if (currentContent && prevContent && /^\s*</.test(currentContent) && /^\s*</.test(prevContent)) {
+                      // Extract tag names from the HTML content (excludes comments, processing instructions, etc.)
+                      const currentTagMatch = currentContent.match(/^\s*<([a-zA-Z][\w:-]*)/);
+                      const prevTagMatch = prevContent.match(/^\s*<([a-zA-Z][\w:-]*)/);
+
+                      // Only collapse if both matched valid element tags (not comments/text)
+                      // and both tags are block-level (inline elements need whitespace preserved)
+                      if (currentTagMatch && prevTagMatch) {
+                        const currentTag = options.name(currentTagMatch[1]);
+                        const prevTag = options.name(prevTagMatch[1]);
+
+                        // Don’t collapse between inline elements
+                        if (!inlineElements.has(currentTag) && !inlineElements.has(prevTag)) {
+                          // Collapse whitespace respecting context rules
+                          let collapsedText = prevText;
+
+                          // Apply `collapseWhitespace` with appropriate context
+                          if (!stackNoTrimWhitespace.length && !stackNoCollapseWhitespace.length) {
+                            // Not in pre or other no-collapse context
+                            if (options.preserveLineBreaks && /[\n\r]/.test(prevText)) {
+                              // Preserve line break as single newline
+                              collapsedText = '\n';
+                            } else if (options.conservativeCollapse) {
+                              // Conservative mode: Keep single space
+                              collapsedText = ' ';
+                            } else {
+                              // Aggressive mode: Remove all whitespace
+                              collapsedText = '';
+                            }
                           }
-                        }
 
-                        // Replace the whitespace in buffer
-                        buffer[buffer.length - 1] = collapsedText;
+                          // Replace the whitespace in buffer
+                          buffer[buffer.length - 1] = collapsedText;
+                        }
                       }
                     }
                   }
@@ -4332,9 +4443,27 @@ async function minifyHTML(value, options, partialMarkup) {
             }
           }
         }
+
+        buffer.push(comment);
       }
 
-      buffer.push(text);
+      // Only conditional comments require async work (recursive minification)
+      if (isConditionalComment(text)) {
+        return cleanConditionalComment(text, options, minifyHTML).then(cleaned => {
+          commentFinalize(prefix + cleaned + suffix);
+        });
+      }
+
+      if (options.removeComments) {
+        if (isIgnoredComment(text, options)) {
+          text = '<!--' + text + '-->';
+        } else {
+          text = '';
+        }
+      } else {
+        text = prefix + text + suffix;
+      }
+      commentFinalize(text);
     },
     doctype: function (doctype) {
       buffer.push(options.useShortDoctype