html-minifier-next 4.9.1 → 4.10.0

package/dist/htmlminifier.esm.bundle.js

@@ -5147,18 +5147,6 @@ function requireLib () {
 var libExports = requireLib();
 var RelateURL = /*@__PURE__*/getDefaultExportFromCjs(libExports);
 
-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());
-}
-
 /*!
  * HTML Parser By John Resig (ejohn.org)
  * Modified by Juriy “kangax” Zaytsev
@@ -5166,6 +5154,15 @@ async function replaceAsync(str, regex, asyncFn) {
  * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js
  */
 
+/*
+ * // Use like so:
+ * HTMLParser(htmlString, {
+ *     start: function(tag, attrs, unary) {},
+ *     end: function(tag) {},
+ *     chars: function(text) {},
+ *     comment: function(text) {}
+ * });
+ */
 
 class CaseInsensitiveSet extends Set {
   has(str) {
@@ -5234,6 +5231,9 @@ const preCompiledStackedTags = {
   'noscript': /([\s\S]*?)<\/noscript[^>]*>/i
 };
 
+// Cache for compiled attribute regexes per handler configuration
+const attrRegexCache = new WeakMap();
+
 function attrForHandler(handler) {
   let pattern = singleAttrIdentifier.source +
     '(?:\\s*(' + joinSingleAttrAssigns(handler) + ')' +
@@ -5271,22 +5271,47 @@ class HTMLParser {
   }
 
   async parse() {
-    let html = this.html;
     const handler = this.handler;
+    const fullHtml = this.html;
+    const fullLength = fullHtml.length;
 
     const stack = []; let lastTag;
-    const attribute = attrForHandler(handler);
-    let last, prevTag = undefined, nextTag = undefined;
-
-    // Track position for better error messages
-    let position = 0;
-    const getLineColumn = (pos) => {
-      const lines = this.html.slice(0, pos).split('\n');
-      return { line: lines.length, column: lines[lines.length - 1].length + 1 };
+    // Use cached attribute regex if available
+    let attribute = attrRegexCache.get(handler);
+    if (!attribute) {
+      attribute = attrForHandler(handler);
+      attrRegexCache.set(handler, attribute);
+    }
+    let prevTag = undefined, nextTag = undefined;
+
+    // Index-based parsing
+    let pos = 0;
+    let lastPos;
+
+    // Helper to get remaining HTML from current position
+    const remaining = () => fullHtml.slice(pos);
+
+    // Helper to advance position
+    const advance = (n) => { pos += n; };
+
+    // Lazy line/column calculation—only compute on actual errors
+    const getLineColumn = (position) => {
+      let line = 1;
+      let column = 1;
+      for (let i = 0; i < position; i++) {
+        if (fullHtml[i] === '\n') {
+          line++;
+          column = 1;
+        } else {
+          column++;
+        }
+      }
+      return { line, column };
     };
 
-    while (html) {
-      last = html;
+    while (pos < fullLength) {
+      lastPos = pos;
+      const html = remaining();
       // Make sure we’re not in a `script` or `style` element
       if (!lastTag || !special.has(lastTag)) {
         let textEnd = html.indexOf('<');
@@ -5299,7 +5324,7 @@ class HTMLParser {
               if (handler.comment) {
                 await handler.comment(html.substring(4, commentEnd));
               }
-              html = html.substring(commentEnd + 3);
+              advance(commentEnd + 3);
               prevTag = '';
               continue;
             }
@@ -5313,7 +5338,7 @@ class HTMLParser {
               if (handler.comment) {
                 await handler.comment(html.substring(2, conditionalEnd + 1), true /* non-standard */);
               }
-              html = html.substring(conditionalEnd + 2);
+              advance(conditionalEnd + 2);
               prevTag = '';
               continue;
             }
@@ -5325,7 +5350,7 @@ class HTMLParser {
             if (handler.doctype) {
               handler.doctype(doctypeMatch[0]);
             }
-            html = html.substring(doctypeMatch[0].length);
+            advance(doctypeMatch[0].length);
             prevTag = '';
             continue;
           }
@@ -5333,8 +5358,8 @@ class HTMLParser {
           // End tag
           const endTagMatch = html.match(endTag);
           if (endTagMatch) {
-            html = html.substring(endTagMatch[0].length);
-            await replaceAsync(endTagMatch[0], endTag, parseEndTag);
+            advance(endTagMatch[0].length);
+            await parseEndTag(endTagMatch[0], endTagMatch[1]);
             prevTag = '/' + endTagMatch[1].toLowerCase();
             continue;
           }
@@ -5342,7 +5367,7 @@ class HTMLParser {
           // Start tag
           const startTagMatch = parseStartTag(html);
           if (startTagMatch) {
-            html = startTagMatch.rest;
+            advance(startTagMatch.advance);
             await handleStartTag(startTagMatch);
             prevTag = startTagMatch.tagName.toLowerCase();
             continue;
@@ -5357,18 +5382,19 @@ class HTMLParser {
         let text;
         if (textEnd >= 0) {
           text = html.substring(0, textEnd);
-          html = html.substring(textEnd);
+          advance(textEnd);
         } else {
           text = html;
-          html = '';
+          advance(html.length);
         }
 
         // Next tag
-        let nextTagMatch = parseStartTag(html);
+        const nextHtml = remaining();
+        let nextTagMatch = parseStartTag(nextHtml);
         if (nextTagMatch) {
           nextTag = nextTagMatch.tagName;
         } else {
-          nextTagMatch = html.match(endTag);
+          nextTagMatch = nextHtml.match(endTag);
           if (nextTagMatch) {
             nextTag = '/' + nextTagMatch[1];
           } else {
@@ -5385,45 +5411,50 @@ class HTMLParser {
         // Use pre-compiled regex for common tags (`script`, `style`, `noscript`) to avoid regex creation overhead
         const reStackedTag = preCompiledStackedTags[stackedTag] || reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)</' + stackedTag + '[^>]*>', 'i'));
 
-        html = await replaceAsync(html, reStackedTag, async (_, text) => {
+        const m = reStackedTag.exec(html);
+        if (m) {
+          let text = m[1];
           if (stackedTag !== 'script' && stackedTag !== 'style' && stackedTag !== 'noscript') {
             text = text
               .replace(/<!--([\s\S]*?)-->/g, '$1')
               .replace(/<!\[CDATA\[([\s\S]*?)]]>/g, '$1');
           }
-
           if (handler.chars) {
             await handler.chars(text);
           }
-
-          return '';
-        });
-
-        await parseEndTag('</' + stackedTag + '>', stackedTag);
+          // Advance HTML past the matched special tag content and its closing tag
+          advance(m.index + m[0].length);
+          await parseEndTag('</' + stackedTag + '>', stackedTag);
+        } else {
+          // No closing tag found; to avoid infinite loop, break similarly to previous behavior
+          if (handler.continueOnParseError && handler.chars && html) {
+            await handler.chars(html[0], prevTag, '');
+            advance(1);
+          } else {
+            break;
+          }
+        }
       }
 
-      if (html === last) {
+      if (pos === lastPos) {
         if (handler.continueOnParseError) {
           // Skip the problematic character and continue
           if (handler.chars) {
-            await handler.chars(html[0], prevTag, '');
+            await handler.chars(fullHtml[pos], prevTag, '');
           }
-          html = html.substring(1);
-          position++;
+          advance(1);
           prevTag = '';
           continue;
         }
-        const loc = getLineColumn(position);
-        // Include some context before the error position so the snippet contains
-        // the offending markup plus preceding characters (e.g. "invalid<tag").
+        const loc = getLineColumn(pos);
+        // Include some context before the error position so the snippet contains the offending markup plus preceding characters (e.g., “invalid<tag”)
         const CONTEXT_BEFORE = 50;
-        const startPos = Math.max(0, position - CONTEXT_BEFORE);
-        const snippet = this.html.slice(startPos, startPos + 200).replace(/\n/g, ' ');
+        const startPos = Math.max(0, pos - CONTEXT_BEFORE);
+        const snippet = fullHtml.slice(startPos, startPos + 200).replace(/\n/g, ' ');
         throw new Error(
-          `Parse error at line ${loc.line}, column ${loc.column}:\n${snippet}${this.html.length > startPos + 200 ? '…' : ''}`
+          `Parse error at line ${loc.line}, column ${loc.column}:\n${snippet}${fullHtml.length > startPos + 200 ? '…' : ''}`
         );
       }
-      position = this.html.length - html.length;
     }
 
     if (!handler.partialMarkup) {
@@ -5436,9 +5467,11 @@ class HTMLParser {
       if (start) {
         const match = {
           tagName: start[1],
-          attrs: []
+          attrs: [],
+          advance: 0
         };
-        input = input.slice(start[0].length);
+        let consumed = start[0].length;
+        input = input.slice(consumed);
         let end, attr;
 
         // Safety limit: max length of input to check for attributes
@@ -5488,7 +5521,9 @@ class HTMLParser {
                     } else {
                       attr[baseIndex + 3] = value; // Single-quoted value
                     }
-                    input = input.slice(fullAttr.length);
+                    const attrLen = fullAttr.length;
+                    input = input.slice(attrLen);
+                    consumed += attrLen;
                     match.attrs.push(attr);
                     continue;
                   }
@@ -5505,7 +5540,9 @@ class HTMLParser {
             break;
           }
 
-          input = input.slice(attr[0].length);
+          const attrLen = attr[0].length;
+          input = input.slice(attrLen);
+          consumed += attrLen;
           match.attrs.push(attr);
         }
 
@@ -5513,7 +5550,8 @@ class HTMLParser {
         end = input.match(startTagClose);
         if (end) {
           match.unarySlash = end[1];
-          match.rest = input.slice(end[0].length);
+          consumed += end[0].length;
+          match.advance = consumed;
           return match;
         }
       }
@@ -5523,7 +5561,7 @@ class HTMLParser {
       let pos;
       const needle = tagName.toLowerCase();
       for (pos = stack.length - 1; pos >= 0; pos--) {
-        const currentTag = stack[pos].tag.toLowerCase();
+        const currentTag = stack[pos].lowerTag;
         if (currentTag === needle) {
           return pos;
         }
@@ -5577,7 +5615,7 @@ class HTMLParser {
         }
         if (tagName === 'col' && findTag('colgroup') < 0) {
           lastTag = 'colgroup';
-          stack.push({ tag: lastTag, attrs: [] });
+          stack.push({ tag: lastTag, lowerTag: 'colgroup', attrs: [] });
           if (handler.start) {
             await handler.start(lastTag, [], false, '');
           }
@@ -5656,7 +5694,7 @@ class HTMLParser {
       });
 
       if (!unary) {
-        stack.push({ tag: tagName, attrs });
+        stack.push({ tag: tagName, lowerTag: tagName.toLowerCase(), attrs });
         lastTag = tagName;
         unarySlash = '';
       }
@@ -5670,7 +5708,7 @@ class HTMLParser {
       let pos;
       const needle = tagName.toLowerCase();
       for (pos = stack.length - 1; pos >= 0; pos--) {
-        if (stack[pos].tag.toLowerCase() === needle) {
+        if (stack[pos].lowerTag === needle) {
           break;
         }
       }
@@ -5722,21 +5760,40 @@ class HTMLParser {
 class Sorter {
   sort(tokens, fromIndex = 0) {
     for (let i = 0, len = this.keys.length; i < len; i++) {
-      const key = this.keys[i];
-      const token = key.slice(1);
+      const token = this.keys[i];
+
+      // Build position map for this token to avoid repeated `indexOf`
+      const positions = [];
+      for (let j = fromIndex; j < tokens.length; j++) {
+        if (tokens[j] === token) {
+          positions.push(j);
+        }
+      }
 
-      let index = tokens.indexOf(token, fromIndex);
+      if (positions.length > 0) {
+        // Build new array with tokens in sorted order instead of splicing
+        const result = [];
 
-      if (index !== -1) {
-        do {
-          if (index !== fromIndex) {
-            tokens.splice(index, 1);
-            tokens.splice(fromIndex, 0, token);
+        // Add all instances of the current token first
+        for (let j = 0; j < positions.length; j++) {
+          result.push(token);
+        }
+
+        // Add other tokens, skipping positions where current token was
+        const posSet = new Set(positions);
+        for (let j = fromIndex; j < tokens.length; j++) {
+          if (!posSet.has(j)) {
+            result.push(tokens[j]);
           }
-          fromIndex++;
-        } while ((index = tokens.indexOf(token, fromIndex)) !== -1);
+        }
 
-        return this[key].sort(tokens, fromIndex);
+        // Copy sorted portion back to tokens array
+        for (let j = 0; j < result.length; j++) {
+          tokens[fromIndex + j] = result[j];
+        }
+
+        const newFromIndex = fromIndex + positions.length;
+        return this.sorterMap.get(token).sort(tokens, newFromIndex);
       }
     }
     return tokens;
@@ -5744,48 +5801,84 @@ class Sorter {
 }
 
 class TokenChain {
+  constructor() {
+    // Use Map instead of object properties for better performance
+    this.map = new Map();
+  }
+
   add(tokens) {
     tokens.forEach((token) => {
-      const key = '$' + token;
-      if (!this[key]) {
-        this[key] = [];
-        this[key].processed = 0;
+      if (!this.map.has(token)) {
+        this.map.set(token, { arrays: [], processed: 0 });
       }
-      this[key].push(tokens);
+      this.map.get(token).arrays.push(tokens);
     });
   }
 
   createSorter() {
     const sorter = new Sorter();
+    sorter.sorterMap = new Map();
+
+    // Convert Map entries to array and sort
+    const entries = Array.from(this.map.entries()).sort((a, b) => {
+      const m = a[1].arrays.length;
+      const n = b[1].arrays.length;
+      // Sort by length descending (larger first)
+      const lengthDiff = n - m;
+      if (lengthDiff !== 0) return lengthDiff;
+      // If lengths equal, sort by key ascending
+      return a[0].localeCompare(b[0]);
+    });
 
-    sorter.keys = Object.keys(this).sort((j, k) => {
-      const m = this[j].length;
-      const n = this[k].length;
-      return m < n ? 1 : m > n ? -1 : j < k ? -1 : j > k ? 1 : 0;
-    }).filter((key) => {
-      if (this[key].processed < this[key].length) {
-        const token = key.slice(1);
+    sorter.keys = [];
+
+    entries.forEach(([token, data]) => {
+      if (data.processed < data.arrays.length) {
         const chain = new TokenChain();
 
-        this[key].forEach((tokens) => {
-          let index;
-          while ((index = tokens.indexOf(token)) !== -1) {
-            tokens.splice(index, 1);
+        data.arrays.forEach((tokens) => {
+          // Build new array without the current token instead of splicing
+          const filtered = [];
+          for (let i = 0; i < tokens.length; i++) {
+            if (tokens[i] !== token) {
+              filtered.push(tokens[i]);
+            }
           }
-          tokens.forEach((token) => {
-            this['$' + token].processed++;
+
+          // Mark remaining tokens as processed
+          filtered.forEach((t) => {
+            const tData = this.map.get(t);
+            if (tData) {
+              tData.processed++;
+            }
           });
-          chain.add(tokens.slice(0));
+
+          if (filtered.length > 0) {
+            chain.add(filtered);
+          }
         });
-        sorter[key] = chain.createSorter();
-        return true;
+
+        sorter.keys.push(token);
+        sorter.sorterMap.set(token, chain.createSorter());
       }
-      return false;
     });
+
     return sorter;
   }
 }
 
+async function replaceAsync(str, regex, asyncFn) {
+  const promises = [];
+
+  str.replace(regex, (match, ...args) => {
+    const promise = asyncFn(match, ...args);
+    promises.push(promise);
+  });
+
+  const data = await Promise.all(promises);
+  return str.replace(regex, () => data.shift());
+}
+
 /**
  * Preset configurations for HTML Minifier Next
  *
@@ -7436,7 +7529,9 @@ async function createSortFns(value, options, uidIgnore, uidAttr) {
           currentType === 'text/html') {
           await scan(text);
         }
-      }
+      },
+      // We never need `nextTag` information in this scan
+      wantsNextTag: false
     });
 
     await parser.parse();
@@ -7672,6 +7767,8 @@ async function minifyHTML(value, options, partialMarkup) {
     customAttrAssign: options.customAttrAssign,
     customAttrSurround: options.customAttrSurround,
     html5: options.html5,
+    // Compute `nextTag` only when whitespace collapse features require it
+    wantsNextTag: !!(options.collapseWhitespace || options.collapseInlineTagWhitespace || options.conservativeCollapse),
 
     start: async function (tag, attrs, unary, unarySlash, autoGenerated) {
       if (tag.toLowerCase() === 'svg') {

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

@@ -1 +1 @@
-{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"AAgvEO,8BAJI,MAAM,YACN,eAAe,GACb,OAAO,CAAC,MAAM,CAAC,CAQ3B;;;;;;;;;;;;UAvtES,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;;;;;;;;oBAMhH,OAAO;;;;;;;;gCAOP,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;;;;;;;YAMP,OAAO;;;;;;;;2BAMP,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;;;;;;;;;;gBAMN,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,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;;;iBASzG,OAAO,GAAG,MAAM,GAAG,OAAO,WAAW,EAAE,OAAO,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;WAS7F,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;;;;;;;;;oBAQzD,OAAO,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;;;;;;;;0BAQrC,OAAO;;;;;;;sBAOP,OAAO;;wBAnYkC,cAAc;0BAAd,cAAc;+BAAd,cAAc"}
+{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"AAovEO,8BAJI,MAAM,YACN,eAAe,GACb,OAAO,CAAC,MAAM,CAAC,CAQ3B;;;;;;;;;;;;UA3tES,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;;;;;;;;oBAMhH,OAAO;;;;;;;;gCAOP,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;;;;;;;YAMP,OAAO;;;;;;;;2BAMP,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;;;;;;;;;;gBAMN,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,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;;;iBASzG,OAAO,GAAG,MAAM,GAAG,OAAO,WAAW,EAAE,OAAO,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;WAS7F,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;;;;;;;;;oBAQzD,OAAO,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;;;;;;;;0BAQrC,OAAO;;;;;;;sBAOP,OAAO;;wBAnYkC,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":"AAgDA,4BAAoE;AAoEpE;IACE,qCAGC;IAFC,UAAgB;IAChB,aAAsB;IAGxB,uBA8bC;CACF"}
+{"version":3,"file":"htmlparser.d.ts","sourceRoot":"","sources":["../../src/htmlparser.js"],"names":[],"mappings":"AA8CA,4BAAoE;AAuEpE;IACE,qCAGC;IAFC,UAAgB;IAChB,aAAsB;IAGxB,uBAoeC;CACF"}

package/dist/types/tokenchain.d.ts

@@ -1,5 +1,6 @@
 export default TokenChain;
 declare class TokenChain {
+    map: Map<any, any>;
     add(tokens: any): void;
     createSorter(): Sorter;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"tokenchain.d.ts","sourceRoot":"","sources":["../../src/tokenchain.js"],"names":[],"mappings":";AAwBA;IACE,uBASC;IAED,uBA4BC;CACF;AAjED;IACE,2CAoBC;CACF"}
+{"version":3,"file":"tokenchain.d.ts","sourceRoot":"","sources":["../../src/tokenchain.js"],"names":[],"mappings":";AA2CA;IAGI,mBAAoB;IAGtB,uBAOC;IAED,uBAiDC;CACF;AA5GD;IACE,2CAuCC;CACF"}

package/package.json

@@ -15,17 +15,17 @@
   },
   "description": "Super-configurable, well-tested, JavaScript-based HTML minifier (enhanced successor of HTML Minifier)",
   "devDependencies": {
-    "@commitlint/cli": "^20.1.0",
+    "@commitlint/cli": "^20.2.0",
     "@eslint/js": "^9.39.1",
     "@rollup/plugin-commonjs": "^29.0.0",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-terser": "^0.4.4",
     "eslint": "^9.39.1",
-    "rollup": "^4.53.2",
+    "rollup": "^4.53.3",
     "rollup-plugin-polyfill-node": "^0.13.0",
     "typescript": "^5.9.3",
-    "vite": "^7.2.2"
+    "vite": "^7.2.7"
   },
   "exports": {
     ".": {
@@ -84,5 +84,5 @@
     "test:watch": "node --test --watch tests/*.spec.js"
   },
   "type": "module",
-  "version": "4.9.1"
+  "version": "4.10.0"
 }

package/src/htmlminifier.js

@@ -1588,7 +1588,9 @@ async function createSortFns(value, options, uidIgnore, uidAttr) {
           currentType === 'text/html') {
           await scan(text);
         }
-      }
+      },
+      // We never need `nextTag` information in this scan
+      wantsNextTag: false
     });
 
     await parser.parse();
@@ -1824,6 +1826,8 @@ async function minifyHTML(value, options, partialMarkup) {
     customAttrAssign: options.customAttrAssign,
     customAttrSurround: options.customAttrSurround,
     html5: options.html5,
+    // Compute `nextTag` only when whitespace collapse features require it
+    wantsNextTag: !!(options.collapseWhitespace || options.collapseInlineTagWhitespace || options.conservativeCollapse),
 
     start: async function (tag, attrs, unary, unarySlash, autoGenerated) {
       if (tag.toLowerCase() === 'svg') {