html-minifier 5.0.2 → 5.0.4

package/src/htmlminifier.js

@@ -2,7 +2,7 @@ import { HTMLParser } from './htmlparser.js';
 import TokenChain from './tokenchain.js';
 import { presets, getPreset, getPresetNames } from './presets.js';
 
-import { LRU, decodeForeignText, describeDependencyFailure, escapeXML, findTagEnd, identity, isThenable, lowercase, uniqueId } from './lib/utils.js';
+import { LRU, decodeForeignText, describeDependencyFailure, escapeXML, findTagEnd, identity, isThenable, lowercase, replaceNUL, uniqueId } from './lib/utils.js';
 import { collectUsage } from './lib/unused-css.js';
 
 import {
@@ -17,7 +17,10 @@ import {
   RE_WS_ONLY,
   RE_WS_NBSP_END,
   RE_STYLE_ELEMENT,
+  RE_ENDS_COLLAPSIBLE,
+  RE_DOCTYPE_SEGMENT,
   formattingElements,
+  inlineElementsToKeepWhitespace,
   inlineElementsToKeepWhitespaceAround,
   inlineElementsToKeepWhitespaceWithin,
   inlineElementsTransparent,
@@ -31,6 +34,7 @@ import {
   compactElements,
   looseElements,
   trailingElements,
+  specialOptionalEndTags,
   pClosingParents,
   namesForeignMixedCase,
   integrationPointsForeign,
@@ -665,6 +669,7 @@ const cacheStatsOrEmpty = (cache) => cache ? cache.stats() : { gets: 0, hits: 0,
 const RE_SCRIPT_ATTRS = /([^\s=]+)(?:=(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
 const RE_SCRIPT_OPEN = /<script(?=[\s>])/gi; // Finds tag start; use `findTagEnd()` for the actual closing `>`
 const RE_SCRIPT_CLOSE = /<\/script\s*>/gi;
+const RE_SCRIPT_START_TEXT = /<script[\t\n\f\r />]/i; // As script text, after `<!--`
 const RE_MATH_TAG = /<(\/?)math(?=[\s/>])/gi;
 const SCRIPT_BOOL_ATTRS = new Set(['async', 'defer', 'nomodule']);
 const DEFAULT_JS_TYPES = new Set(['', 'text/javascript', 'application/javascript']);
@@ -826,14 +831,20 @@ function mergeConsecutiveScripts(html, hasMathML = false) {
       }
       if (boolConflict || a1.nonce !== a2.nonce || (!mergedAny && insideMath(m1.index))) break;
 
-      // Join with a semicolon, or with a newline where the first ends in a `//` comment
       const content2 = html.slice(tagEnd2 + 1, close2.index);
+      // After `<!--`, `<script` opens a state `</script>` doesn’t end,
+      // which would swallow what follows the merged script
+      if (mergedContent.indexOf('<!--') !== -1 && RE_SCRIPT_START_TEXT.test(content2)) break;
+
+      // Join with a semicolon, after a newline where the first may end in a `//`, `<!--`,
+      // or `-->` comment, all of which browsers read as running to the end of the line,
+      // and before one where the second starts with `-->`, a comment only there
       const c1 = mergedContent.trim();
       const c2 = content2.trim();
       if (c1 && c2) {
         const lastLine = c1.slice(c1.lastIndexOf('\n') + 1);
-        const separator = lastLine.includes('//') ? '\n' : (c1.endsWith(';') ? '' : ';');
-        mergedContent = c1 + separator + c2;
+        const separator = /\/\/|<!--|-->/.test(lastLine) ? '\n;' : (c1.endsWith(';') ? '' : ';');
+        mergedContent = c1 + separator + (c2.startsWith('-->') ? '\n' : '') + c2;
       } else {
         mergedContent = c1 || c2;
       }
@@ -953,6 +964,11 @@ async function createSortFns(value, options, uidIgnore, ignoredMarkupChunks) {
     removeTagWhitespace: false,
     decodeEntities: false,
     processScripts: false,
+    minifyCSS: identity,
+    minifyJS: identity,
+    minifyJSON: false,
+    minifySVG: null,
+    minifyURLs: identity,
     // `ignoreCustomFragments` stays, and template syntax may not parse cleanly
     continueOnParseError: true,
     log: identity
@@ -1112,8 +1128,13 @@ async function minifyHTML(value, options, partialMarkup) {
   /** @type {HTMLAttribute[]} */
   const emptyAttrs = [];
 
+  // While parsing, entries already in it change through `bufferSet`, `bufferRemove`,
+  // or `bufferTruncate`, so that `trimSettledIndex` stays true
   /** @type {string[]} */
   const buffer = [];
+  // Where the last trim walk began that came to text it couldn’t trim, past end tags alone: A
+  // later walk that gets there finds the same, until an entry up to there changes
+  let trimSettledIndex = -1;
   // Parallel to `buffer`: whether the entry is a tag—the only place lines may break
   const bufferTags = options.maxLineLength ? /** @type {boolean[]} */ ([]) : null;
   /** @type {string} */
@@ -1124,8 +1145,12 @@ async function minifyHTML(value, options, partialMarkup) {
   // Open elements under `removeEmptyElements`, so an element whose content
   // went is removed, too: where its start tag sits in `buffer`, and whether
   // anything kept went in since
-  /** @type {Array<{tag: string, index: number, empty: boolean}>} */
+  /** @type {Array<{tag: string, index: number, empty: boolean, omittedStartTag?: {tag: string, text: string} | undefined, omittedEndTag?: {tag: string, text: string} | undefined, impliedEnds?: Array<{tag: string, text: string}> | undefined}>} */
   const openElements = [];
+  // End tags not written, for the start tag that comes next (`text` is empty where one can’t be)
+  /** @type {Array<{tag: string, text: string}>} */
+  let impliedEnds = [];
+  let impliedEndsIndex = -1;
   // Under `selfCloseForeignElements`, the open `svg` and `math` elements and the integration points
   // in them, whose children are HTML, which a slash does not close
   /** @type {string[]} */
@@ -1149,7 +1174,7 @@ async function minifyHTML(value, options, partialMarkup) {
   const stackNoTrimWhitespace = [];
   /** @type {string[]} */
   const stackNoCollapseWhitespace = [];
-  let preTextareaDepth = 0; // Count of `pre`/`textarea` entries in `stackNoTrimWhitespace`
+  let preDepth = 0; // Count of `pre` entries in `stackNoTrimWhitespace`
   // Where the last element whose whitespace may not be trimmed ended in `buffer`;
   // what lies up to there stays as written, also where `canTrimWhitespace` decides
   // by attributes the trim walk lacks
@@ -1411,8 +1436,21 @@ async function minifyHTML(value, options, partialMarkup) {
     if (entry) removed = false;
   }
 
+  function bufferSet(/** @type {number} */ index, /** @type {string} */ entry) {
+    buffer[index] = entry;
+    if (index <= trimSettledIndex) trimSettledIndex = -1;
+  }
+
+  // Entries after `index` move down by one, so a settled walk from there on is no longer one
+  function bufferRemove(/** @type {number} */ index) {
+    buffer.splice(index, 1);
+    bufferTags?.splice(index, 1);
+    if (index <= trimSettledIndex) trimSettledIndex = -1;
+  }
+
   function bufferTruncate(/** @type {number} */ length) {
     buffer.length = Math.max(0, length);
+    if (length <= trimSettledIndex) trimSettledIndex = -1;
     if (bufferTags) bufferTags.length = buffer.length;
     if (transparentGapIndex >= buffer.length) transparentGapIndex = -1;
     if (noTrimEndIndex >= buffer.length) noTrimEndIndex = -1;
@@ -1457,15 +1495,15 @@ async function minifyHTML(value, options, partialMarkup) {
       return;
     }
     for (let i = before + 1; i <= first; i++) {
-      buffer[i] = '';
+      bufferSet(i, '');
     }
     // The line break goes on the side of the text before the removal, so that the text after
     // it keeps its own for a removal that may follow
     if (before < 0) {
-      buffer[after] = next.replace(RE_BLANKS_LINE_BREAK_START, '');
+      bufferSet(after, next.replace(RE_BLANKS_LINE_BREAK_START, ''));
     } else {
-      buffer[before] = prev.replace(RE_LINE_BREAK_BLANKS_END, '');
-      buffer[after] = next.replace(RE_BLANKS_START, '');
+      bufferSet(before, prev.replace(RE_LINE_BREAK_BLANKS_END, ''));
+      bufferSet(after, next.replace(RE_BLANKS_START, ''));
     }
   }
 
@@ -1480,18 +1518,18 @@ async function minifyHTML(value, options, partialMarkup) {
     if (!textVerbatim) {
       let index = buffer.length - 1;
       while (index >= 0 && (buffer[index] === '' || RE_WS_ONLY.test(buffer[index] ?? ''))) {
-        buffer[index--] = '';
+        bufferSet(index--, '');
       }
       if (index >= 0) {
-        buffer[index] = (buffer[index] ?? '').replace(RE_WS_END, '');
+        bufferSet(index, (buffer[index] ?? '').replace(RE_WS_END, ''));
       }
     }
     let index = 0;
     while (index < buffer.length && (buffer[index] === '' || RE_WS_ONLY.test(buffer[index] ?? ''))) {
-      buffer[index++] = '';
+      bufferSet(index++, '');
     }
     if (index < buffer.length) {
-      buffer[index] = (buffer[index] ?? '').replace(RE_WS_START, '');
+      bufferSet(index, (buffer[index] ?? '').replace(RE_WS_START, ''));
     }
   }
 
@@ -1503,8 +1541,11 @@ async function minifyHTML(value, options, partialMarkup) {
     return index;
   }
 
-  function removeStartTag() {
-    bufferTruncate(lastStartTagIndex());
+  function removeStartTag(/** @type {boolean} */ capture = false) {
+    const index = lastStartTagIndex();
+    const text = capture ? buffer.slice(index).join('') : undefined;
+    bufferTruncate(index);
+    return text;
   }
 
   // Write the last start tag as self-closing, where it is the last thing written and holds no
@@ -1527,7 +1568,7 @@ async function minifyHTML(value, options, partialMarkup) {
     }
     const tagOpen = tagText.slice(0, -1);
     // A slash right after an unquoted value would belong to the value
-    buffer[last] = tagOpen + (RE_UNQUOTED_VALUE_END.test(tagOpen) ? ' />' : '/>');
+    bufferSet(last, tagOpen + (RE_UNQUOTED_VALUE_END.test(tagOpen) ? ' />' : '/>'));
     return true;
   }
 
@@ -1549,6 +1590,26 @@ async function minifyHTML(value, options, partialMarkup) {
     return lowerTag === 'svg' || lowerTag === 'math' || scope === undefined || scope === 'svg' || scope === 'math';
   }
 
+  // Browsers can close a formatting element with others left open inside it;
+  // any other end tag that doesn’t match the top entry of a stack is stray
+  function canCloseBelowTop(/** @type {string} */ tag, /** @type {string} */ lowerTag) {
+    return formattingElements.has((lowerTag || tag).toLowerCase());
+  }
+
+  // Returns whether `tag` was open
+  function removeClosedTag(/** @type {string[]} */ tags, /** @type {string} */ tag, /** @type {string} */ lowerTag) {
+    if (tags[tags.length - 1] === tag) {
+      tags.pop();
+      return true;
+    }
+    const index = canCloseBelowTop(tag, lowerTag) ? tags.lastIndexOf(tag) : -1;
+    if (index === -1) {
+      return false;
+    }
+    tags.splice(index, 1);
+    return true;
+  }
+
   function markOpenElementFilled() {
     // Guarded, as reading index -1 is a slow property lookup, and this runs for every text node
     if (openElements.length) {
@@ -1584,9 +1645,9 @@ async function minifyHTML(value, options, partialMarkup) {
     // A line break the run already carries outranks the whitespace ahead of it; trimming
     // the other side takes ASCII whitespace only, so a no-break space stays as is
     if (options.preserveLineBreaks && /[\n\r]/.test((next.match(RE_WS_START) ?? [''])[0])) {
-      buffer[before] = prev.replace(RE_WS_END, '');
+      bufferSet(before, prev.replace(RE_WS_END, ''));
     } else {
-      buffer[after] = next.replace(RE_WS_START, '');
+      bufferSet(after, next.replace(RE_WS_START, ''));
     }
   }
 
@@ -1596,13 +1657,13 @@ async function minifyHTML(value, options, partialMarkup) {
     while (index > 0 && !RE_END_TAG.test(buffer[index] ?? '')) {
       index--;
     }
+    const text = buffer[index] ?? '';
     // Text that follows the end tag is kept as is, so drop the tag alone. Whitespace kept
     // verbatim—in `pre`, in `textarea`, or wherever `canTrimWhitespace` says so—counts as
     // kept text too, no matter how whitespace is collapsed elsewhere.
     const noTrim = insideNoTrim || stackNoTrimWhitespace.length > 0;
-    if (index < buffer.length - 1 && (keepsWhitespace() || noTrim) && RE_END_TAG.test(buffer[index] ?? '')) {
-      buffer.splice(index, 1);
-      bufferTags?.splice(index, 1);
+    if (index < buffer.length - 1 && (keepsWhitespace() || noTrim) && RE_END_TAG.test(text)) {
+      bufferRemove(index);
       // Collapsed whitespace can merge, kept whitespace can leave a line of only whitespace
       if (!noTrim) {
         if (options.collapseWhitespace) {
@@ -1611,9 +1672,10 @@ async function minifyHTML(value, options, partialMarkup) {
           removeWhitespaceLine(index);
         }
       }
-      return;
+      return text;
     }
     bufferTruncate(index);
+    return text;
   }
 
   // Look for trailing whitespace, bypassing inline tags
@@ -1621,10 +1683,18 @@ async function minifyHTML(value, options, partialMarkup) {
     // Nothing to the left of the text is in play here, so only its trailing run can
     // change—unless preserved line breaks bring the leading run into play, too
     const trailingOnly = !options.preserveLineBreaks;
+    const indexStart = index;
     let prevTag = '';
     let prevTagLower = '';
     for (; index > noTrimEndIndex && canTrimWhitespace(prevTagLower, prevTag, emptyAttrs); index--) {
+      if (index === trimSettledIndex) {
+        trimSettledIndex = indexStart;
+        return;
+      }
       const str = buffer[index] ?? '';
+      if (!str) {
+        continue;
+      }
       const endTagName = matchPlainEndTag(str);
       if (endTagName !== null) {
         prevTag = endTagName;
@@ -1633,14 +1703,12 @@ async function minifyHTML(value, options, partialMarkup) {
       }
       // A tag ends the search, and so does text that survives collapsing. Text with no
       // trailing run comes back from the call unchanged, so it can end the search on
-      // the spot; empty text cannot, as the search has to carry on past it
-      if (str.charCodeAt(str.length - 1) === 62 /* > */) {
-        break;
-      }
-      if (trailingOnly && str && !endsWithWhitespace(str)) {
+      // the spot, and so can every later search that gets as far as this one began
+      if (str.charCodeAt(str.length - 1) === 62 /* > */ || (trailingOnly && !endsWithWhitespace(str))) {
+        trimSettledIndex = indexStart;
         break;
       }
-      buffer[index] = collapseWhitespaceSmart(str, '', nextTag, emptyAttrs, emptyAttrs, options, inlineSets, !stackNoCollapseWhitespace.length && index > noCollapseEndIndex);
+      bufferSet(index, collapseWhitespaceSmart(str, '', nextTag, emptyAttrs, emptyAttrs, options, inlineSets, !stackNoCollapseWhitespace.length && index > noCollapseEndIndex));
       if (buffer[index]) {
         break;
       }
@@ -1696,7 +1764,7 @@ async function minifyHTML(value, options, partialMarkup) {
   // Keep or trim the whitespace pending before or between elements that don’t render
   function settleTransparentGap(/** @type {boolean} */ keep) {
     if (!keep) {
-      buffer[transparentGapIndex] = collapseWhitespace(buffer[transparentGapIndex] ?? '', options, false, true);
+      bufferSet(transparentGapIndex, collapseWhitespace(buffer[transparentGapIndex] ?? '', options, false, true));
     }
     transparentGapIndex = -1;
   }
@@ -1775,11 +1843,11 @@ async function minifyHTML(value, options, partialMarkup) {
 
   // Whitespace collapsing phase (sync)
   function charsCollapse(/** @type {string} */ text) {
-    // Trim a single trailing newline inside `pre`/`textarea`, often a template engine artifact
-    // (several are likely intentional formatting)
+    // Trim a single trailing newline inside `pre`, often a template engine artifact (several are
+    // likely intentional formatting); in `textarea`, it is part of the value
     if (options.collapseWhitespace && stackNoTrimWhitespace.length) {
       const topTag = stackNoTrimWhitespace[stackNoTrimWhitespace.length - 1];
-      if (preTextareaDepth > 0) {
+      if (preDepth > 0 && topTag?.toLowerCase() !== 'textarea') {
         // Treat CRLF (`\r\n`), CR (`\r`), and LF (`\n`) as single line-ending units
         if (textNextTag && textNextTag === '/' + topTag && /[^\r\n](?:\r\n|\r|\n)[ \t]*$/.test(text)) {
           text = text.replace(RE_LINE_BREAK_BLANKS_END, '');
@@ -1801,10 +1869,14 @@ async function minifyHTML(value, options, partialMarkup) {
             }
             if (buffer.length > 1 && (!prevComment || (!options.conservativeCollapse && / $/.test(currentChars)))) {
               const charsIndex = buffer.length - 2;
-              buffer[charsIndex] = (buffer[charsIndex] ?? '').replace(/\s+$/, function (trailingSpaces) {
+              bufferSet(charsIndex, (buffer[charsIndex] ?? '').replace(/\s+$/, function (trailingSpaces) {
                 text = trailingSpaces + text;
+                // It moved, and is judged again as part of this text
+                if (currentChars.endsWith(trailingSpaces)) {
+                  currentChars = currentChars.slice(0, -trailingSpaces.length);
+                }
                 return '';
-              });
+              }));
             }
           } else if (uidIgnorePlaceholderPattern && textNextTag !== 'comment') {
             // UID placeholder followed by a real element—derive the effective `prevTag` from the
@@ -1835,7 +1907,7 @@ async function minifyHTML(value, options, partialMarkup) {
               trimTrailingWhitespace(tagIndex - 1, 'br');
             }
           } else if (inlineSets.withinEither.has(textPrevTag)) {
-            text = collapseWhitespace(text, options, /(?:^|\s)$/.test(currentChars), false, false, stackNoCollapseWhitespace.length > 0);
+            text = collapseWhitespace(text, options, RE_ENDS_COLLAPSIBLE.test(currentChars), false, false, stackNoCollapseWhitespace.length > 0);
           }
         }
         if (textPrevTag || textNextTag) {
@@ -1938,9 +2010,16 @@ async function minifyHTML(value, options, partialMarkup) {
     }
     if (text && options.insideSVG && options.minifySVG) {
       // SVGO reads XML, so text is escaped for it, while raw text, which XML cannot read as
-      // HTML does (as in `foreignObject`), passes SVGO as a placeholder
+      // HTML does (as in `foreignObject`), passes SVGO as a placeholder—as does HTML text
+      // with whitespace at an end, which SVGO trims (`trim()`, so no-break spaces, too)
+      // outside SVG text elements
       if (!rawText) {
         text = escapeXML(text);
+        if (!options.insideForeignContent && /^\s|\s$/.test(text)) {
+          uidSVGRawText ||= uniqueId(value);
+          svgRawTexts.push(text);
+          text = '/*!' + uidSVGRawText + (svgRawTexts.length - 1) + '*/';
+        }
       } else if (text.indexOf('&') !== -1 || text.indexOf('<') !== -1 || text.indexOf(']]>') !== -1) {
         uidSVGRawText ||= uniqueId(value);
         svgRawTexts.push(text);
@@ -2024,9 +2103,9 @@ async function minifyHTML(value, options, partialMarkup) {
       const firstTag = match ? RE_FIRST_HTML_TAG.exec(ignoredMarkupChunks[+(match[1] ?? 0)] ?? '')?.[1] : undefined;
       if (firstTag && inlineElementsTransparent.has(resolveName(firstTag)) && inlineElementsTransparentAfter.has(charsPrevTag)) {
         // Emptied first, as `precedesTransparentRun` stops at text
-        buffer[buffer.length - 1] = '';
+        bufferSet(buffer.length - 1, '');
         if (transparentGapIndex === buffer.length - 1) transparentGapIndex = -1;
-        buffer[buffer.length - 1] = options.conservativeCollapse || precedesTransparentRun(true) ? ' ' : '';
+        bufferSet(buffer.length - 1, options.conservativeCollapse || precedesTransparentRun(true) ? ' ' : '');
       }
     }
     // What an `htmlmin:ignore` block holds is unknown, so whitespace pending before it stays
@@ -2097,7 +2176,7 @@ async function minifyHTML(value, options, partialMarkup) {
                         }
                       }
 
-                      buffer[buffer.length - 1] = collapsedText;
+                      bufferSet(buffer.length - 1, collapsedText);
                     }
                   }
                 }
@@ -2125,7 +2204,7 @@ async function minifyHTML(value, options, partialMarkup) {
       const trims = Boolean(options.collapseWhitespace) &&
         !options.conservativeCollapse && !options.preserveLineBreaks;
       for (const { code, isModule } of bodies) {
-        const body = trims ? code.trim() : code;
+        const body = replaceNUL(trims ? code.trim() : code);
         const key = (isModule ? 'm|' : '|') + body;
         if (jsPrewarmed.has(key)) {
           continue;
@@ -2190,7 +2269,7 @@ async function minifyHTML(value, options, partialMarkup) {
             const builtAttr = buildAttr(normalizedAttr, tag, hasUnarySlash, optionsTag, i === lastKeptIndex, uidAttr, markers);
             // One entry with the tag name, so that no line break can come between them
             if (i === 0 && fragmentJoinsTag) {
-              buffer[buffer.length - 1] += builtAttr;
+              bufferSet(buffer.length - 1, (buffer[buffer.length - 1] ?? '') + builtAttr);
             } else {
               bufferPush(builtAttr, true);
             }
@@ -2202,7 +2281,7 @@ async function minifyHTML(value, options, partialMarkup) {
       optionalStartTag = tag;
     }
 
-    buffer[buffer.length - 1] += tagText + (hasUnarySlash ? '/' : '') + '>';
+    bufferSet(buffer.length - 1, (buffer[buffer.length - 1] ?? '') + tagText + (hasUnarySlash ? '/' : '') + '>');
 
     impliedStartTag = autoGenerated && !options.includeAutoGeneratedTags ? tag : '';
     if (impliedStartTag) {
@@ -2344,11 +2423,20 @@ async function minifyHTML(value, options, partialMarkup) {
       currentTag = tag;
       charsPrevTag = tag;
       if (!inlineTextSet.has(lowerTag || tag)) {
-        currentChars = '';
+        // Replaced content counts as content for the whitespace after what holds it
+        currentChars = inlineElementsToKeepWhitespace.has(lowerTag || tag) ? '|' : '';
       }
       hasChars = false;
       currentAttrs = attrs;
 
+      // What this start tag closed, which is left to the end tags if its element is removed
+      const impliedEndsClosed = impliedEndsIndex === buffer.length ? impliedEnds : undefined;
+
+      // What this start tag made optional, for if the element then turns out to be removed
+      /** @type {{tag: string, text: string} | undefined} */
+      let omittedStartTag;
+      /** @type {{tag: string, text: string} | undefined} */
+      let omittedEndTag;
       let optional = options.removeOptionalTags;
       if (optional) {
         const htmlTag = htmlElements.has(tag);
@@ -2359,7 +2447,10 @@ async function minifyHTML(value, options, partialMarkup) {
         // `<colgroup>` may be omitted if first thing inside is `<col>`
         // `<tbody>` may be omitted if first thing inside is `<tr>`
         if (htmlTag && canRemoveParentTag(optionalStartTag, tag)) {
-          removeStartTag();
+          const text = removeStartTag(options.removeEmptyElements);
+          if (text !== undefined) {
+            omittedStartTag = { tag: optionalStartTag, text };
+          }
         }
         optionalStartTag = '';
         // End-tag-followed-by-start-tag omission rules
@@ -2367,7 +2458,10 @@ async function minifyHTML(value, options, partialMarkup) {
         if (htmlTag && canRemovePrecedingTag(optionalEndTag, tag) && (tableClosesP || optionalEndTag !== 'p' || tag !== 'table')) {
           // Only a start tag that gets written can stand in for the end tag
           if (optionalEndTagEmitted && (!autoGenerated || options.includeAutoGeneratedTags)) {
-            removeEndTag();
+            const text = removeEndTag();
+            if (options.removeEmptyElements) {
+              omittedEndTag = { tag: optionalEndTag, text };
+            }
           }
           // `<colgroup>` cannot be omitted if preceding `</colgroup>` is omitted
           // `<tbody>` cannot be omitted if preceding `</tbody>`, `</thead>`, or `</tfoot>` is
@@ -2390,7 +2484,7 @@ async function minifyHTML(value, options, partialMarkup) {
         const tagLower = lowerTag || tag;
         if (!canTrimWhitespace(tagLower, tagOut, attrs) || stackNoTrimWhitespace.length) {
           stackNoTrimWhitespace.push(tag);
-          if (tagLower === 'pre' || tagLower === 'textarea') preTextareaDepth++;
+          if (tagLower === 'pre') preDepth++;
         }
         if (options.collapseWhitespace && (!canCollapseWhitespace(tagLower, tagOut, attrs) || stackNoCollapseWhitespace.length)) {
           stackNoCollapseWhitespace.push(tag);
@@ -2420,7 +2514,7 @@ async function minifyHTML(value, options, partialMarkup) {
           markOpenElementFilled();
         } else {
           // A start tag not written can’t be removed with its element
-          openElements.push({ tag, index: buffer.length - 1, empty: !autoGenerated || Boolean(options.includeAutoGeneratedTags) });
+          openElements.push({ tag, index: buffer.length - 1, empty: !autoGenerated || Boolean(options.includeAutoGeneratedTags), omittedStartTag, omittedEndTag, impliedEnds: impliedEndsClosed });
         }
       }
 
@@ -2513,10 +2607,9 @@ async function minifyHTML(value, options, partialMarkup) {
       const insideNoTrim = stackNoTrimWhitespace.length > 0;
       let closesNoTrim = false;
       if (stackNoTrimWhitespace.length) {
-        if (tag === stackNoTrimWhitespace[stackNoTrimWhitespace.length - 1]) {
+        if (removeClosedTag(stackNoTrimWhitespace, tag, lowerTag)) {
           const tagLower = lowerTag || tag;
-          if (tagLower === 'pre' || tagLower === 'textarea') preTextareaDepth--;
-          stackNoTrimWhitespace.pop();
+          if (tagLower === 'pre') preDepth--;
           closesNoTrim = !stackNoTrimWhitespace.length;
         }
       } else if (options.collapseWhitespace) {
@@ -2526,9 +2619,7 @@ async function minifyHTML(value, options, partialMarkup) {
         transparentDepth--;
       }
       let closesNoCollapse = false;
-      if (stackNoCollapseWhitespace.length &&
-          tag === stackNoCollapseWhitespace[stackNoCollapseWhitespace.length - 1]) {
-        stackNoCollapseWhitespace.pop();
+      if (stackNoCollapseWhitespace.length && removeClosedTag(stackNoCollapseWhitespace, tag, lowerTag)) {
         closesNoCollapse = !stackNoCollapseWhitespace.length;
       }
 
@@ -2539,6 +2630,7 @@ async function minifyHTML(value, options, partialMarkup) {
       const skipsEndTag = autoGenerated && (!options.includeAutoGeneratedTags || Boolean(holdsTable));
       impliedStartTag = '';
 
+      let startTagRemoved = false;
       let isElementEmpty = false;
       if (tag === currentTag) {
         currentTag = '';
@@ -2546,7 +2638,19 @@ async function minifyHTML(value, options, partialMarkup) {
       }
       selfCloses &&= isElementEmpty;
       // A stray end tag has no open element of its own
-      const openElement = options.removeEmptyElements && openElements[openElements.length - 1]?.tag === tag ? openElements.pop() : undefined;
+      let openElement;
+      if (options.removeEmptyElements && openElements.length) {
+        if (openElements[openElements.length - 1]?.tag === tag) {
+          openElement = openElements.pop();
+        } else if (canCloseBelowTop(tag, lowerTag)) {
+          const index = openElements.findLastIndex(entry => entry.tag === tag);
+          if (index !== -1) {
+            openElement = openElements.splice(index, 1)[0];
+            // Closed around what is open inside it, so that holds this end tag now
+            currentTag = '';
+          }
+        }
+      }
       // Emptied by removing what it held, as long as its start tag is still the last one written
       const isElementEmptied = !isElementEmpty && Boolean(openElement?.empty) && lastStartTagIndex() === openElement?.index;
 
@@ -2554,15 +2658,17 @@ async function minifyHTML(value, options, partialMarkup) {
         // `<html>`, `<head>`, or `<body>` may be omitted if the element is empty
         if (isElementEmpty && topLevelElements.has(optionalStartTag)) {
           removeStartTag();
+          startTagRemoved = true;
         }
         optionalStartTag = '';
-        // `</html>` or `</body>` may be omitted if not followed by comment
-        // `</head>` may be omitted if not followed by space or comment
-        // `</p>` may be omitted if no more content in parent, as long as the parent’s end tag
-        //   closes the `p` in browsers (`pClosingParents`)
-        // Except for `</dt>` or `</thead>`, end tags may be omitted if no more content in parent
+        // `</html>` or `</body>` may be omitted if not followed by comment;
+        // `</head>` may be omitted if not followed by space or comment;
+        // `</p>`, `</li>`, `</dd>`, and `</dt>` may be omitted if no more content
+        // in parent, as long as the parent’s end tag closes these special elements
+        // in browsers (`pClosingParents`); except for `</dt>` or `</thead>`,
+        // end tags may be omitted if no more content in parent
         // https://html.spec.whatwg.org/multipage/syntax.html#optional-tags
-        if (tag && optionalEndTag && optionalEndTagEmitted && !trailingElements.has(optionalEndTag) && (optionalEndTag !== 'p' || pClosingParents.has(tag))) {
+        if (tag && optionalEndTag && optionalEndTagEmitted && !trailingElements.has(optionalEndTag) && (!specialOptionalEndTags.has(optionalEndTag) || pClosingParents.has(tag))) {
           removeEndTag(insideNoTrim);
         }
         optionalEndTag = optionalEndTags.has(tag) && !endsImpliedStart && !holdsTable ? tag : '';
@@ -2571,8 +2677,8 @@ async function minifyHTML(value, options, partialMarkup) {
 
       let isElementRemoved = false;
       // A formatting element closed by a block is reopened after it by browsers, so it has to stay
-      if (options.removeEmptyElements && (isElementEmpty || isElementEmptied) && !options.insideForeignContent && canRemoveElement(tag, attrs) &&
-          !(autoGenerated && formattingElements.has(tag))) {
+      if (options.removeEmptyElements && (isElementEmpty || isElementEmptied) && !options.insideForeignContent && canRemoveElement(tag, attrs, options, tagOut) &&
+          !(autoGenerated && formattingElements.has(tag)) && !openElement?.impliedEnds?.some(implied => !implied.text)) {
         let preserve = false;
         if (removeEmptyElementsExcept.length) {
           const normalizedAttrs = attrs.map((/** @type {HTMLAttribute} */ attr) => ({ ...attr, name: resolveName(attr.name) }));
@@ -2580,11 +2686,37 @@ async function minifyHTML(value, options, partialMarkup) {
         }
 
         if (!preserve) {
-          removeStartTag();
+          // Once it is gone, the last start tag is another element’s
+          if (!startTagRemoved) {
+            removeStartTag();
+          }
           isElementRemoved = true;
           optionalStartTag = '';
           optionalEndTag = '';
           optionalEndTagEmitted = false;
+          // What it made optional is up to what comes next now
+          if (openElement?.omittedEndTag) {
+            bufferPush(openElement.omittedEndTag.text, true);
+            optionalEndTag = openElement.omittedEndTag.tag;
+            optionalEndTagEmitted = true;
+          }
+          if (openElement?.omittedStartTag) {
+            bufferPush(openElement.omittedStartTag.text, true);
+            optionalStartTag = openElement.omittedStartTag.tag;
+          }
+          if (openElement?.impliedEnds) {
+            // Browsers reopen formatting elements after what closed them, which their end tags
+            // would prevent and whitespace following an omitted end tag would change
+            const written = openElement.impliedEnds.filter(implied => !formattingElements.has(implied.tag));
+            for (const implied of written) {
+              bufferPush(implied.text, true);
+            }
+            const last = written[written.length - 1];
+            if (last && written.length === openElement.impliedEnds.length && optionalEndTags.has(last.tag)) {
+              optionalEndTag = last.tag;
+              optionalEndTagEmitted = true;
+            }
+          }
         } else {
           // Preserve the element—add closing tag
           if (skipsEndTag) {
@@ -2595,7 +2727,7 @@ async function minifyHTML(value, options, partialMarkup) {
           charsPrevTag = '/' + tag;
           if (!inlineElements.has(lowerTag || tag)) {
             currentChars = '';
-          } else if (isElementEmpty) {
+          } else if (isElementEmpty || !inlineTextSet.has(lowerTag || tag)) {
             currentChars += '|';
           }
         }
@@ -2608,11 +2740,20 @@ async function minifyHTML(value, options, partialMarkup) {
         charsPrevTag = '/' + tag;
         if (!inlineElements.has(lowerTag || tag)) {
           currentChars = '';
-        } else if (isElementEmpty) {
+        } else if (isElementEmpty || !inlineTextSet.has(lowerTag || tag)) {
+          // What is not text counts as content for the whitespace after it
           currentChars += '|';
         }
       }
 
+      if (skipsEndTag && !isElementRemoved && options.removeEmptyElements) {
+        if (impliedEndsIndex !== buffer.length) {
+          impliedEnds = [];
+          impliedEndsIndex = buffer.length;
+        }
+        impliedEnds.push({ tag, text: holdsTable ? '' : endTagText });
+      }
+
       if (closesNoTrim && !isElementRemoved) {
         noTrimEndIndex = buffer.length - 1;
       }
@@ -2678,6 +2819,9 @@ async function minifyHTML(value, options, partialMarkup) {
         if (needsProcessScript) {
           text = await processScript(text, options, currentTag, currentAttrs, minifyHTML);
         }
+        if (needsMinifyJS || needsMinifyCSS) {
+          text = replaceNUL(text);
+        }
         if (needsMinifyJS) {
           const prewarmed = jsPrewarmed?.get((isModuleScript ? 'm|' : '|') + text);
           text = prewarmed ? await prewarmed : await options.minifyJS(text, false, isModuleScript);
@@ -2710,12 +2854,16 @@ async function minifyHTML(value, options, partialMarkup) {
     strayEnd: function () {
       removed = true;
     },
-    doctype: function (/** @type {string} */ doctype, /** @type {boolean} */ noQuirksMode) {
+    doctype: function (/** @type {string} */ doctype, /** @type {boolean} */ noQuirksMode, /** @type {boolean} */ isIgnored) {
       tableClosesP = noQuirksMode;
+      if (isIgnored) {
+        removed = true;
+        return;
+      }
       bufferPush(options.useShortDoctype
         ? '<!doctype' +
         (options.removeTagWhitespace ? '' : ' ') + 'html>'
-        : collapseWhitespaceAll(doctype), false);
+        : doctype.replace(RE_DOCTYPE_SEGMENT, (segment, quoted) => quoted ?? collapseWhitespaceAll(segment)), false);
     }
   });
 
@@ -2749,7 +2897,7 @@ async function minifyHTML(value, options, partialMarkup) {
     for (let i = 0; i < buffer.length; i++) {
       const segment = /** @type {string} */ (buffer[i]);
       if (segment.indexOf(uidSVGRawText) !== -1) {
-        buffer[i] = segment.replace(pattern, (/** @type {string} */ match, /** @type {string} */ index) => svgRawTexts[+index] ?? match);
+        bufferSet(i, segment.replace(pattern, (/** @type {string} */ match, /** @type {string} */ index) => svgRawTexts[+index] ?? match));
       }
     }
   }
@@ -3035,6 +3183,9 @@ export const minify = async function (value, options) {
   let processedBase;
   // `valueUnchanged` needs no budget of its own: Recursion is bounded by the
   // stored snapshot, which is a finite tree of at most `SNAPSHOT_MAX_NODES`
+  //
+  // Note: The comparison takes about 8% of a call on tiny documents; only options
+  // known never to change (e.g., deeply frozen ones) could skip it
   if (cached && valueUnchanged(cached.snapshot, inputOptions)) {
     processedBase = cached.processed;
   } else {