html-minifier-next 5.1.2 → 5.1.3

package/dist/types/htmlminifier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"AAorDO,8BAJI,MAAM,YACN,eAAe,GACb,OAAO,CAAC,MAAM,CAAC,CAwB3B;;;;;;;;;;;;UAv9CS,MAAM;YACN,MAAM;YACN,MAAM;mBACN,MAAM;iBACN,MAAM;kBACN,MAAM;;;;;;;;;;;;;4BAQN,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE,qBAAqB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO;;;;;;;wBAMjG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,SAAS,EAAE,iBAAiB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO;;;;;;;;;;eAMhH,MAAM;;;;;;;;;;cASN,MAAM;;;;;;;;;;eASN,MAAM;;;;;;;;oBASN,OAAO;;;;;;;;;kCAON,OAAO;;;;;;;;gCAQR,OAAO;;;;;;;;kCAOP,OAAO;;;;;;;;yBAOP,OAAO;;;;;;;;2BAOP,OAAO;;;;;;;;4BAOP,OAAO;;;;;;;2BAOP,OAAO;;;;;;;;uBAMP,MAAM,EAAE;;;;;;yBAOR,MAAM;;;;;;yBAKN,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE;;;;;;;4BAKlB,MAAM,EAAE;;;;;;;oCAMR,MAAM;;;;;;;qBAMN,OAAO;;;;;;;;2BAOP,MAAM,EAAE;;;;;;;;;4BAOR,MAAM,EAAE;;;;;;;+BAQR,OAAO;;;;;;;2BAMP,SAAS,CAAC,MAAM,CAAC;;;;;;uBAMjB,OAAO;;;;;;;;UAKP,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI;;;;;;;;qBAO1B,MAAM;;;;;;;oBAON,MAAM;;;;;;;;mBAMN,OAAO;;;;;;;;;;gBAOP,OAAO,GAAG,OAAO,CAAC,OAAO,cAAc,EAAE,gBAAgB,CAAC,OAAO,cAAc,EAAE,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;;;;;;;eAS9J,OAAO,GAAG,OAAO,QAAQ,EAAE,aAAa,GAAG;QAAC,MAAM,CAAC,EAAE,QAAQ,GAAG,KAAK,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;;;iBAa3J,OAAO,GAAG,MAAM,GAAG;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;;gBASjF,OAAO,MAAS;;;;;;;;WAQhB,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM;;;;;;;+BAOxB,OAAO;;;;;;;;;;oBAMP,OAAO;;;;;;;;yBASP,OAAO;;;;;;;gCAOP,OAAO;;;;;;;;iCAMP,OAAO;;;;;;;;;;qBAOP,MAAM,EAAE;;;;;;;qBASR,IAAI,GAAG,GAAG;;;;;;;4BAMV,OAAO;;;;;;;;qBAMP,OAAO;;;;;;;;;4BAOP,OAAO,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;;;;;;;;0BAQtD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;gCAOP,MAAM,EAAE;;;;;;;;yBAyBR,OAAO;;;;;;;;gCAOP,OAAO;;;;;;;iCAOP,OAAO;;;;;;;oCAMP,OAAO;;;;;;;;;;0BAMP,OAAO;;;;;;;;;qBASP,OAAO,GAAG,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,IAAI,CAAC;;;;;;;;;qBAQzD,OAAO,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;;;;;;;;0BAQrC,OAAO;;;;;;;sBAOP,OAAO;;wBAzoBkC,cAAc;0BAAd,cAAc;+BAAd,cAAc"}

package/dist/types/htmlparser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"htmlparser.d.ts","sourceRoot":"","sources":["../../src/htmlparser.js"],"names":[],"mappings":"AA8CA,4BAAkE;AAuFlE;IACE,qCAGC;IAFC,UAAgB;IAChB,aAAsB;IAGxB,uBA8lBC;CACF"}
+{"version":3,"file":"htmlparser.d.ts","sourceRoot":"","sources":["../../src/htmlparser.js"],"names":[],"mappings":"AAgDA,4BAAkE;AAuFlE;IACE,qCAGC;IAFC,UAAgB;IAChB,aAAsB;IAGxB,uBAomBC;CACF"}

package/dist/types/lib/attributes.d.ts

@@ -19,12 +19,8 @@ export function isMetaViewport(tag: any, attrs: any): boolean;
 export function isContentSecurityPolicy(tag: any, attrs: any): boolean;
 export function canDeleteEmptyAttribute(tag: any, attrName: any, attrValue: any, options: any): any;
 export function hasAttrName(name: any, attrs: any): boolean;
