html-minifier-next 7.6.0 → 8.1.0

package/src/htmlparser.js

@@ -5,7 +5,7 @@
  * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js
  */
 
-import { isThenable } from './lib/utils.js';
+import { isThenable, embedSource } from './lib/utils.js';
 
 /** @import { HTMLAttribute } from './lib/attributes.js' */
 
@@ -141,9 +141,9 @@ function buildAttrRegex(handler) {
         throw new Error('`customAttrSurround` entries must be `[RegExp, RegExp]` pairs');
       }
       attrClauses[i] = '(?:' +
-        '(' + pair[0].source + ')\\s*' +
+        '(' + embedSource(pair[0]) + ')\\s*' +
         pattern +
-        '\\s*(' + pair[1].source + ')' +
+        '\\s*(' + embedSource(pair[1]) + ')' +
         ')';
     }
     attrClauses.push('(?:' + pattern + ')');
@@ -180,7 +180,7 @@ function joinSingleAttrAssigns(handler) {
   return singleAttrAssigns.concat(
     handler.customAttrAssign || []
   ).map(function (assign) {
-    return '(?:' + assign.source + ')';
+    return '(?:' + embedSource(assign) + ')';
   }).join('|');
 }
 

package/src/lib/attributes.js

@@ -13,10 +13,12 @@ import {
   isBooleanValue,
   collapsibleValues,
   srcsetElements,
-  reEmptyAttribute
+  RE_EMPTY_ATTRIBUTE,
+  RE_STYLE_ELEMENT
 } from './constants.js';
 import { trimWhitespace, collapseWhitespaceAll } from './whitespace.js';
 import { shouldMinifyInnerHTML } from './options.js';
+import { collectUsedSymbols } from './unused-css.js';
 import { identity, isThenable } from './utils.js';
 
 /** @import { ProcessedOptions } from './options.js' */
@@ -25,10 +27,11 @@ import { identity, isThenable } from './utils.js';
 
 /**
  * @typedef {{ name: string, value?: string | undefined, quote?: string, customAssign?: string, customOpen?: string, customClose?: string }} HTMLAttribute
- *  Internal counterpart of the public typedef in `htmlminifier.js`—keep in sync.
+ *  Internal counterpart of the public typedef in htmlminifier.js—keep in sync.
  */
 
-// Lazy-load entities (used for `decodeEntities` and event-handler attribute decode before `minifyJS`)
+// Lazy-load entities (used for `decodeEntities`, event-handler attribute
+// decoding before `minifyJS`, and `srcdoc` decoding/re-encoding)
 
 /** @type {Promise<Function> | undefined} */
 let decodeHTMLStrictPromise;
@@ -39,6 +42,15 @@ async function getDecodeHTMLStrict() {
   return decodeHTMLStrictPromise;
 }
 
