html-minifier 5.0.2 → 5.0.4

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;
   }
@@ -639,6 +697,32 @@ function canDeleteEmptyAttribute(tag, attrName, attrValue, options, tagOut = tag
   return (tag === 'input' && attrName === 'value') || RE_EMPTY_ATTRIBUTE.test(attrName);
 }
 
+/**
+ * The name to write and to hand to hooks: as in the source for HTML names under
+ * `caseSensitive`, as named otherwise (foreign names are named as written anyway)
+ * @param {HTMLAttribute} attr
+ * @param {string} attrName
+ * @param {ProcessedOptions} options
+ */
+function nameAttrOut(attr, attrName, options) {
+  return options.namesAsWritten && options.name === lowercase ? attr.name : attrName;
+}
+
+/**
+ * Whether `removeEmptyAttributes` removes the attribute
+ * @param {string} tag
+ * @param {string} attrName
+ * @param {string | undefined} attrValue
+ * @param {ProcessedOptions} options
+ * @param {string} [tagOut]
+ * @param {string} [attrNameOut]
+ */
+function removesEmptyAttribute(tag, attrName, attrValue, options, tagOut = tag, attrNameOut = attrName) {
+  return Boolean(options.removeEmptyAttributes) &&
+    canDeleteEmptyAttribute(tag, attrName, attrValue, options, tagOut, attrNameOut) &&
+    !isAttributeSelected(attrName, options);
+}
+
 /**
  * @param {string} name
  * @param {HTMLAttribute[]} attrs
@@ -658,6 +742,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
@@ -688,12 +781,10 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTM
   const isEventAttr = isEventAttribute(attrName, options, attrNameOut);
 
   // 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, ' ');
-    }
+  // with `collapseWhitespace`; an `annotation-xml` encoding is matched as written,
+  // and with spaces taken out could make the element hold HTML
+  if (options.collapseAttributeWhitespace && !collapseAttributeWhitespaceExempt.has(attrName) && !(attrName === 'value' && valueWhitespaceExemptElements.has(tag)) && !(attrName.toLowerCase() === 'encoding' && tag.toLowerCase() === 'annotation-xml') && !isEventAttr) {
+    attrValue = collapseAttributeValue(attrValue);
   }
 
   if (isEventAttr) {
@@ -984,9 +1075,7 @@ function chooseAttributeQuote(attrValue, options) {
  */
 function normalizeAttr(attr, attrs, tag, tagOut, options, minifyHTML, markers) {
   const attrName = options.name(attr.name);
-  // The name to write and to hand to hooks: as in the source for HTML names
-  // under `caseSensitive`, as named otherwise (foreign names are named as written anyway)
-  const attrNameOut = options.namesAsWritten && options.name === lowercase ? attr.name : attrName;
+  const attrNameOut = nameAttrOut(attr, attrName, options);
   const attrValue = attr.value;
 
   // Entity decoding requires a lazy import—async only while that import is unresolved
@@ -1016,12 +1105,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;
   }
 
