html-minifier 5.0.1 → 5.0.3

package/src/htmlminifier.js

@@ -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,
@@ -78,7 +81,7 @@ import {
 } from './lib/content.js';
 
 import { processOptions } from './lib/options.js';
-import { toFragment, replaceCustomFragments } from './lib/fragments.js';
+import { toFragment, replaceCustomFragments, isMinifiedCodeSafe } from './lib/fragments.js';
 
 /** @import { ProcessedOptions } from './lib/options.js' */
 
@@ -826,13 +829,13 @@ 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
+      // Join with a semicolon, after a newline where the first may end in a `//` comment
       const content2 = html.slice(tagEnd2 + 1, close2.index);
       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(';') ? '' : ';');
+        const separator = lastLine.includes('//') ? '\n;' : (c1.endsWith(';') ? '' : ';');
         mergedContent = c1 + separator + c2;
       } else {
         mergedContent = c1 || c2;
@@ -1124,8 +1127,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 +1156,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
@@ -1263,31 +1270,32 @@ async function minifyHTML(value, options, partialMarkup) {
         uidAttrLeadingPattern = new RegExp('^\\s*' + uidAttr + '(\\d+)' + uidAttr);
         uidAttrExactPattern = new RegExp('^' + uidAttr + '(\\d+)' + uidAttr + '$');
 
-        if (options.minifyCSS !== identity) {
-          options.minifyCSS = (function (/** @type {ProcessedOptions['minifyCSS']} */ fn) {
-            return function (/** @type {string} */ text, /** @type {string | undefined} */ type, /** @type {ProcessedOptions['cssContext']} */ context) {
-              text = text.replace(/** @type {RegExp} */ (uidPattern), function (/** @type {string} */ _match, /** @type {string} */ _prefix, /** @type {string} */ index) {
-                const chunks = ignoredCustomMarkupChunks[+index];
-                customMarkupInCode.add(+index);
-                return (chunks?.[1] ?? '') + uidAttr + index + uidAttr + (chunks?.[2] ?? '');
-              });
-
-              return fn(text, type, context);
-            };
-          })(options.minifyCSS);
-        }
-
-        if (options.minifyJS !== identity) {
-          options.minifyJS = (function (/** @type {ProcessedOptions['minifyJS']} */ fn) {
-            return function (/** @type {string} */ text, /** @type {boolean | undefined} */ inline, /** @type {boolean | undefined} */ isModule) {
-              return fn(text.replace(/** @type {RegExp} */ (uidPattern), function (/** @type {string} */ _match, /** @type {string} */ _prefix, /** @type {string} */ index) {
-                const chunks = ignoredCustomMarkupChunks[+index];
-                customMarkupInCode.add(+index);
-                return (chunks?.[1] ?? '') + uidAttr + index + uidAttr + (chunks?.[2] ?? '');
-              }), inline, isModule);
-            };
-          })(options.minifyJS);
-        }
+        const uidPlaceholderPattern = new RegExp(uidAttr + '\\d+' + uidAttr, 'g');
+
+        /**
+         * @param {(text: string, ...args: any[]) => any} fn
+         * @param {boolean} isJS
+         * @returns {any}
+         */
+        const wrapCodeMinifier = (fn, isJS) => (/** @type {string} */ text, /** @type {any[]} */ ...args) => {
+          if (!text.includes(/** @type {string} */ (uidAttr))) return fn(text, ...args);
+
+          const source = text.replace(/** @type {RegExp} */ (uidPattern), function (/** @type {string} */ _match, /** @type {string} */ _prefix, /** @type {string} */ index) {
+            const chunks = ignoredCustomMarkupChunks[+index];
+            customMarkupInCode.add(+index);
+            return (chunks?.[1] ?? '') + uidAttr + index + uidAttr + (chunks?.[2] ?? '');
+          });
+          const result = fn(source, ...args);
+          const finish = (/** @type {string} */ output) => {
+            if (isMinifiedCodeSafe(source, output, uidPlaceholderPattern, isJS)) return output;
+            options.log('Keeping CSS or JavaScript as written, as minifying could break or lose a custom fragment');
+            return source;
+          };
+          return isThenable(result) ? Promise.resolve(result).then(finish) : finish(result);
+        };
+
+        if (options.minifyCSS !== identity) options.minifyCSS = wrapCodeMinifier(options.minifyCSS, false);
+        if (options.minifyJS !== identity) options.minifyJS = wrapCodeMinifier(options.minifyJS, true);
       }
 
       const token = uidAttr + ignoredCustomMarkupChunks.length + uidAttr;
@@ -1502,8 +1510,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
@@ -1548,6 +1559,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) {
@@ -1595,11 +1626,12 @@ 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] ?? '')) {
+    if (index < buffer.length - 1 && (keepsWhitespace() || noTrim) && RE_END_TAG.test(text)) {
       buffer.splice(index, 1);
       bufferTags?.splice(index, 1);
       // Collapsed whitespace can merge, kept whitespace can leave a line of only whitespace
@@ -1610,9 +1642,10 @@ async function minifyHTML(value, options, partialMarkup) {
           removeWhitespaceLine(index);
         }
       }
-      return;
+      return text;
     }
     bufferTruncate(index);