+/** @type {Promise<Function> | undefined} */
+let escapeAttributePromise;
+async function getEscapeAttribute() {
+  if (!escapeAttributePromise) {
+    escapeAttributePromise = import('entities').then(m => m.escapeAttribute);
+  }
+  return escapeAttributePromise;
+}
+
 // Validators
 
 /**
@@ -353,7 +365,7 @@ function canDeleteEmptyAttribute(tag, attrName, attrValue, options) {
   if (typeof options.removeEmptyAttributes === 'function') {
     return options.removeEmptyAttributes(attrName, tag);
   }
-  return (tag === 'input' && attrName === 'value') || reEmptyAttribute.test(attrName);
+  return (tag === 'input' && attrName === 'value') || RE_EMPTY_ATTRIBUTE.test(attrName);
 }
 
 /**
@@ -593,17 +605,62 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTM
   }
 
   if (tag === 'iframe' && attrName === 'srcdoc') {
-    // Recursively minify HTML content within `srcdoc` attribute
     // Fast-path: Skip if nothing would change
     if (!shouldMinifyInnerHTML(options)) {
       return attrValue;
     }
-    return minifyHTMLSelf(attrValue, options, true);
+    return minifySrcdoc(attrValue, options, minifyHTMLSelf);
   }
 
   return attrValue;
 }
 
+/**
+ * Recursively minify the document an `iframe srcdoc` attribute holds.
+ *
+ * Browsers resolve character references before parsing `srcdoc`, so an
+ * entity-encoded document is decoded first (unless `decodeEntities` already
+ * did) and re-encoded afterwards—but only then, so a literal value passes
+ * through byte-identical.
+ *
+ * @param {string} attrValue
+ * @param {ProcessedOptions} options
+ * @param {Function} minifyHTMLSelf
+ * @returns {Promise<string>}
+ */
+async function minifySrcdoc(attrValue, options, minifyHTMLSelf) {
+  let markup = attrValue;
+  let wasEncoded = false;
+  if (!options.decodeEntities && attrValue.indexOf('&') !== -1) {
+    const decode = await getDecodeHTMLStrict();
+    markup = decode(attrValue);
+    wasEncoded = markup !== attrValue;
+  }
+
+  let srcdocOptions = options;
+  // The inner document sees none of the parent’s markup, so its style sheets
+  // minify against the symbols the `srcdoc` content references itself
+  if (options.removeUnusedCSS && RE_STYLE_ELEMENT.test(markup)) {
+    const decode = markup.indexOf('&') !== -1 ? await getDecodeHTMLStrict() : undefined;
+    srcdocOptions = {
+      ...options,
+      cssContext: {
+        warned: options.cssContext ? options.cssContext.warned : new Set(),
+        usedSymbols: collectUsedSymbols(markup, options.removeUnusedCSS.scripts, /** @type {((text: string) => string) | undefined} */ (decode))
+      }
+    };
+  }
+
+  try {
+    const minified = await minifyHTMLSelf(markup, srcdocOptions, true);
+    return wasEncoded ? (await getEscapeAttribute())(minified) : minified;
+  } catch (err) {
+    if (!options.continueOnMinifyError) throw err;
+    options.log && options.log(/** @type {Error} */ (err));
+    return attrValue;
+  }
+}
+
 /**
  * Choose appropriate quote character for an attribute value
  * @param {string} attrValue - The attribute value

package/src/lib/constants.js

@@ -17,6 +17,9 @@ const RE_ATTR_WS_CHECK = /[ \n\r\t\f]/;
 const RE_ATTR_WS_COLLAPSE = /[ \n\r\t\f]+/g;
 const RE_ATTR_WS_TRIM = /^[ \n\r\t\f]+|[ \n\r\t\f]+$/g;
 const RE_STYLE_ELEMENT = /<style[\s/>]/i;
+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)))$');
 
 // Inline element sets for whitespace handling
 
@@ -163,12 +166,6 @@ const trailingElements = new Set(['dt', 'thead']);
 
 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']);
 
-// Empty attribute regex
-
-const reEmptyAttribute = new RegExp(
-  '^(?:class|id|style|title|lang|dir|on(?:focus|blur|change|click|dblclick|mouse(' +
-  '?:down|up|over|move|out)|key(?:press|down|up)))$');
-
 // Special content elements
 
 const specialContentElements = new Set(['script', 'style']);
@@ -194,6 +191,8 @@ export {
   RE_ATTR_WS_COLLAPSE,
   RE_ATTR_WS_TRIM,
   RE_STYLE_ELEMENT,
+  RE_EMPTY_ATTRIBUTE,
+
   // Inline element sets
   inlineElementsToKeepWhitespaceAround,
   inlineElementsToKeepWhitespaceWithin,
@@ -236,7 +235,6 @@ export {
   trailingElements,
   htmlElements,
 
-  // Regex
-  reEmptyAttribute,
+  // Special content elements
   specialContentElements
 };

package/src/lib/fragments.js

@@ -0,0 +1,274 @@
+/**
+ * Custom fragment matching
+ *
+ * `ignoreCustomFragments` patterns nearly always describe the same shape: a literal
+ * opening delimiter, an any-character or negated-class body, and a literal closing
+ * delimiter, as in `<%[\s\S]*?%>` or `\{\{[^}]*?\}\}`. Such a fragment can be found
+ * with `indexOf` in linear time, where running the pattern as a regex costs O(n²)
+ * on input that opens fragments it never closes—and can cost far more than that when
+ * the pattern itself backtracks. Patterns of other shapes keep running as regexes,
+ * one per pattern, so each keeps its own flags.
+ */
+
+const RE_WHITESPACE = /\s/;
+
+// Any-character and negated-class bodies; without the `s` flag, `.` is itself a
+// negated class, excluding line terminators
+const RE_DELIMITED = /^(.*?)(?:\[\\s\\S\]|\[\\S\\s\]|\[\^\]|(\.)|\[\^((?:\\[^]|[^\]\\])+)\])(?:([*+])|\{(\d+)(?:,(\d*))?\})\?(.*)$/;
+
+// Flags that leave literal matching alone, so a pattern carrying them can still be
+// scanned for; `i` in particular cannot, since case folding moves character indexes
+const RE_LITERAL_FLAGS = /^[gds]*$/;
+
+/**
+ * @typedef {{open: string, close: string, min: number, max: number, excluded: RegExp | null}} DelimitedFragment
+ *  Literal delimiters around a body, found by scanning; `excluded` holds the
+ *  characters a negated-class body cannot cross, null when the body spans every
+ *  character
+ * @typedef {{search: RegExp, anchored: RegExp}} PatternFragment
+ *  Everything else, found by running the pattern itself
+ */
+
+/**
+ * Read a regex source as a literal string, so it can be matched with `indexOf`
+ * @param {string} source
+ * @returns {string | null} Null when the source is more than literal characters
+ */
+function toLiteral(source) {
+  let literal = '';
+
+  for (let i = 0; i < source.length; i++) {
+    const char = source[i] ?? '';
+    if (char === '\\') {
+      const escaped = source[++i];
+      // A trailing backslash is half an escape the body token was split out of,
+      // as in `<%\.*?%>`, where the `.` is literal and not a body
+      if (escaped === undefined) return null;
+      // `\n` and friends are literal characters, `\s` and `\1` are not
+      if (escaped === 'n') literal += '\n';
+      else if (escaped === 't') literal += '\t';
+      else if (escaped === 'r') literal += '\r';
+      else if (escaped === 'f') literal += '\f';
+      else if (escaped === 'v') literal += '\v';
+      else if (/[A-Za-z0-9]/.test(escaped)) return null;
+      else literal += escaped;
+    } else if ('.*+?()[]{}|^$'.includes(char)) {
+      return null;
+    } else {
+      literal += char;
+    }
+  }
+
+  return literal;
+}
+
+/**
+ * Describe a fragment pattern as literal delimiters around an any-character body
+ * @param {RegExp} pattern
+ * @returns {DelimitedFragment | null} Null when the pattern has another shape, which
+ *  the caller answers by running it as a regex
+ */
+function toDelimitedFragment(pattern) {
+  if (!RE_LITERAL_FLAGS.test(pattern.flags)) return null;
+
+  const match = RE_DELIMITED.exec(pattern.source);
+  if (!match) return null;
+
+  const [, rawOpen, dot, negated, simple, exact, upper, rawClose] = match;
+  const open = toLiteral(rawOpen ?? '');
+  const close = toLiteral(rawClose ?? '');
+  // Both delimiters have to be there: without them a match has no boundary to scan to
+  if (!open || !close) return null;
+
+  // The class content doubles as the search for characters the body cannot cross;
+  // a `.` body spans every character under the `s` flag, and excludes line
+  // terminators without it
+  const inner = dot ? (pattern.flags.includes('s') ? null : '\\n\\r\\u2028\\u2029') : negated ?? null;
+
+  const min = simple ? (simple === '+' ? 1 : 0) : Number(exact);
+  const max = simple || upper === '' ? Infinity : Number(upper ?? exact);
+
+  return { open, close, min, max, excluded: inner === null ? null : new RegExp('[' + inner + ']', 'g') };
+}
+
+/**
+ * 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;
+
+  // `g` and `y` are ours to set, the rest belong to the pattern
+  const flags = pattern.flags.replace(/[gy]/g, '');
+  return { search: new RegExp(pattern.source, flags + 'g'), anchored: new RegExp(pattern.source, flags + 'y') };
+}
+
+/**
+ * Replace runs of custom fragments, and the whitespace padding them
+ * @param {string} value - Document to scan
+ * @param {(DelimitedFragment | PatternFragment)[]} fragments - In the order the patterns
+ *  were given, since the earliest match wins and ties go to the pattern listed first
+ * @param {(match: string) => string} replacer - Called with each match, as `replace` would
+ * @returns {string}
+ */
+function replaceCustomFragments(value, fragments, replacer) {
+  // Where each fragment's next match may start, its next closing delimiter may be
+  // found, and its next excluded character sits; all only ever move forward, which
+  // is what keeps the whole scan linear
+  const found = fragments.map(() => /** @type {{start: number, end: number} | null} */ (null));
+  const closesAt = fragments.map(() => -1);
+  const excludedAt = fragments.map(() => -1);
+  const exhausted = fragments.map(() => false);
+
+  /**
+   * Whether a body region holds a character its class excludes
+   * @param {DelimitedFragment} fragment
+   * @param {number} index - Which fragment, for the forward-only bookkeeping
+   * @param {number} bodyStart
+   * @param {number} close
+   * @returns {boolean}
+   */
+  const bodyBlocked = (fragment, index, bodyStart, close) => {
+    if (!fragment.excluded) return false;
+    if (/** @type {number} */ (excludedAt[index]) < bodyStart) {
+      fragment.excluded.lastIndex = bodyStart;
+      const blocked = fragment.excluded.exec(value);
+      excludedAt[index] = blocked ? blocked.index : Infinity;
+    }
+    return /** @type {number} */ (excludedAt[index]) < close;
+  };
+
+  /**
+   * Earliest match of one delimited fragment at or after `from`
+   * @param {DelimitedFragment} fragment
+   * @param {number} index - Which fragment, for the forward-only bookkeeping
+   * @param {number} from
+   * @param {boolean} anchored - Whether the match has to start exactly at `from`
+   * @returns {{start: number, end: number} | null}
+   */
+  const scan = (fragment, index, from, anchored) => {
+    let openFrom = from;
+
+    for (;;) {
+      const open = anchored
+        ? (value.startsWith(fragment.open, from) ? from : -1)
+        : value.indexOf(fragment.open, openFrom);
+      if (open === -1) {
+        if (!anchored) exhausted[index] = true;
+        return null;
+      }
+
+      const bodyStart = open + fragment.open.length;
+      if (/** @type {number} */ (closesAt[index]) < bodyStart + fragment.min) {
+        closesAt[index] = value.indexOf(fragment.close, bodyStart + fragment.min);
+      }
+      const close = /** @type {number} */ (closesAt[index]);
+      if (close === -1) {
+        exhausted[index] = true;
+        return null;
+      }
+
+      if (close - bodyStart <= fragment.max && !bodyBlocked(fragment, index, bodyStart, close)) {
+        return { start: open, end: close + fragment.close.length };
+      }
+      // The body is longer than the pattern allows, or holds a character its class
+      // excludes, so the match has to start later
+      if (anchored) return null;
+      openFrom = open + 1;
+    }
+  };
+
+  /**
+   * Earliest match of one regex fragment at or after `from`
+   * @param {PatternFragment} fragment
+   * @param {number} from
+   * @param {boolean} anchored
+   * @returns {{start: number, end: number} | null}
+   */
+  const run = (fragment, from, anchored) => {
+    const pattern = anchored ? fragment.anchored : fragment.search;
+    pattern.lastIndex = from;
+
+    for (;;) {
+      const match = pattern.exec(value);
+      if (!match) return null;
+      // A pattern that matches nothing would leave the run in place forever
+      if (match[0].length > 0) return { start: match.index, end: match.index + match[0].length };
+      if (anchored) return null;
+      pattern.lastIndex = match.index + 1;
+    }
+  };
+
+  /**
+   * @param {number} from
+   * @param {boolean} anchored
+   * @returns {{start: number, end: number} | null}
+   */
+  const find = (from, anchored) => {
+    /** @type {{start: number, end: number} | null} */
+    let earliest = null;
+
+    for (let i = 0; i < fragments.length; i++) {
+      if (exhausted[i]) continue;
+      const fragment = /** @type {DelimitedFragment | PatternFragment} */ (fragments[i]);
+
+      /** @type {{start: number, end: number} | null} */
+      let match;
+      if (anchored) {
+        match = 'open' in fragment ? scan(fragment, i, from, true) : run(fragment, from, true);
+      } else {
+        // Matches only ever move forward, so the last one found still stands
+        const previous = found[i];
+        match = previous && previous.start >= from
+          ? previous
+          : ('open' in fragment ? scan(fragment, i, from, false) : run(fragment, from, false));
+        found[i] = match;
+        // Nothing ahead now means nothing ahead later, either
+        if (!match) exhausted[i] = true;
+      }
+
+      // Ties go to the fragment listed first, the way alternation would resolve them
+      if (match && (!earliest || match.start < earliest.start)) earliest = match;
+    }
+
+    return earliest;
+  };
+
+  let out = '';
+  let copied = 0;
+  let search = 0;
+
+  while (search <= value.length) {
+    const first = find(search, false);
+    if (!first) break;
+
+    // Fragments running straight into each other are one match
+    let end = first.end;
+    for (;;) {
+      const next = find(end, true);
+      if (!next) break;
+      end = next.end;
+    }
+
+    // …as is the whitespace on either side, back to where the last match left off
+    let start = first.start;
+    while (start > copied && RE_WHITESPACE.test(value[start - 1] ?? '')) start--;
+    while (end < value.length && RE_WHITESPACE.test(value[end] ?? '')) end++;
+
+    out += value.slice(copied, start) + replacer(value.slice(start, end));
+    copied = end;
+    search = end;
+  }
+
+  return copied === 0 ? value : out + value.slice(copied);
+}
+
+// Exports
+
+export {
+  toDelimitedFragment,
+  toFragment,
+  replaceCustomFragments
+};