@@ -1047,8 +1136,7 @@ function normalizeAttrContinue(attrName, attrNameOut, attrValue, attr, attrs, ta
  * @param {ProcessedOptions} options
  */
 function normalizeAttrFinish(attrName, attrNameOut, attrValue, attr, tag, tagOut, options) {
-  if (options.removeEmptyAttributes &&
-      canDeleteEmptyAttribute(tag, attrName, attrValue, options, tagOut, attrNameOut)) {
+  if (removesEmptyAttribute(tag, attrName, attrValue, options, tagOut, attrNameOut)) {
     return;
   }
 
@@ -1210,6 +1298,8 @@ export {
   isStyleElement,
   isMetaWithoutEffect,
   hasAttrName,
+  nameAttrOut,
+  removesEmptyAttribute,
 
   // Cleaners
   normalizeAttr,

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', 'textpath', 'time', 'tspan', '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', 'marquee', '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', 'textpath', 'time', 'tspan', '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']);
@@ -296,13 +303,14 @@ 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']);
 
 const pBlockElements = new Set(['address', 'article', 'aside', 'blockquote', 'details', 'dialog', 'div', 'dl', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hgroup', 'hr', 'main', 'menu', 'nav', 'ol', 'p', 'pre', 'search', 'section', 'table', 'ul']);
 
-// Elements whose end tags close an open `p` in browsers, so that `</p>` may be omitted before them
+// Elements whose end tags close an open `p`, `li`, `dd`, or `dt` in browsers,
+// so that its end tag may be omitted before them
 const pClosingParents = new Set(['address', 'applet', 'article', 'aside', 'blockquote', 'body', 'button', 'caption', 'center', 'dd', 'details', 'dialog', 'dir', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hgroup', 'html', 'li', 'listing', 'main', 'marquee', 'menu', 'nav', 'object', 'ol', 'pre', 'search', 'section', 'summary', 'td', 'template', 'th', 'ul']);
 
 const rubyEndTagOmission = new Set(['rb', 'rt', 'rtc', 'rp']); // `</rb>`, `</rt>`, `</rp>` can be omitted if followed by `<rb>`, `<rt>`, `<rtc>`, or `<rp>`
@@ -325,6 +333,9 @@ const looseElements = new Set(['head', 'colgroup', 'caption']);
 
 const trailingElements = new Set(['dt', 'thead']);
 
+// Special elements with optional end tags, which only `pClosingParents` end tags close
+const specialOptionalEndTags = new Set(['p', 'li', 'dd', 'dt']);
+
 const htmlElements = new Set(['a', 'abbr', 'acronym', 'address', 'applet', 'area', 'article', 'aside', 'audio', 'b', 'base', 'basefont', 'bdi', 'bdo', 'bgsound', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'command', 'content', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'image', 'img', 'input', 'ins', 'isindex', 'kbd', 'keygen', 'label', 'legend', 'li', 'link', 'listing', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meta', 'meter', 'multicol', 'nav', 'nobr', 'noembed', 'noframes', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'plaintext', 'pre', 'progress', 'q', 'rb', 'rp', 'rt', 'rtc', 'ruby', 's', 'samp', 'script', 'search', 'section', 'select', 'selectedcontent', 'shadow', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr', 'xmp']);
 
 // Doctype identifiers that set quirks mode, lowercase for their case-insensitive comparison
@@ -432,16 +443,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
@@ -504,6 +519,7 @@ export {
   compactElements,
   looseElements,
   trailingElements,
+  specialOptionalEndTags,
   htmlElements,
 
   // Doctype identifiers

package/src/lib/elements.js

@@ -13,7 +13,7 @@ import {
   tableSectionElements,
   cellElements
 } from './constants.js';
-import { hasAttrName } from './attributes.js';
+import { hasAttrName, nameAttrOut, removesEmptyAttribute } from './attributes.js';
 
 /** @import { HTMLAttribute } from './attributes.js' */
 /** @import { ProcessedOptions } from './options.js' */
@@ -95,15 +95,20 @@ function canRemovePrecedingTag(optionalEndTag, tag) {
 /**
  * @param {string} tag
  * @param {HTMLAttribute[]} attrs
+ * @param {ProcessedOptions} options
+ * @param {string} [tagOut] - As hooks get it
  */
-function canRemoveElement(tag, attrs) {
+function canRemoveElement(tag, attrs, options, tagOut = tag) {
   // Elements with `id` attribute must never be removed—they serve as:
   // - Navigation targets (skip links, URL fragments)
   // - JavaScript selector targets (`getElementById`, `querySelector`)
   // - CSS targets (`:target` pseudo-class, ID selectors)
   // - Accessibility landmarks (ARIA references)
   // - Portal mount points (React portals, etc.)
-  if (hasAttrName('id', attrs)) {
+  // An empty one that `removeEmptyAttributes` removes does none of this
+  const id = attrs.find(attr => attr.name.toLowerCase() === 'id');
+  const idName = id && options.name(id.name);
+  if (id && !(idName === 'id' && removesEmptyAttribute(tag, idName, id.value, options, tagOut, nameAttrOut(id, idName, options)))) {
     return false;
   }
 
@@ -124,9 +129,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

@@ -10,6 +10,8 @@
  * one per pattern, so each keeps its own flags.
  */
 
+import { LRU } from './utils.js';
+
 const RE_WHITESPACE = /\s/;
 const RE_NAME_CHAR = /[\w$-]/;
 
@@ -149,22 +151,29 @@ function toClosingLiteral(pattern) {
   return close;
 }
 
+// Prepared fragments outlive the call, as options mostly repeat their patterns; a scan
+// only ever runs synchronously, so the `lastIndex` of their regexes is never shared
+const fragmentCache = new LRU(100);
+
 /**
  * Prepare a fragment pattern for matching, by scanning where the shape allows it
  * @param {RegExp} pattern
  * @returns {DelimitedFragment | PatternFragment}
  */
 function toFragment(pattern) {
-  const delimited = toDelimitedFragment(pattern);
-  if (delimited) return delimited;
+  const key = pattern.flags + '/' + pattern.source;
+  const cached = /** @type {DelimitedFragment | PatternFragment | undefined} */ (fragmentCache.get(key));
+  if (cached) return cached;
 
   // `g` and `y` are ours to set, the rest belong to the pattern
   const flags = pattern.flags.replace(/[gy]/g, '');
-  return {
+  const fragment = toDelimitedFragment(pattern) ?? {
     search: new RegExp(pattern.source, flags + 'g'),
     anchored: new RegExp(pattern.source, flags + 'y'),
     close: toClosingLiteral(pattern)
   };
+  fragmentCache.set(key, fragment);
+  return fragment;
 }
 
 /**

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);