html-minifier-next 4.17.2 → 4.19.0

package/dist/htmlminifier.esm.bundle.js

@@ -2655,16 +2655,16 @@ const singleAttrValues = [
 // https://www.w3.org/TR/1999/REC-xml-names-19990114/#NT-QName
 const qnameCapture = (function () {
   // https://www.npmjs.com/package/ncname
-  const combiningChar = '\\u0300-\\u0345\\u0360\\u0361\\u0483-\\u0486\\u0591-\\u05A1\\u05A3-\\u05B9\\u05BB-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u064B-\\u0652\\u0670\\u06D6-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0901-\\u0903\\u093C\\u093E-\\u094D\\u0951-\\u0954\\u0962\\u0963\\u0981-\\u0983\\u09BC\\u09BE-\\u09C4\\u09C7\\u09C8\\u09CB-\\u09CD\\u09D7\\u09E2\\u09E3\\u0A02\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A70\\u0A71\\u0A81-\\u0A83\\u0ABC\\u0ABE-\\u0AC5\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD\\u0B01-\\u0B03\\u0B3C\\u0B3E-\\u0B43\\u0B47\\u0B48\\u0B4B-\\u0B4D\\u0B56\\u0B57\\u0B82\\u0B83\\u0BBE-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCD\\u0BD7\\u0C01-\\u0C03\\u0C3E-\\u0C44\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C82\\u0C83\\u0CBE-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6\\u0D02\\u0D03\\u0D3E-\\u0D43\\u0D46-\\u0D48\\u0D4A-\\u0D4D\\u0D57\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F3E\\u0F3F\\u0F71-\\u0F84\\u0F86-\\u0F8B\\u0F90-\\u0F95\\u0F97\\u0F99-\\u0FAD\\u0FB1-\\u0FB7\\u0FB9\\u20D0-\\u20DC\\u20E1\\u302A-\\u302F\\u3099\\u309A';
-  const digit = '0-9\\u0660-\\u0669\\u06F0-\\u06F9\\u0966-\\u096F\\u09E6-\\u09EF\\u0A66-\\u0A6F\\u0AE6-\\u0AEF\\u0B66-\\u0B6F\\u0BE7-\\u0BEF\\u0C66-\\u0C6F\\u0CE6-\\u0CEF\\u0D66-\\u0D6F\\u0E50-\\u0E59\\u0ED0-\\u0ED9\\u0F20-\\u0F29';
-  const extender = '\\xB7\\u02D0\\u02D1\\u0387\\u0640\\u0E46\\u0EC6\\u3005\\u3031-\\u3035\\u309D\\u309E\\u30FC-\\u30FE';
-  const letter = 'A-Za-z\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u0131\\u0134-\\u013E\\u0141-\\u0148\\u014A-\\u017E\\u0180-\\u01C3\\u01CD-\\u01F0\\u01F4\\u01F5\\u01FA-\\u0217\\u0250-\\u02A8\\u02BB-\\u02C1\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03CE\\u03D0-\\u03D6\\u03DA\\u03DC\\u03DE\\u03E0\\u03E2-\\u03F3\\u0401-\\u040C\\u040E-\\u044F\\u0451-\\u045C\\u045E-\\u0481\\u0490-\\u04C4\\u04C7\\u04C8\\u04CB\\u04CC\\u04D0-\\u04EB\\u04EE-\\u04F5\\u04F8\\u04F9\\u0531-\\u0556\\u0559\\u0561-\\u0586\\u05D0-\\u05EA\\u05F0-\\u05F2\\u0621-\\u063A\\u0641-\\u064A\\u0671-\\u06B7\\u06BA-\\u06BE\\u06C0-\\u06CE\\u06D0-\\u06D3\\u06D5\\u06E5\\u06E6\\u0905-\\u0939\\u093D\\u0958-\\u0961\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8B\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AE0\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B36-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB5\\u0BB7-\\u0BB9\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C33\\u0C35-\\u0C39\\u0C60\\u0C61\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CDE\\u0CE0\\u0CE1\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D28\\u0D2A-\\u0D39\\u0D60\\u0D61\\u0E01-\\u0E2E\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E45\\u0E81\\u0E82\\u0E84\\u0E87\\u0E88\\u0E8A\\u0E8D\\u0E94-\\u0E97\\u0E99-\\u0E9F\\u0EA1-\\u0EA3\\u0EA5\\u0EA7\\u0EAA\\u0EAB\\u0EAD\\u0EAE\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0F40-\\u0F47\\u0F49-\\u0F69\\u10A0-\\u10C5\\u10D0-\\u10F6\\u1100\\u1102\\u1103\\u1105-\\u1107\\u1109\\u110B\\u110C\\u110E-\\u1112\\u113C\\u113E\\u1140\\u114C\\u114E\\u1150\\u1154\\u1155\\u1159\\u115F-\\u1161\\u1163\\u1165\\u1167\\u1169\\u116D\\u116E\\u1172\\u1173\\u1175\\u119E\\u11A8\\u11AB\\u11AE\\u11AF\\u11B7\\u11B8\\u11BA\\u11BC-\\u11C2\\u11EB\\u11F0\\u11F9\\u1E00-\\u1E9B\\u1EA0-\\u1EF9\\u1F00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2126\\u212A\\u212B\\u212E\\u2180-\\u2182\\u3007\\u3021-\\u3029\\u3041-\\u3094\\u30A1-\\u30FA\\u3105-\\u312C\\u4E00-\\u9FA5\\uAC00-\\uD7A3';
+  const combiningChar = '\u0300-\u0345\u0360\u0361\u0483-\u0486\u0591-\u05A1\u05A3-\u05B9\u05BB-\u05BD\u05BF\u05C1\u05C2\u05C4\u064B-\u0652\u0670\u06D6-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0901-\u0903\u093C\u093E-\u094D\u0951-\u0954\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u0A02\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A70\u0A71\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0B01-\u0B03\u0B3C\u0B3E-\u0B43\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B82\u0B83\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C01-\u0C03\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C82\u0C83\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0D02\u0D03\u0D3E-\u0D43\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86-\u0F8B\u0F90-\u0F95\u0F97\u0F99-\u0FAD\u0FB1-\u0FB7\u0FB9\u20D0-\u20DC\u20E1\u302A-\u302F\u3099\u309A';
+  const digit = '0-9\u0660-\u0669\u06F0-\u06F9\u0966-\u096F\u09E6-\u09EF\u0A66-\u0A6F\u0AE6-\u0AEF\u0B66-\u0B6F\u0BE7-\u0BEF\u0C66-\u0C6F\u0CE6-\u0CEF\u0D66-\u0D6F\u0E50-\u0E59\u0ED0-\u0ED9\u0F20-\u0F29';
+  const extender = '\xB7\u02D0\u02D1\u0387\u0640\u0E46\u0EC6\u3005\u3031-\u3035\u309D\u309E\u30FC-\u30FE';
+  const letter = 'A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\u0131\u0134-\u013E\u0141-\u0148\u014A-\u017E\u0180-\u01C3\u01CD-\u01F0\u01F4\u01F5\u01FA-\u0217\u0250-\u02A8\u02BB-\u02C1\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03CE\u03D0-\u03D6\u03DA\u03DC\u03DE\u03E0\u03E2-\u03F3\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E-\u0481\u0490-\u04C4\u04C7\u04C8\u04CB\u04CC\u04D0-\u04EB\u04EE-\u04F5\u04F8\u04F9\u0531-\u0556\u0559\u0561-\u0586\u05D0-\u05EA\u05F0-\u05F2\u0621-\u063A\u0641-\u064A\u0671-\u06B7\u06BA-\u06BE\u06C0-\u06CE\u06D0-\u06D3\u06D5\u06E5\u06E6\u0905-\u0939\u093D\u0958-\u0961\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8B\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AE0\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B36-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB5\u0BB7-\u0BB9\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CDE\u0CE0\u0CE1\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D28\u0D2A-\u0D39\u0D60\u0D61\u0E01-\u0E2E\u0E30\u0E32\u0E33\u0E40-\u0E45\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD\u0EAE\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0F40-\u0F47\u0F49-\u0F69\u10A0-\u10C5\u10D0-\u10F6\u1100\u1102\u1103\u1105-\u1107\u1109\u110B\u110C\u110E-\u1112\u113C\u113E\u1140\u114C\u114E\u1150\u1154\u1155\u1159\u115F-\u1161\u1163\u1165\u1167\u1169\u116D\u116E\u1172\u1173\u1175\u119E\u11A8\u11AB\u11AE\u11AF\u11B7\u11B8\u11BA\u11BC-\u11C2\u11EB\u11F0\u11F9\u1E00-\u1E9B\u1EA0-\u1EF9\u1F00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2126\u212A\u212B\u212E\u2180-\u2182\u3007\u3021-\u3029\u3041-\u3094\u30A1-\u30FA\u3105-\u312C\u4E00-\u9FA5\uAC00-\uD7A3';
   const ncname = '[' + letter + '_][' + letter + digit + '\\.\\-_' + combiningChar + extender + ']*';
   return '((?:' + ncname + '\\:)?' + ncname + ')';
 })();
 const startTagOpen = new RegExp('^<' + qnameCapture);
 const startTagClose = /^\s*(\/?)>/;
-const endTag = new RegExp('^<\\/' + qnameCapture + '[^>]*>');
+const endTag = new RegExp('^</' + qnameCapture + '[^>]*>');
 const doctype = /^<!DOCTYPE\s?[^>]+>/i;
 
 let IS_REGEX_CAPTURING_BROKEN = false;
@@ -2763,9 +2763,6 @@ class HTMLParser {
     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; };
 
@@ -2784,22 +2781,32 @@ class HTMLParser {
       return { line, column };
     };
 
+    // Helper to safely extract substring when needed for regex operations
+    const sliceFromPos = (startPos, len) => {
+      const endPos = fullLength;
+      return fullHtml.slice(startPos, endPos);
+    };
+
     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('<');
-        if (textEnd === 0) {
+        const textEnd = fullHtml.indexOf('<', pos);
+
+        if (textEnd === pos) {
+          // We found a tag at current position
+          const remaining = sliceFromPos(pos);
+
           // Comment
-          if (/^<!--/.test(html)) {
-            const commentEnd = html.indexOf('-->');
+          if (/^<!--/.test(remaining)) {
+            const commentEnd = fullHtml.indexOf('-->', pos + 4);
 
             if (commentEnd >= 0) {
               if (handler.comment) {
-                await handler.comment(html.substring(4, commentEnd));
+                await handler.comment(fullHtml.substring(pos + 4, commentEnd));
               }
-              advance(commentEnd + 3);
+              advance(commentEnd + 3 - pos);
               prevTag = '';
               prevAttrs = [];
               continue;
@@ -2807,14 +2814,14 @@ class HTMLParser {
           }
 
           // https://web.archive.org/web/20241201212701/https://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-          if (/^<!\[/.test(html)) {
-            const conditionalEnd = html.indexOf(']>');
+          if (/^<!\[/.test(remaining)) {
+            const conditionalEnd = fullHtml.indexOf(']>', pos + 3);
 
             if (conditionalEnd >= 0) {
               if (handler.comment) {
-                await handler.comment(html.substring(2, conditionalEnd + 1), true /* Non-standard */);
+                await handler.comment(fullHtml.substring(pos + 2, conditionalEnd + 1), true /* Non-standard */);
               }
-              advance(conditionalEnd + 2);
+              advance(conditionalEnd + 2 - pos);
               prevTag = '';
               prevAttrs = [];
               continue;
@@ -2822,8 +2829,8 @@ class HTMLParser {
           }
 
           // Doctype
-          const doctypeMatch = html.match(doctype);
-          if (doctypeMatch) {
+          if (doctype.test(remaining)) {
+            const doctypeMatch = remaining.match(doctype);
             if (handler.doctype) {
               handler.doctype(doctypeMatch[0]);
             }
@@ -2834,8 +2841,8 @@ class HTMLParser {
           }
 
           // End tag
-          const endTagMatch = html.match(endTag);
-          if (endTagMatch) {
+          if (endTag.test(remaining)) {
+            const endTagMatch = remaining.match(endTag);
             advance(endTagMatch[0].length);
             await parseEndTag(endTagMatch[0], endTagMatch[1]);
             prevTag = '/' + endTagMatch[1].toLowerCase();
@@ -2844,7 +2851,7 @@ class HTMLParser {
           }
 
           // Start tag
-          const startTagMatch = parseStartTag(html);
+          const startTagMatch = parseStartTag(remaining, pos);
           if (startTagMatch) {
             advance(startTagMatch.advance);
             await handleStartTag(startTagMatch);
@@ -2853,31 +2860,29 @@ class HTMLParser {
           }
 
           // Treat `<` as text
-          if (handler.continueOnParseError) {
-            textEnd = html.indexOf('<', 1);
-          }
+          if (handler.continueOnParseError) ;
         }
 
         let text;
         if (textEnd >= 0) {
-          text = html.substring(0, textEnd);
-          advance(textEnd);
+          text = fullHtml.substring(pos, textEnd);
+          advance(textEnd - pos);
         } else {
-          text = html;
-          advance(html.length);
+          text = fullHtml.substring(pos);
+          advance(fullLength - pos);
         }
 
-        // Next tag
-        const nextHtml = remaining();
-        let nextTagMatch = parseStartTag(nextHtml);
+        // Next tag for whitespace processing context
+        const remainingAfterText = sliceFromPos(pos);
+        let nextTagMatch = parseStartTag(remainingAfterText, pos);
         if (nextTagMatch) {
           nextTag = nextTagMatch.tagName;
           // Extract minimal attribute info for whitespace logic (just name/value pairs)
           nextAttrs = extractAttrInfo(nextTagMatch.attrs);
         } else {
-          nextTagMatch = nextHtml.match(endTag);
-          if (nextTagMatch) {
-            nextTag = '/' + nextTagMatch[1];
+          const endTagMatch = remainingAfterText.match(endTag);
+          if (endTagMatch) {
+            nextTag = '/' + endTagMatch[1];
             nextAttrs = [];
           } else {
             nextTag = '';
@@ -2893,10 +2898,11 @@ class HTMLParser {
       } else {
         const stackedTag = lastTag.toLowerCase();
         // 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'));
+        const reStackedTag = preCompiledStackedTags[stackedTag] || reCache[stackedTag] || (reCache[stackedTag] = new RegExp('([\\s\\S]*?)\\x3c/' + stackedTag + '[^>]*>', 'i'));
 
-        const m = reStackedTag.exec(html);
-        if (m) {
+        const remaining = sliceFromPos(pos);
+        const m = reStackedTag.exec(remaining);
+        if (m && m.index === 0) {
           let text = m[1];
           if (stackedTag !== 'script' && stackedTag !== 'style' && stackedTag !== 'noscript') {
             text = text
@@ -2907,12 +2913,12 @@ class HTMLParser {
             await handler.chars(text);
           }
           // Advance HTML past the matched special tag content and its closing tag
-          advance(m.index + m[0].length);
+          advance(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, '', prevAttrs, []);
+          if (handler.continueOnParseError && handler.chars && pos < fullLength) {
+            await handler.chars(fullHtml[pos], prevTag, '', prevAttrs, []);
             advance(1);
           } else {
             break;
@@ -2932,7 +2938,7 @@ class HTMLParser {
           continue;
         }
         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”)
+        // 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, pos - CONTEXT_BEFORE);
         const snippet = fullHtml.slice(startPos, startPos + 200).replace(/\n/g, ' ');
@@ -2964,8 +2970,8 @@ class HTMLParser {
       }).filter(attr => attr.name); // Filter out invalid entries
     }
 
-    function parseStartTag(input) {
-      const start = input.match(startTagOpen);
+    function parseStartTag(remaining, startPos) {
+      const start = remaining.match(startTagOpen);
       if (start) {
         const match = {
           tagName: start[1],
@@ -2973,7 +2979,7 @@ class HTMLParser {
           advance: 0
         };
         let consumed = start[0].length;
-        input = input.slice(consumed);
+        let currentPos = startPos + consumed;
         let end, attr;
 
         // Safety limit: Max length of input to check for attributes
@@ -2982,16 +2988,20 @@ class HTMLParser {
 
         while (true) {
           // Check for closing tag first
-          end = input.match(startTagClose);
+          const remainingForEnd = sliceFromPos(currentPos);
+          end = remainingForEnd.match(startTagClose);
           if (end) {
             break;
           }
 
           // Limit the input length we pass to the regex to prevent catastrophic backtracking
-          const isLimited = input.length > MAX_ATTR_PARSE_LENGTH;
-          const searchInput = isLimited ? input.slice(0, MAX_ATTR_PARSE_LENGTH) : input;
+          const remainingLen = fullLength - currentPos;
+          const isLimited = remainingLen > MAX_ATTR_PARSE_LENGTH;
+          const extractEndPos = isLimited ? currentPos + MAX_ATTR_PARSE_LENGTH : fullLength;
 
-          attr = searchInput.match(attribute);
+          // Create a temporary substring only for attribute parsing (this is limited and necessary for regex)
+          const searchStr = fullHtml.substring(currentPos, extractEndPos);
+          attr = searchStr.match(attribute);
 
           // If we limited the input and got a match, check if the value might be truncated
           if (attr && isLimited) {
@@ -3000,32 +3010,31 @@ class HTMLParser {
             // If the match ends near the limit, the value might be truncated
             if (attrEnd > MAX_ATTR_PARSE_LENGTH - 100) {
               // Manually extract this attribute to handle potentially huge value
-              const manualMatch = input.match(/^\s*([^\s"'<>/=]+)\s*=\s*/);
+              const manualMatch = searchStr.match(/^\s*([^\s"'<>/=]+)\s*=\s*/);
               if (manualMatch) {
-                const quoteChar = input[manualMatch[0].length];
+                const quoteChar = searchStr[manualMatch[0].length];
                 if (quoteChar === '"' || quoteChar === "'") {
-                  const closeQuote = input.indexOf(quoteChar, manualMatch[0].length + 1);
+                  const closeQuote = searchStr.indexOf(quoteChar, manualMatch[0].length + 1);
                   if (closeQuote !== -1) {
-                    const fullAttr = input.slice(0, closeQuote + 1);
+                    const fullAttrLen = closeQuote + 1;
                     const numCustomParts = handler.customAttrSurround
                       ? handler.customAttrSurround.length * NCP
                       : 0;
                     const baseIndex = 1 + numCustomParts;
 
                     attr = [];
-                    attr[0] = fullAttr;
+                    attr[0] = searchStr.substring(0, fullAttrLen);
                     attr[baseIndex] = manualMatch[1]; // Attribute name
-                    attr[baseIndex + 1] = '='; // `customAssign` (falls back to “=” for huge attributes)
-                    const value = input.slice(manualMatch[0].length + 1, closeQuote);
+                    attr[baseIndex + 1] = '='; // `customAssign` (falls back to "=" for huge attributes)
+                    const value = searchStr.substring(manualMatch[0].length + 1, closeQuote);
                     // Place value at correct index based on quote type
                     if (quoteChar === '"') {
                       attr[baseIndex + 2] = value; // Double-quoted value
                     } else {
                       attr[baseIndex + 3] = value; // Single-quoted value
                     }
-                    const attrLen = fullAttr.length;
-                    input = input.slice(attrLen);
-                    consumed += attrLen;
+                    currentPos += fullAttrLen;
+                    consumed += fullAttrLen;
                     match.attrs.push(attr);
                     continue;
                   }
@@ -3038,18 +3047,55 @@ class HTMLParser {
             }
           }
 
+          if (!attr && isLimited) {
+            // If we limited the input and got no match, try manual extraction
+            // This handles cases where quoted attributes exceed `MAX_ATTR_PARSE_LENGTH`
+            const manualMatch = searchStr.match(/^\s*([^\s"'<>/=]+)\s*=\s*/);
+            if (manualMatch) {
+              const quoteChar = searchStr[manualMatch[0].length];
+              if (quoteChar === '"' || quoteChar === "'") {
+                // Search in the full HTML (not limited substring) for closing quote
+                const closeQuote = fullHtml.indexOf(quoteChar, currentPos + manualMatch[0].length + 1);
+                if (closeQuote !== -1) {
+                  const fullAttrLen = closeQuote - currentPos + 1;
+                  const numCustomParts = handler.customAttrSurround
+                    ? handler.customAttrSurround.length * NCP
+                    : 0;
+                  const baseIndex = 1 + numCustomParts;
+
+                  attr = [];
+                  attr[0] = fullHtml.substring(currentPos, closeQuote + 1);
+                  attr[baseIndex] = manualMatch[1]; // Attribute name
+                  attr[baseIndex + 1] = '='; // customAssign
+                  const value = fullHtml.substring(currentPos + manualMatch[0].length + 1, closeQuote);
+                  // Place value at correct index based on quote type
+                  if (quoteChar === '"') {
+                    attr[baseIndex + 2] = value; // Double-quoted value
+                  } else {
+                    attr[baseIndex + 3] = value; // Single-quoted value
+                  }
+                  currentPos += fullAttrLen;
+                  consumed += fullAttrLen;
+                  match.attrs.push(attr);
+                  continue;
+                }
+              }
+            }
+          }
+
           if (!attr) {
             break;
           }
 
           const attrLen = attr[0].length;
-          input = input.slice(attrLen);
+          currentPos += attrLen;
           consumed += attrLen;
           match.attrs.push(attr);
         }
 
         // Check for closing tag
-        end = input.match(startTagClose);
+        const remainingForClose = sliceFromPos(currentPos);
+        end = remainingForClose.match(startTagClose);
         if (end) {
           match.unarySlash = end[1];
           consumed += end[0].length;
@@ -3246,11 +3292,11 @@ class HTMLParser {
         if (handler.end) {
           handler.end(tagName, [], false);
         }
-      } else if (tagName.toLowerCase() === 'br') {
+      } else if (tagName && tagName.toLowerCase() === 'br') {
         if (handler.start) {
           await handler.start(tagName, [], true, '');
         }
-      } else if (tagName.toLowerCase() === 'p') {
+      } else if (tagName && tagName.toLowerCase() === 'p') {
         if (handler.start) {
           await handler.start(tagName, [], false, '', true);
         }
@@ -3393,6 +3439,7 @@ const presets = {
     collapseWhitespace: true,
     continueOnParseError: true,
     decodeEntities: true,
+    mergeScripts: true,
     minifyCSS: true,
     minifyJS: true,
     minifySVG: true,
@@ -3611,6 +3658,11 @@ const isSimpleBoolean = new Set(['allowfullscreen', 'async', 'autofocus', 'autop
 
 const isBooleanValue = new Set(['true', 'false']);
 
+// Attributes where empty value can be collapsed to just the attribute name
+// `crossorigin=""` → `crossorigin` (empty string equals anonymous mode)
+// `contenteditable=""` → `contenteditable` (empty string equals `true`)
+const emptyCollapsible = new Set(['crossorigin', 'contenteditable']);
+
 // `srcset` elements
 
 const srcsetElements = new Set(['img', 'source']);
@@ -6590,7 +6642,8 @@ function minifyNumber(num, precision = 3) {
   const fixed = parsed.toFixed(precision);
   const trimmed = fixed.replace(/\.?0+$/, '');
 
-  const result = trimmed || '0';
+  // Remove leading zero before decimal point (e.g., `0.5` → `.5`, `-0.3` → `-.3`)
+  const result = (trimmed || '0').replace(/^(-?)0\./, '$1.');
   numberCache.set(cacheKey, result);
   return result;
 }
@@ -6610,17 +6663,23 @@ function minifyPathData(pathData, precision = 3) {
   });
 
   // Remove unnecessary spaces around path commands
-  // Safe to remove space after a command letter when it’s followed by a number (which may be negative)
-  // `M 10 20` → `M10 20`, `L -5 -3` → `L-5-3`
-  result = result.replace(/([MLHVCSQTAZmlhvcsqtaz])\s+(?=-?\d)/g, '$1');
+  // Safe to remove space after a command letter when it’s followed by a number
+  // (which may be negative or start with a decimal point)
+  // `M 10 20` → `M10 20`, `L -5 -3` → `L-5-3`, `M .5 .3` → `M.5.3`
+  result = result.replace(/([MLHVCSQTAZmlhvcsqtaz])\s+(?=-?\.?\d)/g, '$1');
 
   // Safe to remove space before command letter when preceded by a number
-  // `0 L` → `0L`, `20 M` → `20M`
-  result = result.replace(/(\d)\s+([MLHVCSQTAZmlhvcsqtaz])/g, '$1$2');
+  // `0 L` → `0L`, `20 M` → `20M`, `.5 L` → `.5L`
+  result = result.replace(/([\d.])\s+([MLHVCSQTAZmlhvcsqtaz])/g, '$1$2');
 
   // Safe to remove space before negative number when preceded by a number
-  // `10 -20` → `10-20` (numbers are separated by the minus sign)
-  result = result.replace(/(\d)\s+(-\d)/g, '$1$2');
+  // `10 -20` → `10-20`, `.5 -.3` → `.5-.3` (minus sign is always a separator)
+  result = result.replace(/([\d.])\s+(-)/g, '$1$2');
+
+  // Safe to remove space between two decimal numbers (decimal point acts as separator)
+  // `.5 .3` → `.5.3` (only when previous char is `.`, indicating a complete decimal)
+  // Note: `0 .3` must not become `0.3` (that would change two numbers into one)
+  result = result.replace(/(\.\d*)\s+(\.)/g, '$1$2');
 
   return result;
 }
@@ -6918,10 +6977,9 @@ function shouldMinifyInnerHTML(options) {
  * @param {Function} deps.getSwc - Function to lazily load @swc/core
  * @param {LRU} deps.cssMinifyCache - CSS minification cache
  * @param {LRU} deps.jsMinifyCache - JS minification cache
- * @param {LRU} deps.urlMinifyCache - URL minification cache
  * @returns {MinifierOptions} Normalized options with defaults applied
  */
-const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, cssMinifyCache, jsMinifyCache, urlMinifyCache } = {}) => {
+const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, cssMinifyCache, jsMinifyCache } = {}) => {
   const options = {
     name: function (name) {
       return name.toLowerCase();
@@ -7215,7 +7273,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, cssM
       const relateUrlInstance = new RelateURL(relateUrlOptions.site || '', relateUrlOptions);
 
       // Create instance-specific cache (results depend on site configuration)
-      const instanceCache = urlMinifyCache ? new (urlMinifyCache.constructor)(500) : null;
+      const instanceCache = new LRU(500);
 
       options.minifyURLs = function (text) {
         // Fast-path: Skip if text doesn’t look like a URL that needs processing
@@ -7224,20 +7282,15 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, cssM
           return text;
         }
 
-        // Check instance-specific cache
-        if (instanceCache) {
-          const cached = instanceCache.get(text);
-          if (cached !== undefined) {
-            return cached;
-          }
+        // Check cache
+        const cached = instanceCache.get(text);
+        if (cached !== undefined) {
+          return cached;
         }
 
         try {
           const result = relateUrlInstance.relate(text);
-          // Cache successful results
-          if (instanceCache) {
-            instanceCache.set(text, result);
-          }
+          instanceCache.set(text, result);
           return result;
         } catch (err) {
           // Don’t cache errors
@@ -7397,7 +7450,9 @@ function isStyleElement(tag, attrs) {
 }
 
 function isBooleanAttribute(attrName, attrValue) {
-  return isSimpleBoolean.has(attrName) || (attrName === 'draggable' && !isBooleanValue.has(attrValue));
+  return isSimpleBoolean.has(attrName) ||
+    (attrName === 'draggable' && !isBooleanValue.has(attrValue)) ||
+    (attrValue === '' && emptyCollapsible.has(attrName));
 }
 
 function isUriTypeAttribute(attrName, tag) {
@@ -8074,11 +8129,125 @@ async function getSwc() {
   return swcPromise;
 }
 
-// Minification caches
+// Minification caches (initialized on first use with configurable sizes)
+let cssMinifyCache = null;
+let jsMinifyCache = null;
+
+// Pre-compiled patterns for script merging (avoid repeated allocation in hot path)
+const RE_SCRIPT_ATTRS = /([^\s=]+)(?:=(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
+const SCRIPT_BOOL_ATTRS = new Set(['async', 'defer', 'nomodule']);
+const DEFAULT_JS_TYPES = new Set(['', 'text/javascript', 'application/javascript']);
+
+// Pre-compiled patterns for buffer scanning
+const RE_START_TAG = /^<[^/!]/;
+const RE_END_TAG = /^<\//;
+
+// Script merging
 
-const cssMinifyCache = new LRU(500);
-const jsMinifyCache = new LRU(500);
-const urlMinifyCache = new LRU(500);
+/**
+ * Merge consecutive inline script tags into one (`mergeConsecutiveScripts`).
+ * Only merges scripts that are compatible:
+ * - Both inline (no `src` attribute)
+ * - Same `type` (or both default JavaScript)
+ * - No conflicting attributes (`async`, `defer`, `nomodule`, different `nonce`)
+ *
+ * Limitation: This function uses regex-based matching (`pattern` variable below),
+ * which can produce incorrect results if a script’s content contains a literal
+ * `</script>` string (e.g., `document.write('<script>…</script>')`). In valid
+ * HTML, such strings should be escaped as `<\/script>` or split like
+ * `'</scr' + 'ipt>'`, so this limitation rarely affects real-world code. The
+ * earlier `minifyJS` step (if enabled) typically handles this escaping already.
+ *
+ * @param {string} html - The HTML string to process
+ * @returns {string} HTML with consecutive scripts merged
+ */
+function mergeConsecutiveScripts(html) {
+  // `pattern`: Regex to match consecutive `</script>` followed by `<script…>`.
+  // See function JSDoc above for known limitations with literal `</script>` in content.
+  // Captures:
+  // 1. first script attrs
+  // 2. first script content
+  // 3. whitespace between
+  // 4. second script attrs
+  // 5. second script content
+  const pattern = /<script([^>]*)>([\s\S]*?)<\/script>([\s]*)<script([^>]*)>([\s\S]*?)<\/script>/gi;
+
+  let result = html;
+  let changed = true;
+
+  // Keep merging until no more changes (handles chains of 3+ scripts)
+  while (changed) {
+    changed = false;
+    result = result.replace(pattern, (match, attrs1, content1, whitespace, attrs2, content2) => {
+      // Parse attributes from both script tags (uses pre-compiled RE_SCRIPT_ATTRS)
+      const parseAttrs = (attrStr) => {
+        const attrs = {};
+        RE_SCRIPT_ATTRS.lastIndex = 0; // Reset for reuse
+        let m;
+        while ((m = RE_SCRIPT_ATTRS.exec(attrStr)) !== null) {
+          const name = m[1].toLowerCase();
+          const value = m[2] ?? m[3] ?? m[4] ?? '';
+          attrs[name] = value;
+        }
+        return attrs;
+      };
+
+      const a1 = parseAttrs(attrs1);
+      const a2 = parseAttrs(attrs2);
+
+      // Check for `src`—cannot merge external scripts
+      if ('src' in a1 || 'src' in a2) {
+        return match;
+      }
+
+      // Check `type` compatibility (both must be same, or both default JS)
+      const type1 = a1.type || '';
+      const type2 = a2.type || '';
+
+      if (DEFAULT_JS_TYPES.has(type1) && DEFAULT_JS_TYPES.has(type2)) ; else if (type1 === type2) ; else {
+        // Incompatible types
+        return match;
+      }
+
+      // Check for conflicting boolean attributes (uses pre-compiled SCRIPT_BOOL_ATTRS)
+      for (const attr of SCRIPT_BOOL_ATTRS) {
+        const has1 = attr in a1;
+        const has2 = attr in a2;
+        if (has1 !== has2) {
+          // One has it, one doesn't - incompatible
+          return match;
+        }
+      }
+
+      // Check `nonce`—must be same or both absent
+      if (a1.nonce !== a2.nonce) {
+        return match;
+      }
+
+      // Scripts are compatible—merge them
+      changed = true;
+
+      // Combine content—use semicolon normally, newline only for trailing `//` comments
+      const c1 = content1.trim();
+      const c2 = content2.trim();
+      let mergedContent;
+      if (c1 && c2) {
+        // Check if last line of c1 contains `//` (single-line comment)
+        // If so, use newline to terminate it; otherwise use semicolon (if not already present)
+        const lastLine = c1.slice(c1.lastIndexOf('\n') + 1);
+        const separator = lastLine.includes('//') ? '\n' : (c1.endsWith(';') ? '' : ';');
+        mergedContent = c1 + separator + c2;
+      } else {
+        mergedContent = c1 || c2;
+      }
+
+      // Use first script’s attributes (they should be compatible)
+      return `<script${attrs1}>${mergedContent}</script>`;
+    });
+  }
+
+  return result;
+}
 
 // Type definitions
 
@@ -8111,6 +8280,24 @@ const urlMinifyCache = new LRU(500);
  *
  *  Default: Built-in `canTrimWhitespace` function
  *
+ * @prop {number} [cacheCSS]
+ *  The maximum number of entries for the CSS minification cache. Higher values
+ *  improve performance for inputs with repeated CSS (e.g., batch processing).
+ *  - Cache is created on first `minify()` call and persists for the process lifetime
+ *  - Cache size is locked after first call—subsequent calls reuse the same cache
+ *  - Explicit `0` values are coerced to `1` (minimum functional cache size)
+ *
+ *  Default: `500` (or `1000` when `CI=true` environment variable is set)
+ *
+ * @prop {number} [cacheJS]
+ *  The maximum number of entries for the JavaScript minification cache. Higher
+ *  values improve performance for inputs with repeated JavaScript.
+ *  - Cache is created on first `minify()` call and persists for the process lifetime
+ *  - Cache size is locked after first call—subsequent calls reuse the same cache
+ *  - Explicit `0` values are coerced to `1` (minimum functional cache size)
+ *
+ *  Default: `500` (or `1000` when `CI=true` environment variable is set)
+ *
  * @prop {boolean} [caseSensitive]
  *  When true, tag and attribute names are treated as case-sensitive.
  *  Useful for custom HTML tags.
@@ -8260,6 +8447,13 @@ const urlMinifyCache = new LRU(500);
  *
  *  Default: No limit
  *
+ * @prop {boolean} [mergeScripts]
+ *  When true, consecutive inline `<script>` elements are merged into one.
+ *  Only merges compatible scripts (same `type`, matching `async`/`defer`/
+ *  `nomodule`/`nonce` attributes). Does not merge external scripts (with `src`).
+ *
+ *  Default: `false`
+ *
  * @prop {boolean | Partial<import("lightningcss").TransformOptions<import("lightningcss").CustomAtRules>> | ((text: string, type?: string) => Promise<string> | string)} [minifyCSS]
  *  When true, enables CSS minification for inline `<style>` tags or
  *  `style` attributes. If an object is provided, it is passed to
@@ -8838,7 +9032,7 @@ async function minifyHTML(value, options, partialMarkup) {
 
   function removeStartTag() {
     let index = buffer.length - 1;
-    while (index > 0 && !/^<[^/!]/.test(buffer[index])) {
+    while (index > 0 && !RE_START_TAG.test(buffer[index])) {
       index--;
     }
     buffer.length = Math.max(0, index);
@@ -8846,7 +9040,7 @@ async function minifyHTML(value, options, partialMarkup) {
 
   function removeEndTag() {
     let index = buffer.length - 1;
-    while (index > 0 && !/^<\//.test(buffer[index])) {
+    while (index > 0 && !RE_END_TAG.test(buffer[index])) {
       index--;
     }
     buffer.length = Math.max(0, index);
@@ -9157,8 +9351,8 @@ async function minifyHTML(value, options, partialMarkup) {
       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 `;`)
+        // 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) {
@@ -9362,6 +9556,49 @@ function joinResultSegments(results, options, restoreCustom, restoreIgnore) {
   return options.collapseWhitespace ? collapseWhitespace(str, options, true, true) : str;
 }
 
+/**
+ * Initialize minification caches with configurable sizes.
+ *
+ * Important behavior notes:
+ * - Caches are created on the first `minify()` call and persist for the lifetime of the process
+ * - Cache sizes are locked after first initialization—subsequent calls use the same caches
+ *   even if different `cacheCSS`/`cacheJS` options are provided
+ * - The first call’s options determine the cache sizes for subsequent calls
+ * - Explicit `0` values are coerced to `1` (minimum functional cache size)
+ */
+function initCaches(options) {
+  // Only create caches once (on first call)—sizes are locked after this
+  if (!cssMinifyCache) {
+    // Determine default size based on environment
+    const defaultSize = process.env.CI === 'true' ? 1000 : 500;
+
+    // Helper to parse env var—returns parsed number (including 0) or undefined if absent, invalid, or negative
+    const parseEnvCacheSize = (envVar) => {
+      if (envVar === undefined) return undefined;
+      const parsed = Number(envVar);
+      if (Number.isNaN(parsed) || !Number.isFinite(parsed) || parsed < 0) {
+        return undefined;
+      }
+      return parsed;
+    };
+
+    // Get cache sizes with precedence: Options > env > default
+    const cssSize = options.cacheCSS !== undefined ? options.cacheCSS
+                 : (parseEnvCacheSize(process.env.HMN_CACHE_CSS) ?? defaultSize);
+    const jsSize = options.cacheJS !== undefined ? options.cacheJS
+                 : (parseEnvCacheSize(process.env.HMN_CACHE_JS) ?? defaultSize);
+
+    // Coerce `0` to `1` (minimum functional cache size) to avoid immediate eviction
+    const cssFinalSize = cssSize === 0 ? 1 : cssSize;
+    const jsFinalSize = jsSize === 0 ? 1 : jsSize;
+
+    cssMinifyCache = new LRU(cssFinalSize);
+    jsMinifyCache = new LRU(jsFinalSize);
+  }
+
+  return { cssMinifyCache, jsMinifyCache };
+}
+
 /**
  * @param {string} value
  * @param {MinifierOptions} [options]
@@ -9369,15 +9606,23 @@ function joinResultSegments(results, options, restoreCustom, restoreIgnore) {
  */
 const minify$1 = async function (value, options) {
   const start = Date.now();
+
+  // Initialize caches on first use with configurable sizes
+  const caches = initCaches(options || {});
+
   options = processOptions(options || {}, {
     getLightningCSS,
     getTerser,
     getSwc,
-    cssMinifyCache,
-    jsMinifyCache,
-    urlMinifyCache
+    ...caches
   });
-  const result = await minifyHTML(value, options);
+  let result = await minifyHTML(value, options);
+
+  // Post-processing: Merge consecutive inline scripts if enabled
+  if (options.mergeScripts) {
+    result = mergeConsecutiveScripts(result);
+  }
+
   options.log('minified in: ' + (Date.now() - start) + 'ms');
   return result;
 };