package/src/lib/option-definitions.js

@@ -1,5 +1,13 @@
 // Single source of truth for minifier option names, descriptions, types, and shared defaults
 
+/**
+ * @typedef {object} OptionDefinition
+ * @property {string} description Help text, phrased for the option’s primary CLI form
+ * @property {string} [descriptionAffirmative] Help text for what enabling the option does, where `description` describes the negated form
+ * @property {string} type Key into the parser and JSON Schema type maps in cli.js and scripts/build-schema.js
+ */
+
+/** @type {Record<string, OptionDefinition>} */
 const optionDefinitions = {
   cacheCSS: {
     description: 'Set CSS minification cache size (number of entries, default: 500)',
@@ -62,10 +70,6 @@ const optionDefinitions = {
     description: 'Array of regexes that allow to support custom event attributes for minifyJS (e.g., `ng-click`)',
     type: 'regexpArray'
   },
-  customFragmentQuantifierLimit: {
-    description: 'Set maximum quantifier limit for custom fragments to prevent ReDoS attacks (default: 200)',
-    type: 'int'
-  },
   decodeEntities: {
     description: 'Use direct Unicode characters whenever possible',
     type: 'boolean'
@@ -194,6 +198,10 @@ const optionDefinitions = {
     description: 'Trim whitespace around custom fragments (`--ignore-custom-fragments`)',
     type: 'boolean'
   },
+  strictCustomFragments: {
+    description: 'Reject `ignoreCustomFragments` patterns that risk catastrophic backtracking (rather than warning about them)',
+    type: 'boolean'
+  },
   useShortDoctype: {
     description: 'Replaces the doctype with the short HTML doctype',
     type: 'boolean'

package/src/lib/options.js

@@ -1,5 +1,5 @@
 import { createUrlMinifier } from './urls.js';
-import { LRU, MAX_CACHE_ENTRY_SIZE, stableStringify, hashContent, identity, lowercase, replaceAsync, parseRegExp } from './utils.js';
+import { LRU, MAX_CACHE_ENTRY_SIZE, stableStringify, hashContent, identity, lowercase, replaceAsync, parseRegExp, describeQuantifierRisk, lostFlag } from './utils.js';
 import { RE_TRAILING_SEMICOLON } from './constants.js';
 import { canCollapseWhitespace, canTrimWhitespace } from './whitespace.js';
 import { wrapCSS, unwrapCSS } from './content.js';
@@ -28,7 +28,7 @@ import { optionDefinitions, optionDefaults } from './option-definitions.js';
 
 /**
  * Options object produced by `processOptions` and consumed by `minifyHTML` and
- * the `lib/` helpers; normalization guarantees that the function-valued options
+ * the lib/ helpers; normalization guarantees that the function-valued options
  * below are always present (defaulting to identity/built-in functions), and
  * minification adds writable internal state on top of the public options
  * (set on prototype-chain forks during SVG/MathML namespace transitions)
@@ -97,9 +97,8 @@ const optionKeysExtra = new Set(['preset', 'log', 'canCollapseWhitespace', 'canT
 // key per process, so repeated `minify` calls (e.g., batch runs) don’t flood STDERR
 const optionKeysWarned = new Set();
 const presetNamesWarned = new Set();
-// The custom-fragment ReDoS warning is security-relevant, so it reaches the
-// console even without a `log` hook—once per process, like the warnings above
-let customFragmentQuantifierWarned = false;
+// Custom fragments whose shape risks ReDoS, warned about once per pattern per process
+const customFragmentsWarned = new Set();
 const unusedCSSWarned = new Set();
 // Object-valued options handed a string, warned about once per distinct value
 const stringValuesWarned = new Set();
@@ -191,7 +190,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
     // A string carries no configuration for these options. The CLI parses config
     // values as JSON first, so only a value that is not JSON reaches this from
     // there. (`minifyURLs` is deliberately excluded—there, a string names the site.)
-    const definition = /** @type {Record<string, {type?: string}>} */ (optionDefinitions)[key];
+    const definition = optionDefinitions[key];
     if (typeof option === 'string' && definition?.type === 'jsonObject') {
       const message = `HTML Minifier Next: Ignoring \`${key}\`—it takes a boolean or an object, not a string (“${option}”)`;
       if (!stringValuesWarned.has(message)) {
@@ -598,22 +597,50 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
     } else if (['customAttrAssign', 'customEventAttributes', 'ignoreCustomComments', 'ignoreCustomFragments'].includes(key)) {
       // Array of regex patterns
       optionsDynamic[key] = parseRegExpArray(option);
-      // Warn about potential ReDoS when user-provided fragments use unlimited
-      // quantifiers; only explicitly passed fragments are checked
-      if (key === 'ignoreCustomFragments' && !customFragmentQuantifierWarned) {
-        for (const re of /** @type {RegExp[]} */ (optionsDynamic[key])) {
-          if (/[*+]/.test(re.source)) {
-            customFragmentQuantifierWarned = true;
-            warn('HTML Minifier Next: Custom fragment contains unlimited quantifiers (“*” or “+”) which may cause ReDoS vulnerability');
-            break;
-          }
-        }
-      }
     } else {
       optionsDynamic[key] = option;
     }
   });
 
+  // The parser merges these into one attribute pattern, and a merged pattern
+  // carries no flags of its own. `i` and `s` are written into the source instead,
+  // but `u` and `v` change how a source reads and cannot be: dropped, `\p{L}`
+  // stops being a property escape and matches the literal text `p{L}`, silently
+  // and without failing to compile. Refusing them beats matching the wrong thing.
+  /** @type {[string, RegExp[]][]} */
+  const merged = [
+    ['customAttrAssign', options.customAttrAssign || []],
+    ['customAttrSurround', (options.customAttrSurround || []).flat()]
+  ];
+  for (const [key, patterns] of merged) {
+    for (const re of patterns) {
+      if (!(re instanceof RegExp)) continue;
+      const flag = lostFlag(re);
+      if (!flag) continue;
+      throw new Error(`HTML Minifier Next: \`${key}\` pattern \`/${re.source}/${re.flags}\` carries \`${flag}\`, which the merged attribute pattern cannot carry—rewrite it without \`${flag}\``);
+    }
+  }
+
+  // Fragments that compound quantifiers or alternation under unbounded repetition
+  // are the shapes that backtrack catastrophically, and they are also the ones a
+  // linear scan cannot stand in for; so are patterns too long or too deeply
+  // nested to read, which are refused for that rather than for a shape. A lone
+  // `[\s\S]*?` up to a literal terminator is linear and passes; HMN’s default
+  // fragments have exactly that shape, so the check flagging it would mean
+  // warning about the defaults themselves.
+  for (const re of options.ignoreCustomFragments || []) {
+    const risk = describeQuantifierRisk(re);
+    if (!risk) continue;
+    const problem = `Custom fragment \`/${re.source}/\` ${risk}`;
+    if (options.strictCustomFragments) {
+      throw new Error(`HTML Minifier Next: ${problem}`);
+    }
+    if (!customFragmentsWarned.has(re.source)) {
+      customFragmentsWarned.add(re.source);
+      warn(`HTML Minifier Next: ${problem}`);
+    }
+  }
+
   // Unused-CSS removal rides along with Lightning CSS, so it silently does nothing
   // when `minifyCSS` is off or replaced by a function—say so rather than let it pass
   if (options.removeUnusedCSS) {

package/src/lib/unused-css.js

@@ -37,9 +37,6 @@ const fragmentReferenceAttributes = new Set([
   'xlink:href'
 ]);
 
-// `srcdoc` can nest, and each level costs another scan of its own markup
-const SRCDOC_MAX_DEPTH = 3;
-
 const attributePattern = /(?:^|[\s/])([-\w:.]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/g;
 const identifierPattern = /--[\w-]*|-?[A-Za-z_][\w-]*/g;
 // SVG paints and filters reach elements by ID through `url(#gradient)`, in
@@ -173,16 +170,17 @@ function findRawTextElements(haystack, tagName) {
  * Collect the class names and IDs a document references.
  *
  * Style sheet contents are excluded, so that a style sheet never counts as
- * evidence for its own selectors. Over-collecting is safe here (a symbol wrongly
- * considered used is merely kept), under-collecting is not.
+ * evidence for its own selectors. An `iframe srcdoc` value is not scanned,
+ * either: It holds a document of its own, minified against its own symbol set.
+ * Over-collecting is safe here (a symbol wrongly considered used is merely
+ * kept), under-collecting is not.
  *
  * @param {string} html - Raw document markup
  * @param {boolean} includeScripts - Also treat identifiers inside inline `script` elements as used
  * @param {((text: string) => string)} [decode] - Resolves character references in attribute values
- * @param {number} [depth] - Nesting level, counted through `srcdoc`
  * @returns {Set<string>} Symbols to keep
  */
-function collectUsedSymbols(html, includeScripts, decode, depth = 0) {
+function collectUsedSymbols(html, includeScripts, decode) {
   const used = new Set();
   const haystack = foldCase(html);
 
@@ -222,9 +220,6 @@ function collectUsedSymbols(html, includeScripts, decode, depth = 0) {
     return element !== undefined && index >= element.start;
   };
 
-  /** @type {string[]} */
-  const nested = [];
-
   attributePattern.lastIndex = 0;
   let match;
   while ((match = attributePattern.exec(html))) {
@@ -244,8 +239,6 @@ function collectUsedSymbols(html, includeScripts, decode, depth = 0) {
     } else if (fragmentReferenceAttributes.has(name) && value.charAt(0) === '#') {
       // Only a leading `#`: `href="/page#sec"` names a section of another document
       addTokens(value.slice(1));
-    } else if (name === 'srcdoc' && depth < SRCDOC_MAX_DEPTH) {
-      nested.push(value);
     }
     if (value.indexOf('(') !== -1) {
       fragmentURLPattern.lastIndex = 0;
@@ -256,16 +249,6 @@ function collectUsedSymbols(html, includeScripts, decode, depth = 0) {
     }
   }
 
-  // `iframe srcdoc` holds a document of its own, whose style sheets are minified
-  // against this very set—so what it references has to be in it. The scan runs here
-  // rather than at the attribute: The patterns it shares with this one are
-  // module-level, so no nested scan may start while one of their loops is open.
-  for (const markup of nested) {
-    for (const symbol of collectUsedSymbols(markup, includeScripts, decode, depth + 1)) {
-      used.add(symbol);
-    }
-  }
-
   if (includeScripts) {
     // Script contents are raw text, so character references stay literal;
     // an unclosed `script` runs to the end of the document, as it does in a browser