+    return text;
   }
 
   // Look for trailing whitespace, bypassing inline tags
@@ -1620,11 +1653,14 @@ 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;
-    for (let prevTag = ''; index > noTrimEndIndex && canTrimWhitespace(namesAsWritten ? prevTag.toLowerCase() : prevTag, prevTag, emptyAttrs); index--) {
+    let prevTag = '';
+    let prevTagLower = '';
+    for (; index > noTrimEndIndex && canTrimWhitespace(prevTagLower, prevTag, emptyAttrs); index--) {
       const str = buffer[index] ?? '';
       const endTagName = matchPlainEndTag(str);
       if (endTagName !== null) {
         prevTag = endTagName;
+        prevTagLower = prevTag.toLowerCase();
         continue;
       }
       // A tag ends the search, and so does text that survives collapsing. Text with no
@@ -1771,11 +1807,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, '');
@@ -1799,6 +1835,10 @@ async function minifyHTML(value, options, partialMarkup) {
               const charsIndex = buffer.length - 2;
               buffer[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 '';
               });
             }
@@ -1831,7 +1871,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) {
@@ -2146,8 +2186,9 @@ async function minifyHTML(value, options, partialMarkup) {
    * @param {string | boolean | undefined} hasUnarySlash
    * @param {boolean | undefined} optional
    * @param {ProcessedOptions | null} restoreOptions - Context a unary tag pushed, or null
+   * @param {ProcessedOptions} optionsTag - Context the element’s own attributes are in
    */
-  function emitStartTag(normalizedAttrs, tag, unary, autoGenerated, fragmentJoinsTag, hasUnarySlash, optional, restoreOptions) {
+  function emitStartTag(normalizedAttrs, tag, unary, autoGenerated, fragmentJoinsTag, hasUnarySlash, optional, restoreOptions, optionsTag) {
     // Find the last kept attribute, then emit in order, with no intermediate array
     let lastKeptIndex = -1;
     for (let i = normalizedAttrs.length - 1; i >= 0; i--) {
@@ -2169,7 +2210,7 @@ async function minifyHTML(value, options, partialMarkup) {
             if (uidAttr && normalizedAttr.name.includes(uidAttr)) {
               markTagFragments(normalizedAttr.name);
             }
-            tagText += buildAttr(normalizedAttr, hasUnarySlash, options, i === lastKeptIndex, uidAttr);
+            tagText += buildAttr(normalizedAttr, tag, hasUnarySlash, optionsTag, i === lastKeptIndex, uidAttr, markers);
           }
         }
       } else {
@@ -2182,7 +2223,7 @@ async function minifyHTML(value, options, partialMarkup) {
             if (uidAttr && normalizedAttr.name.includes(uidAttr)) {
               markTagFragments(normalizedAttr.name);
             }
-            const builtAttr = buildAttr(normalizedAttr, hasUnarySlash, options, i === lastKeptIndex, uidAttr);
+            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;
@@ -2338,12 +2379,21 @@ async function minifyHTML(value, options, partialMarkup) {
       }
       currentTag = tag;
       charsPrevTag = tag;
-      if (!inlineTextSet.has(tag)) {
-        currentChars = '';
+      if (!inlineTextSet.has(lowerTag || tag)) {
+        // 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);
@@ -2354,7 +2404,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
@@ -2362,7 +2415,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
@@ -2376,17 +2432,18 @@ async function minifyHTML(value, options, partialMarkup) {
       // Set whitespace flags for nested tags (e.g., `<code>` within a `<pre>`); verbatim
       // whitespace is tracked without `collapseWhitespace` too, as `removeWhitespaceLine` spares it
       if (options.collapseWhitespace && !stackNoTrimWhitespace.length) {
-        squashTrailingWhitespace(tag);
+        squashTrailingWhitespace(lowerTag || tag);
       }
-      if (options.collapseWhitespace && !unary && inlineElementsTransparent.has(tag)) {
+      if (options.collapseWhitespace && !unary && inlineElementsTransparent.has(lowerTag || tag)) {
         transparentDepth++;
       }
       if (!unary) {
-        if (!canTrimWhitespace(tag, tagOut, attrs) || stackNoTrimWhitespace.length) {
+        const tagLower = lowerTag || tag;
+        if (!canTrimWhitespace(tagLower, tagOut, attrs) || stackNoTrimWhitespace.length) {
           stackNoTrimWhitespace.push(tag);
-          if (tag === 'pre' || tag === 'textarea') preTextareaDepth++;
+          if (tagLower === 'pre') preDepth++;
         }
-        if (options.collapseWhitespace && (!canCollapseWhitespace(tag, tagOut, attrs) || stackNoCollapseWhitespace.length)) {
+        if (options.collapseWhitespace && (!canCollapseWhitespace(tagLower, tagOut, attrs) || stackNoCollapseWhitespace.length)) {
           stackNoCollapseWhitespace.push(tag);
         }
       }
@@ -2403,7 +2460,9 @@ async function minifyHTML(value, options, partialMarkup) {
       // SVGO reads the whole SVG block as XML, where an element closes itself or not, so
       // every unary element in there is written with a slash
       const needsXMLSlash = unary && Boolean(options.insideSVG) && Boolean(options.minifySVG);
-      const hasUnarySlash = needsXMLSlash || (unarySlash && (useNameParentForTag ? optionsParent : options).keepClosingSlash);
+      // `foreignObject` and `annotation-xml` hold HTML, but are foreign elements themselves
+      const optionsTag = useNameParentForTag ? optionsParent : options;
+      const hasUnarySlash = needsXMLSlash || (unarySlash && optionsTag.keepClosingSlash);
 
       bufferPush(openTag, true);
 
@@ -2412,7 +2471,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 });
         }
       }
 
@@ -2450,10 +2509,10 @@ async function minifyHTML(value, options, partialMarkup) {
       const restoreOptions = unary && pushedContext ? optionsParent : null;
       if (anyThenable) {
         return Promise.all(attrResults).then(resolved => {
-          emitStartTag(resolved, tag, unary, autoGenerated, fragmentJoinsTag, hasUnarySlash, optional, restoreOptions);
+          emitStartTag(resolved, tag, unary, autoGenerated, fragmentJoinsTag, hasUnarySlash, optional, restoreOptions, optionsTag);
         });
       }
-      emitStartTag(/** @type {Array<{name: string, value: string | undefined, attr: HTMLAttribute} | undefined>} */ (attrResults), tag, unary, autoGenerated, fragmentJoinsTag, hasUnarySlash, optional, restoreOptions);
+      emitStartTag(/** @type {Array<{name: string, value: string | undefined, attr: HTMLAttribute} | undefined>} */ (attrResults), tag, unary, autoGenerated, fragmentJoinsTag, hasUnarySlash, optional, restoreOptions, optionsTag);
       return undefined;
     },
     end: function (/** @type {string} */ tag, /** @type {HTMLAttribute[]} */ attrs, /** @type {boolean} */ autoGenerated, /** @type {string | undefined} */ rest, /** @type {boolean | undefined} */ holdsTable) {
@@ -2505,21 +2564,19 @@ async function minifyHTML(value, options, partialMarkup) {
       const insideNoTrim = stackNoTrimWhitespace.length > 0;
       let closesNoTrim = false;
       if (stackNoTrimWhitespace.length) {
-        if (tag === stackNoTrimWhitespace[stackNoTrimWhitespace.length - 1]) {
-          if (tag === 'pre' || tag === 'textarea') preTextareaDepth--;
-          stackNoTrimWhitespace.pop();
+        if (removeClosedTag(stackNoTrimWhitespace, tag, lowerTag)) {
+          const tagLower = lowerTag || tag;
+          if (tagLower === 'pre') preDepth--;
           closesNoTrim = !stackNoTrimWhitespace.length;
         }
       } else if (options.collapseWhitespace) {
-        squashTrailingWhitespace('/' + tag);
+        squashTrailingWhitespace('/' + (lowerTag || tag));
       }
-      if (transparentDepth && inlineElementsTransparent.has(tag)) {
+      if (transparentDepth && inlineElementsTransparent.has(lowerTag || tag)) {
         transparentDepth--;
       }
       let closesNoCollapse = false;
-      if (stackNoCollapseWhitespace.length &&
-          tag === stackNoCollapseWhitespace[stackNoCollapseWhitespace.length - 1]) {
-        stackNoCollapseWhitespace.pop();
+      if (stackNoCollapseWhitespace.length && removeClosedTag(stackNoCollapseWhitespace, tag, lowerTag)) {
         closesNoCollapse = !stackNoCollapseWhitespace.length;
       }
 
@@ -2530,6 +2587,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 = '';
@@ -2537,7 +2595,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;
 
@@ -2545,6 +2615,7 @@ 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
@@ -2563,7 +2634,7 @@ 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))) {
+          !(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) }));
@@ -2571,11 +2642,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) {
@@ -2584,9 +2681,9 @@ async function minifyHTML(value, options, partialMarkup) {
             bufferPush(endTagText, true);
           }
           charsPrevTag = '/' + tag;
-          if (!inlineElements.has(tag)) {
+          if (!inlineElements.has(lowerTag || tag)) {
             currentChars = '';
-          } else if (isElementEmpty) {
+          } else if (isElementEmpty || !inlineTextSet.has(lowerTag || tag)) {
             currentChars += '|';
           }
         }
@@ -2597,13 +2694,22 @@ async function minifyHTML(value, options, partialMarkup) {
           bufferPush(endTagText, true);
         }
         charsPrevTag = '/' + tag;
-        if (!inlineElements.has(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;
       }
@@ -2701,12 +2807,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);
     }
   });