-export function cleanAttributeValue(tag: any, attrName: any, attrValue: any, options: any, attrs: any, minifyHTMLSelf: any): Promise<any>;
-export function normalizeAttr(attr: any, attrs: any, tag: any, options: any, minifyHTML: any): Promise<{
-    attr: any;
-    name: any;
-    value: any;
-}>;
+export function cleanAttributeValue(tag: any, attrName: any, attrValue: any, options: any, attrs: any, minifyHTMLSelf: any): any;
+export function normalizeAttr(attr: any, attrs: any, tag: any, options: any, minifyHTML: any): any;
 export function buildAttr(normalized: any, hasUnarySlash: any, options: any, isLast: any, uidAttr: any): any;
 /**
  * Remove duplicate attributes from an attribute list.

package/dist/types/lib/attributes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../src/lib/attributes.js"],"names":[],"mappings":"AAmCA,yDAEC;AAED,mEAOC;AAED,uEAWC;AAED,8DAGC;AAED,4EAOC;AAgCD,mGAuCC;AAED,mEAGC;AAED,qEAGC;AAED,kEAWC;AAED,sEAGC;AAED,8DAWC;AAED,2EAIC;AAmBD,qEAGC;AAgBD,wEAGC;AAED,sEAUC;AAED,2EAEC;AAED,2DAEC;AAED,8DAUC;AAED,uEAUC;AAED,oGASC;AAED,4DAOC;AAID,0IAqIC;AAsBD;;;;GAsCC;AAED,6GAuHC;AA3hBD;;;;;;;GAOG;AACH,mEAHW,OAAO,SAuBjB"}
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../src/lib/attributes.js"],"names":[],"mappings":"AAoCA,yDAEC;AAED,mEAOC;AAED,uEAWC;AAED,8DAGC;AAED,4EAOC;AAgCD,mGAuCC;AAED,mEAGC;AAED,qEAGC;AAED,kEAWC;AAED,sEAGC;AAED,8DAWC;AAED,2EAIC;AAmBD,qEAGC;AAgBD,wEAGC;AAED,sEAUC;AAED,2EAEC;AAED,2DAEC;AAED,8DAUC;AAED,uEAUC;AAED,oGASC;AAED,4DAOC;AAMD,iIA0KC;AAwBD,mGAYC;AA0CD,6GAuHC;AAllBD;;;;;;;GAOG;AACH,mEAHW,OAAO,SAuBjB"}

package/dist/types/lib/utils.d.ts

@@ -9,7 +9,7 @@ export class LRU {
 }
 export function uniqueId(value: any): string;
 export function identity(value: any): any;
-export function identityAsync(value: any): Promise<any>;
+export function isThenable(value: any): boolean;
 export function lowercase(value: any): any;
 /**
  * Asynchronously replace matches in a string

package/dist/types/lib/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.js"],"names":[],"mappings":"AAEA,+CAUC;AAID;IACE,4BAGC;IAFC,cAAkB;IAClB,mBAAoB;IAEtB,mBAQC;IACD,gCAOC;IACD,uBAAqC;CACtC;AAID,6CAMC;AAID,0CAEC;AAED,wDAEC;AAED,2CAEC;AAID;;;;;;GAMG;AACH,kCALW,MAAM,SACN,MAAM,sBAEJ,OAAO,CAAC,MAAM,CAAC,CAY3B;AAID,6CAUC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.js"],"names":[],"mappings":"AAEA,+CAUC;AAID;IACE,4BAGC;IAFC,cAAkB;IAClB,mBAAoB;IAEtB,mBAQC;IACD,gCAOC;IACD,uBAAqC;CACtC;AAID,6CAMC;AAID,0CAEC;AAED,gDAEC;AAED,2CAEC;AAID;;;;;;GAMG;AACH,kCALW,MAAM,SACN,MAAM,sBAEJ,OAAO,CAAC,MAAM,CAAC,CAY3B;AAID,6CAUC"}

package/package.json

@@ -95,5 +95,5 @@
   },
   "type": "module",
   "types": "./dist/types/htmlminifier.d.ts",
-  "version": "5.1.2"
+  "version": "5.1.3"
 }

package/src/htmlminifier.js

@@ -4,7 +4,7 @@ import { HTMLParser, endTag } from './htmlparser.js';
 import TokenChain from './tokenchain.js';
 import { presets, getPreset, getPresetNames } from './presets.js';
 
-import { LRU, identity, lowercase, uniqueId } from './lib/utils.js';
+import { LRU, identity, isThenable, lowercase, uniqueId } from './lib/utils.js';
 
 import {
   RE_LEGACY_ENTITIES,
@@ -921,31 +921,33 @@ 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) {
+    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 = [];
+        }
+        options.ignoreCustomComments.push(pattern);
       }
-      options.ignoreCustomComments.push(pattern);
-    }
-    const token = '<!--' + uidIgnore + ignoredMarkupChunks.length + '-->';
-    ignoredMarkupChunks.push(group1);
-    return token;
-  });
+      const token = '<!--' + uidIgnore + ignoredMarkupChunks.length + '-->';
+      ignoredMarkupChunks.push(group1);
+      return token;
+    });
+  }
 
   // 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
@@ -1180,9 +1182,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--) {
@@ -1310,207 +1311,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;
+                        }
                       }
                     }
                   }
@@ -1519,9 +1538,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