html-minifier 5.0.1 → 5.0.3

package/src/lib/attributes.js

@@ -7,6 +7,7 @@ import {
   RE_CAN_REMOVE_ATTR_QUOTES,
   RE_AMP_REFERENCE_ATTR,
   RE_CR,
+  RE_ATTR_SELECTOR,
   RE_BASE_ELEMENT,
   RE_ATTR_WS_CHECK,
   RE_ATTR_WS_COLLAPSE,
@@ -29,7 +30,8 @@ import {
   collapsibleValues,
   srcsetElements,
   RE_EMPTY_ATTRIBUTE,
-  RE_STYLE_ELEMENT
+  RE_STYLE_ELEMENT,
+  RE_STYLE_TAG
 } from './constants.js';
 import { trimWhitespace, collapseWhitespaceAll } from './whitespace.js';
 import { shouldMinifyInnerHTML } from './options.js';
@@ -197,6 +199,54 @@ function isTargetSelfRedundant(attrValue, options) {
   return !state || !(state.hasBase ??= RE_BASE_ELEMENT.test(state.source));
 }
 
+/**
+ * The attribute names `style` elements in `source` select on, in lowercase
+ * @param {string} source
+ * @returns {Set<string>}
+ */
+function findSelectedAttributes(source) {
+  /** @type {Set<string>} */
+  const names = new Set();
+  if (!RE_STYLE_ELEMENT.test(source)) {
+    return names;
+  }
+  const addSelected = (/** @type {number} */ start, /** @type {number} */ end) => {
+    for (const selector of source.slice(start, end).toLowerCase().matchAll(RE_ATTR_SELECTOR)) {
+      names.add(/** @type {string} */ (selector[1]));
+    }
+  };
+  // Scanned rather than matched, as a lazy pattern is quadratic on `style` tags left open
+  let start = -1;
+  RE_STYLE_TAG.lastIndex = 0;
+  for (let match = RE_STYLE_TAG.exec(source); match; match = RE_STYLE_TAG.exec(source)) {
+    if (match[0][1] !== '/') {
+      if (start === -1) start = match.index;
+    } else if (start !== -1) {
+      addSelected(start, match.index);
+      start = -1;
+    }
+  }
+  // Browsers apply a `style` element the document ends in, but not one that is script text,
+  // with a script’s end tag after it (without, `<script` before it is text of some other kind)
+  if (start !== -1) {
+    const before = source.slice(0, start).toLowerCase();
+    if (before.lastIndexOf('<script') <= before.lastIndexOf('</script') || !source.slice(start).toLowerCase().includes('</script')) {
+      addSelected(start, source.length);
+    }
+  }
+  return names;
+}
+
+/**
+ * Whether a style sheet of the document selects on the attribute, which removing it would break
+ * @param {string} attrName
+ * @param {ProcessedOptions} options
+ */
+function isAttributeSelected(attrName, options) {
+  const state = options.baseState;
+  return state !== undefined && (state.selectedAttrs ??= findSelectedAttributes(state.source)).has(attrName.toLowerCase());
+}
+
 /**
  * @param {string} tag - In lowercase
  * @param {string} attrName - In lowercase
@@ -268,7 +318,18 @@ function isAttributeRedundant(tag, attrName, attrValue, attrs, options) {
     : undefined;
   const tagDefault = tagAttrDefaults && Object.hasOwn(tagAttrDefaults, attrName) ? tagAttrDefaults[attrName] : undefined;
 
-  const isLegacyAttr = (tag === 'script' && (attrName === 'language' || attrName === 'charset')) || (tag === 'a' && attrName === 'name');
+  // As written, for browsers match fragments case-sensitively and without trimming
+  if (tag === 'a' && attrName === 'name') {
+    const id = attrs.find(attr => attr.name.toLowerCase() === 'id');
+    const idValue = id?.value ?? '';
+    // With `decodeEntities`, the name is decoded by now, the ID isn’t
+    if (id === undefined || (options.decodeEntities && idValue.indexOf('&') !== -1)) {
+      return false;
+    }
+    return options.collapseAttributeWhitespace ? collapseAttributeValue(idValue) === collapseAttributeValue(attrValue) : idValue === attrValue;
+  }
+
+  const isLegacyAttr = tag === 'script' && (attrName === 'language' || attrName === 'charset');
 
   // Without a default for this very attribute, nor a legacy rule, the value cannot be redundant
   if (generalDefault === undefined && tagDefault === undefined && !isLegacyAttr) {
@@ -284,9 +345,6 @@ function isAttributeRedundant(tag, attrName, attrValue, attrs, options) {
   if (tag === 'script' && attrName === 'charset' && !attributesInclude(attrs, 'src')) {
     return true;
   }
-  if (tag === 'a' && attrName === 'name' && attributesInclude(attrs, 'id')) {
-    return true;
-  }
   if (tag === 'ol' && attrName === 'start' && attributesInclude(attrs, 'reversed')) {
     return false;
   }
@@ -342,21 +400,42 @@ function isStyleElement(tag, attrs) {
 }
 
 /**
- * Whether an attribute collapses to its name; takes name and value as written, lower-casing
- * the value only for the few names that depend on it
+ * Whether an attribute collapses to its name; lower-cases the value only for the few names
+ * that depend on it
  *
- * @param {string} attrName
+ * @param {string} name - In lowercase
  * @param {string} attrValue
+ * @param {string} tag
+ * @param {string[]} markers - What custom fragment and `htmlmin:ignore` placeholders hold
  */
-function collapsesToBooleanName(attrName, attrValue) {
-  const name = attrName.toLowerCase();
-  if (isSimpleBoolean.has(name)) {
+function collapsesToBooleanName(name, attrValue, tag, markers) {
+  const simple = isSimpleBoolean.has(name);
+  if (!simple && name !== 'hidden' && name !== 'draggable' && !collapsibleValues.has(name)) {
+    return false;
+  }
+  // Custom elements define what their attributes mean, and `marquee` counts its loops
+  if (tag.includes('-') || (name === 'loop' && tag.toLowerCase() === 'marquee')) {
+    return false;
+  }
+  // Template code and ignored markup are not the minifier’s to remove
+  if (markers.some(marker => attrValue.indexOf(marker) !== -1)) {
+    return false;
+  }
+  if (simple) {
     return true;
   }
   const values = collapsibleValues.get(name);
   if (values) {
     return values.has(attrValue.toLowerCase());
   }
+  // What a reference decodes to, the value as written doesn’t show
+  if ((name === 'hidden' || name === 'draggable') && attrValue.indexOf('&') !== -1) {
+    return false;
+  }
+  // Any other value means the hidden state, which the bare attribute does, too
+  if (name === 'hidden') {
+    return attrValue.toLowerCase() !== 'until-found';
+  }
   return name === 'draggable' && !isBooleanValue.has(attrValue.toLowerCase());
 }
 
@@ -637,6 +716,15 @@ const collapseAttributeWhitespaceExempt = new Set(['pattern', 'placeholder', 'ti
 // `value` whitespace matters only on form-submission and machine-readable elements
 const valueWhitespaceExemptElements = new Set(['button', 'data', 'input', 'option', 'param']);
 
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function collapseAttributeValue(value) {
+  // Fast path: Only process if whitespace exists (avoids regex overhead on clean values)
+  return RE_ATTR_WS_CHECK.test(value) ? trimWhitespace(value).replace(RE_ATTR_WS_COLLAPSE, ' ') : value;
+}
+
 /**
  * Drop repeated names from a whitespace-separated class list, keeping the first of each.
  * @param {string} value
@@ -669,10 +757,7 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTM
   // Special spaces (no-break space, hair space, etc.) stay, for consistency
   // with `collapseWhitespace`
   if (options.collapseAttributeWhitespace && !collapseAttributeWhitespaceExempt.has(attrName) && !(attrName === 'value' && valueWhitespaceExemptElements.has(tag)) && !isEventAttr) {
-    // Fast path: Only process if whitespace exists (avoids regex overhead on clean values)
-    if (RE_ATTR_WS_CHECK.test(attrValue)) {
-      attrValue = trimWhitespace(attrValue).replace(RE_ATTR_WS_COLLAPSE, ' ');
-    }
+    attrValue = collapseAttributeValue(attrValue);
   }
 
   if (isEventAttr) {
@@ -995,12 +1080,12 @@ function normalizeAttr(attr, attrs, tag, tagOut, options, minifyHTML, markers) {
  * @param {string[]} [markers] - What custom fragment and `htmlmin:ignore` placeholders hold
  */
 function normalizeAttrContinue(attrName, attrNameOut, attrValue, attr, attrs, tag, tagOut, options, minifyHTML, markers) {
-  if ((options.removeRedundantAttributes &&
+  if (((options.removeRedundantAttributes &&
        isAttributeRedundant(tag, attrName, attrValue ?? '', attrs, options)) ||
       (options.removeDefaultTypeAttributes && attrName === 'type' && (
         ((tag === 'style' || tag === 'link') && isStyleLinkTypeAttribute(attrValue)) ||
         (tag === 'script' && isScriptTypeAttribute(attrValue) && !keepScriptTypeAttribute(attrValue))
-      ))) {
+      ))) && !isAttributeSelected(attrName, options)) {
     return;
   }
 
@@ -1027,7 +1112,8 @@ function normalizeAttrContinue(attrName, attrNameOut, attrValue, attr, attrs, ta
  */
 function normalizeAttrFinish(attrName, attrNameOut, attrValue, attr, tag, tagOut, options) {
   if (options.removeEmptyAttributes &&
-      canDeleteEmptyAttribute(tag, attrName, attrValue, options, tagOut, attrNameOut)) {
+      canDeleteEmptyAttribute(tag, attrName, attrValue, options, tagOut, attrNameOut) &&
+      !isAttributeSelected(attrName, options)) {
     return;
   }
 
@@ -1051,12 +1137,14 @@ function normalizeAttrFinish(attrName, attrNameOut, attrValue, attr, tag, tagOut
 
 /**
  * @param {{name: string, value: string | undefined, attr: HTMLAttribute}} normalized
+ * @param {string} tag
  * @param {string | boolean | undefined} hasUnarySlash
  * @param {ProcessedOptions} options
  * @param {boolean} isLast
  * @param {string | undefined} uidAttr
+ * @param {string[]} markers - What custom fragment and `htmlmin:ignore` placeholders hold
  */
-function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
+function buildAttr(normalized, tag, hasUnarySlash, options, isLast, uidAttr, markers) {
   const attrName = normalized.name;
   let attrValue = normalized.value;
   const attr = normalized.attr;
@@ -1070,7 +1158,7 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
 
   // An attribute written as its name alone skips the quoting work below
   if (typeof attrValue === 'undefined' ||
-      (options.collapseBooleanAttributes && collapsesToBooleanName(attrName, attrValue ?? '')) ||
+      (options.collapseBooleanAttributes && !options.insideForeignContent && collapsesToBooleanName(options.namesAsWritten ? attrName.toLowerCase() : attrName, attrValue ?? '', tag, markers)) ||
       (options.collapseEmptyAttributes && attrValue === '' && (attr.customAssign ?? '=') === '=')) {
     return attr.customOpen + attrName + (isLast ? '' : ' ') + attr.customClose;
   }

package/src/lib/constants.js

@@ -48,10 +48,17 @@ const RE_HTML_ENCODING = /^(text\/html|application\/xhtml\+xml)$/i;
 // identifier precedes it, anything but `>` sets quirks mode
 // https://html.spec.whatwg.org/multipage/parsing.html#doctype-state
 const RE_DOCTYPE = /^<!doctype[ \n\r\t\f]*([^ \n\r\t\f>]+)[ \n\r\t\f]*(?:public[ \n\r\t\f]*("[^">]*"|'[^'>]*')[ \n\r\t\f]*("[^">]*"|'[^'>]*')?|system[ \n\r\t\f]*("[^">]*"|'[^'>]*'))?([^]*)$/i;
+// A doctype’s quoted identifiers (captured) and what lies between them
+const RE_DOCTYPE_SEGMENT = /("[^"]*(?:"|$)|'[^']*(?:'|$))|[^"']+/g;
 const RE_ATTR_WS_CHECK = /[ \n\r\t\f]/;
 const RE_ATTR_WS_COLLAPSE = /[ \n\r\t\f]+/g;
 const RE_WS_CHAR = /\s/;
 const RE_STYLE_ELEMENT = /<style[\s/>]/i;
+const RE_STYLE_TAG = /<\/?style/gi;
+// Text that a space after would collapse into (a no-break space does not take it in)
+const RE_ENDS_COLLAPSIBLE = /(?:^|[ \n\r\t\f])$/;
+// An attribute selector’s name, namespace prefix aside, in lowercased CSS
+const RE_ATTR_SELECTOR = /\[\s*(?:[\w-]*\|)?([\w:-]+)\s*[\]=~|^$*]/g;
 const RE_EMPTY_ATTRIBUTE = new RegExp(
   '^(?:class|id|style|title|lang|dir|on(?:focus|blur|change|click|dblclick|mouse(' +
   '?:down|up|over|move|out)|key(?:press|down|up)))$');
@@ -59,14 +66,14 @@ const RE_EMPTY_ATTRIBUTE = new RegExp(
 // Inline element sets for whitespace handling
 
 // Non-empty elements that will maintain whitespace around them
-const inlineElementsToKeepWhitespaceAround = new Set(['a', 'abbr', 'acronym', 'audio', 'b', 'bdi', 'bdo', 'big', 'button', 'canvas', 'cite', 'code', 'data', 'del', 'dfn', 'em', 'embed', 'font', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'label', 'map', 'mark', 'math', 'meter', 'nobr', 'object', 'output', 'picture', 'progress', 'q', 'rb', 'rp', 'rt', 'rtc', 'ruby', 's', 'samp', 'select', 'selectedcontent', 'slot', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'svg', 'textarea', 'time', 'tt', 'u', 'var', 'video', 'wbr']);
+const inlineElementsToKeepWhitespaceAround = new Set(['a', 'abbr', 'acronym', 'audio', 'b', 'bdi', 'bdo', 'big', 'button', 'canvas', 'cite', 'code', 'data', 'del', 'dfn', 'em', 'embed', 'font', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'label', 'map', 'mark', 'math', 'meter', 'nobr', 'object', 'output', 'picture', 'progress', 'q', 'rb', 'rp', 'rt', 'rtc', 'ruby', 's', 'samp', 'select', 'selectedcontent', 'slot', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'svg', 'textarea', 'textpath', 'time', 'tspan', 'tt', 'u', 'var', 'video', 'wbr']);
 
 // Non-empty elements that will maintain whitespace within them
-const inlineElementsToKeepWhitespaceWithin = new Set(['a', 'abbr', 'acronym', 'b', 'big', 'data', 'del', 'em', 'font', 'i', 'ins', 'kbd', 'map', 'mark', 'nobr', 's', 'samp', 'slot', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'time', 'tt', 'u', 'var']);
+const inlineElementsToKeepWhitespaceWithin = new Set(['a', 'abbr', 'acronym', 'b', 'bdi', 'bdo', 'big', 'cite', 'code', 'data', 'del', 'dfn', 'em', 'font', 'i', 'ins', 'kbd', 'label', 'map', 'mark', 'nobr', 'q', 'ruby', 's', 'samp', 'slot', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'textpath', 'time', 'tspan', 'tt', 'u', 'var']);
 
 // Text-level elements that keep whitespace between them and other elements under
 // `collapseInlineTagWhitespace`
-const inlineElementsToKeepWhitespaceBetween = new Set([...inlineElementsToKeepWhitespaceWithin, 'bdi', 'bdo', 'cite', 'code', 'dfn', 'label', 'math', 'q', 'ruby']);
+const inlineElementsToKeepWhitespaceBetween = new Set([...inlineElementsToKeepWhitespaceWithin, 'math']);
 
 // Phrasing elements that don’t render, whose neighbors decide on the whitespace around them
 const inlineElementsTransparent = new Set(['area', 'datalist', 'link', 'meta', 'noscript', 'script', 'style', 'template']);
@@ -259,7 +266,7 @@ const keepScriptsMimetypes = new Set([
 
 // Boolean attribute sets
 
-const isSimpleBoolean = new Set(['allowfullscreen', 'async', 'autofocus', 'autoplay', 'checked', 'compact', 'controls', 'declare', 'default', 'defaultchecked', 'defaultmuted', 'defaultselected', 'defer', 'disabled', 'enabled', 'formnovalidate', 'hidden', 'indeterminate', 'inert', 'ismap', 'itemscope', 'loop', 'multiple', 'muted', 'nohref', 'noresize', 'noshade', 'novalidate', 'nowrap', 'open', 'pauseonexit', 'readonly', 'required', 'reversed', 'scoped', 'seamless', 'selected', 'sortable', 'truespeed', 'typemustmatch', 'visible']);
+const isSimpleBoolean = new Set(['allowfullscreen', 'alpha', 'async', 'autofocus', 'autoplay', 'checked', 'compact', 'controls', 'declare', 'default', 'defer', 'disabled', 'formnovalidate', 'headingreset', 'inert', 'ismap', 'itemscope', 'loop', 'multiple', 'muted', 'nohref', 'nomodule', 'noresize', 'noshade', 'novalidate', 'nowrap', 'open', 'playsinline', 'readonly', 'required', 'reversed', 'scoped', 'seamless', 'selected', 'shadowrootclonable', 'shadowrootcustomelementregistry', 'shadowrootdelegatesfocus', 'shadowrootserializable', 'sortable', 'truespeed', 'typemustmatch']);
 
 const isBooleanValue = new Set(['true', 'false']);
 
@@ -296,7 +303,7 @@ const optionalStartTags = new Set(['html', 'head', 'body', 'colgroup', 'tbody'])
 
 const optionalEndTags = new Set(['html', 'head', 'body', 'li', 'dt', 'dd', 'p', 'rb', 'rt', 'rtc', 'rp', 'optgroup', 'option', 'colgroup', 'caption', 'thead', 'tbody', 'tfoot', 'tr', 'td', 'th']);
 
-const headerElements = new Set(['meta', 'link', 'script', 'style', 'template', 'noscript']);
+const headerElements = new Set(['base', 'basefont', 'bgsound', 'link', 'meta', 'noframes', 'noscript', 'script', 'style', 'template', 'title']);
 
 const descriptionElements = new Set(['dt', 'dd']);
 
@@ -432,16 +439,20 @@ export {
   RE_LINE_BREAK_CR,
   RE_LEGACY_ENTITIES,
   RE_ESCAPE_LT,
+  RE_ATTR_SELECTOR,
+  RE_ENDS_COLLAPSIBLE,
   RE_BASE_ELEMENT,
   RE_ESCAPE_LT_RAW_TEXT,
   RE_XML_ESCAPE_TEXT,
   RE_XML_ESCAPE_ATTR,
   RE_HTML_ENCODING,
   RE_DOCTYPE,
+  RE_DOCTYPE_SEGMENT,
   RE_ATTR_WS_CHECK,
   RE_ATTR_WS_COLLAPSE,
   RE_WS_CHAR,
   RE_STYLE_ELEMENT,
+  RE_STYLE_TAG,
   RE_EMPTY_ATTRIBUTE,
 
   // Inline element sets

package/src/lib/elements.js

@@ -124,9 +124,16 @@ function canRemoveElement(tag, attrs) {
   }
 
   switch (tag) {
+    // Without a `frameset`, browsers render what follows it
     case 'canvas':
+    case 'frameset':
     case 'textarea':
       return false;
+    // Browsers create them anyway, but not with their attributes
+    case 'body':
+    case 'head':
+    case 'html':
+      return attrs.length === 0;
     case 'audio':
     case 'script':
     case 'video':

package/src/lib/fragments.js

@@ -11,6 +11,19 @@
  */
 
 const RE_WHITESPACE = /\s/;
+const RE_NAME_CHAR = /[\w$-]/;
+
+// Run on at most the eight characters ending in the word
+const RE_BLOCK_KEYWORD = /(?:^|[^\w$.])(?:do|else|finally|try)$/;
+
+// The last character before a `/` that starts a regular expression, not a division
+const RE_BEFORE_REGEX = /[(,=:[!&|?{};+*%<>~^}-]/;
+
+// Run on at most the eleven characters ending in the word
+const RE_BEFORE_REGEX_KEYWORD = /(?:^|[^\w$.])(?:await|case|delete|do|else|in|instanceof|new|of|return|throw|typeof|void|yield)$/;
+
+// Run on at most the eleven characters from the `@`
+const RE_DROPPABLE_AT_RULE = /^@(?:charset|import|namespace)(?![\w-])/i;
 
 // Any-character and negated-class bodies; without the `s` flag, `.` is itself a
 // negated class, excluding line terminators
@@ -333,8 +346,268 @@ function replaceCustomFragments(value, fragments, replacer) {
   return copied === 0 ? value : out + value.slice(copied);
 }
 
+/**
+ * Index past the regular expression starting at the `/` at an index
+ * @param {string} source
+ * @param {number} index
+ * @returns {number} The index itself when the line ends before the expression does
+ */
+function skipRegex(source, index) {
+  let inClass = false;
+  for (let position = index + 1; position < source.length; position++) {
+    const current = source[position];
+    if (current === '\n' || current === '\r') return index;
+    if (current === '\\') position++;
+    else if (current === '[') inClass = true;
+    else if (current === ']') inClass = false;
+    else if (current === '/' && !inClass) return position + 1;
+  }
+  return index;
+}
+
+/**
+ * Index past the comment, string, or regular expression starting at an index
+ * @param {string} source
+ * @param {number} index
+ * @param {boolean} isJS
+ * @returns {number} The index itself when none starts there
+ */
+function skipCommentOrString(source, index, isJS) {
+  const char = source[index];
+  const next = source[index + 1];
+
+  if (char === '/' && next === '*') {
+    const end = source.indexOf('*/', index + 2);
+    return end === -1 ? source.length : end + 2;
+  }
+  if (isJS && char === '/' && next === '/') {
+    const end = source.indexOf('\n', index + 2);
+    return end === -1 ? source.length : end;
+  }
+  if (isJS && char === '/') return isRegexStart(source, index) ? skipRegex(source, index) : index;
+  if (char !== '"' && char !== '\'' && !(isJS && char === '`')) return index;
+
+  for (let position = index + 1; position < source.length; position++) {
+    const current = source[position];
+    if (current === '\\') position++;
+    else if (current === char) return position + 1;
+    else if (current === '\n' && char !== '`') return position;
+  }
+  return source.length;
+}
+
+/**
+ * Index of the last non-whitespace character before an index
+ * @param {string} source
+ * @param {number} index
+ * @returns {number} -1 when there is none
+ */
+function findPreviousToken(source, index) {
+  let position = index - 1;
+  while (position >= 0 && RE_WHITESPACE.test(source[position] ?? '')) position--;
+  return position;
+}
+
+/**
+ * Whether a `/` starts a regular expression rather than a division, going by what precedes
+ * it; after a `)`, which `if (a) /b/.test(c)` leaves open, it’s read as a division
+ * @param {string} source
+ * @param {number} slash
+ * @returns {boolean}
+ */
+function isRegexStart(source, slash) {
+  const before = findPreviousToken(source, slash);
+  if (before === -1) return true;
+
+  const char = source[before] ?? '';
+  // `++` and `--` can only end an operand here, as a literal cannot be incremented
+  if ((char === '+' || char === '-') && source[before - 1] === char) return false;
+  return RE_BEFORE_REGEX.test(char) || RE_BEFORE_REGEX_KEYWORD.test(source.slice(Math.max(before - 10, 0), before + 1));
+}
+
+/**
+ * Whether a block keyword ends at an index
+ * @param {string} source
+ * @param {number} index
+ * @returns {boolean}
+ */
+function isBlockKeywordEnd(source, index) {
+  return RE_BLOCK_KEYWORD.test(source.slice(Math.max(index - 7, 0), index + 1));
+}
+
+/**
+ * Whether a `{` opens a block rather than an object literal
+ * @param {string} source
+ * @param {number} brace
+ * @returns {boolean}
+ */
+function isBlockBrace(source, brace) {
+  const before = findPreviousToken(source, brace);
+  if (before === -1) return true;
+
+  const char = source[before] ?? '';
+  if (char === ';' || char === '{' || char === '}' || char === ')') return true;
+  if (char === '>') return source[before - 1] === '=';
+  return isBlockKeywordEnd(source, before);
+}
+
+/**
+ * Whether a colon ends a statement label or `default`, going by what precedes the name.
+ * Two expressions cannot follow each other, so a name after one of these tokens cannot
+ * be the middle of a ternary
+ * @param {string} source
+ * @param {number} colon
+ * @returns {boolean}
+ */
+function isLabelColon(source, colon) {
+  const end = findPreviousToken(source, colon);
+  let start = end;
+  while (start >= 0 && RE_NAME_CHAR.test(source[start] ?? '')) start--;
+  if (start === end) return false;
+
+  const before = findPreviousToken(source, start + 1);
+  const char = source[before];
+  // After `:`, any other name may be a nested ternary’s branch
+  if (char === ':') return source.slice(start + 1, end + 1) === 'default';
+  return before === -1 || char === ';' || char === '}' || char === ')' || (char === '{' && isBlockBrace(source, before));
+}
+
+/**
+ * Whether the `case` keyword starts at an index, rather than a name or property holding it
+ * @param {string} source
+ * @param {number} index
+ * @returns {boolean}
+ */
+function isCaseKeyword(source, index) {
+  if (!source.startsWith('case', index) || RE_NAME_CHAR.test(source[index + 4] ?? '')) return false;
+
+  const before = source[index - 1] ?? '';
+  if (before === '.' || RE_NAME_CHAR.test(before)) return false;
+
+  let after = index + 4;
+  while (RE_WHITESPACE.test(source[after] ?? '')) after++;
+  return source[after] !== ':';
+}
+
+/**
+ * Indexes of the colons after which a JavaScript statement starts
+ * @param {string} source
+ * @returns {Set<number>}
+ */
+function findStatementColons(source) {
+  const colons = new Set();
+  // Unpaired `?` in the current `case` expression, -1 outside of one
+  let ternaries = -1;
+
+  for (let i = 0; i < source.length; i++) {
+    const end = skipCommentOrString(source, i, true);
+    if (end > i) {
+      i = end - 1;
+      continue;
+    }
+
+    const char = source[i];
+    if (ternaries === -1) {
+      if (char === ':') {
+        if (isLabelColon(source, i)) colons.add(i);
+      } else if (char === 'c' && isCaseKeyword(source, i)) {
+        ternaries = 0;
+        i += 3;
+      }
+    } else if (char === '?') {
+      // `?.` and `??` have no `:` to pair with
+      if (source[i + 1] === '.' || source[i + 1] === '?') i++;
+      else ternaries++;
+    } else if (char === ':') {
+      if (ternaries === 0) colons.add(i);
+      ternaries--;
+    } else if (char === ';' || char === '{' || char === '}') {
+      ternaries = -1;
+    }
+  }
+
+  return colons;
+}
+
+/**
+ * Placeholders within `@charset`, `@import`, and `@namespace` statements, which
+ * Lightning CSS drops whole where it cannot read them, and `@charset` always
+ * @param {string} source
+ * @param {RegExp} placeholder
+ * @returns {string[]}
+ */
+function findDroppableAtRulePlaceholders(source, placeholder) {
+  const tokens = [];
+  let start = -1;
+
+  for (let i = 0; i <= source.length; i++) {
+    const end = skipCommentOrString(source, i, false);
+    if (end > i) {
+      i = end - 1;
+      continue;
+    }
+
+    const char = source[i];
+    if (start === -1) {
+      if (char === '@' && RE_DROPPABLE_AT_RULE.test(source.slice(i, i + 11))) start = i;
+    } else if (char === ';' || char === '{' || char === '}' || char === undefined) {
+      for (const match of source.slice(start, i).matchAll(placeholder)) tokens.push(match[0]);
+      start = -1;
+    }
+  }
+
+  return tokens;
+}
+
+/**
+ * Whether what comes before an index allows a statement or rule to start there
+ * @param {string} source
+ * @param {number} index
+ * @param {Set<number>} colons - Colons after which a statement starts
+ * @param {boolean} isJS
+ * @returns {boolean}
+ */
+function isCodeStart(source, index, colons, isJS) {
+  let position = index;
+  while (position > 0) {
+    const char = source[--position] ?? '';
+    if (char === '\n' || char === '\r' || char === ';' || char === '{' || char === '}') return true;
+    if (!RE_WHITESPACE.test(char)) {
+      return char === ')' || (char === '/' && source[position - 1] === '*') || colons.has(position) || (isJS && isBlockKeywordEnd(source, position));
+    }
+  }
+  return true;
+}
+
+/**
+ * Whether minified CSS or JavaScript can stand in for its source. A fragment starting a
+ * statement or rule can render as anything, or as nothing, while engines read it as an
+ * identifier or selector and join it with the code around it, or drop it; a fragment in
+ * an at-rule Lightning CSS cannot read would go with that at-rule
+ * @param {string} source
+ * @param {unknown} output - Anything but a string, from a minifier of one’s own, passes
+ * @param {RegExp} placeholder - Global pattern matching one fragment placeholder
+ * @param {boolean} [isJS] - Whether the code is JavaScript rather than CSS
+ * @returns {boolean}
+ */
+function isMinifiedCodeSafe(source, output, placeholder, isJS = false) {
+  if (typeof output !== 'string' || output === source) return true;
+
+  const matches = [...source.matchAll(placeholder)];
+  if (!matches.length) return true;
+
+  const colons = isJS ? findStatementColons(source) : new Set();
+  const starts = matches.filter(match => isCodeStart(source, match.index, colons, isJS));
+  const kept = new Set(Array.from(output.matchAll(placeholder), match => match[0]));
+
+  // Output of nothing but fragments only holds up where no label or `case` went with the code
+  if (starts.length && (colons.size || output.replace(placeholder, '').trim() || !starts.every(match => kept.has(match[0])))) return false;
+  return isJS || !source.includes('@') || findDroppableAtRulePlaceholders(source, placeholder).every(token => kept.has(token));
+}
+
 export {
   toDelimitedFragment,
   toFragment,
-  replaceCustomFragments
+  replaceCustomFragments,
+  isMinifiedCodeSafe
 };

package/src/lib/options.js

@@ -51,7 +51,7 @@ import { optionDefinitions, optionDefaults } from './option-definitions.js';
  *   removeUnusedCSS: {safelist: Array<string | RegExp>, scripts: boolean} | null,
  *   cssContext?: CSSContext,
  *   documentState?: {hasMathML: boolean},
- *   baseState?: {hasBase: boolean | undefined, source: string},
+ *   baseState?: {hasBase: boolean | undefined, selectedAttrs?: Set<string>, source: string},
  *   parallelJS?: boolean,
  *   nameParent?: (name: string) => string,
  *   namesAsWritten?: boolean,
@@ -519,14 +519,15 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
             const outputCSS = unwrapCSS(result.code.toString(), type);
 
             // Where Lightning CSS emptied template syntax (`<?php ?>`, `{{ }}`: `<` or `>` without
-            // `CDATA`) or custom-fragment UIDs (long lowercase alphanumeric runs), keep the
-            // original; CDATA sections, entities, and other invalid CSS may go
+            // `CDATA`), custom-fragment UIDs (long lowercase alphanumeric runs), or a media query
+            // (an invalid one matches nothing, an empty one everything), keep the original;
+            // CDATA sections, entities, and other invalid CSS may go
             const isCDATA = text.includes('<![CDATA[');
             const uidPattern = /[a-z0-9]{10,}/; // UIDs are long alphanumeric strings
             const hasUID = uidPattern.test(text) && !isCDATA; // Exclude CDATA from UID detection
             const looksLikeTemplate = (text.includes('<') || text.includes('>')) && !isCDATA;
 
-            const css = (text.trim() && !outputCSS.trim() && (looksLikeTemplate || hasUID)) ? text : outputCSS;
+            const css = (text.trim() && !outputCSS.trim() && (type === 'media' || looksLikeTemplate || hasUID)) ? text : outputCSS;
             return /** @type {CSSResult} */ ({ css, warnings });
           });
           report(resolved.warnings);