html-minifier 5.0.3 → 5.0.4

package/src/htmlparser.js

@@ -5,7 +5,7 @@
  * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js
  */
 
-import { isThenable, isQuirksDoctype, embedSource, findTagEnd } from './lib/utils.js';
+import { isThenable, isQuirksDoctype, isWhitespaceCode, embedSource, findTagEnd } from './lib/utils.js';
 import { endlessRawTextElements, escapableRawTextElements, formattingElements, genericRawTextElements, processingInstructionTag, RE_HTML_ENCODING, RE_WS_ONLY } from './lib/constants.js';
 
 /** @import { HTMLAttribute } from './lib/attributes.js' */
@@ -172,13 +172,6 @@ function scanAsciiTagName(html, start) {
   }
 }
 
-// The characters `\s` matches, by code: Tab through carriage return, space, and the
-// Unicode whitespace and line terminators
-const isWhitespaceCode = (/** @type {number} */ code) =>
-  (code >= 9 && code <= 13) || code === 32 || code === 0xA0 || code === 0x1680 ||
-  (code >= 0x2000 && code <= 0x200A) || code === 0x2028 || code === 0x2029 ||
-  code === 0x202F || code === 0x205F || code === 0x3000 || code === 0xFEFF;
-
 /**
  * @param {string} text - The input the tag stands in
  * @param {number} nameEnd - Position right after the tag name
@@ -269,9 +262,6 @@ function findScriptEnd(text) {
   return null;
 }
 
-// Cache for compiled attribute regexes per handler configuration
-const attrRegexCache = new WeakMap();
-
 /** @param {HTMLParserHandler} handler */
 function buildAttrRegex(handler) {
   const unquotedValue = handler.continueOnParseError ? singleAttrValueLenientUnquoted : singleAttrValues[2];
@@ -302,26 +292,32 @@ function buildAttrRegex(handler) {
   return new RegExp('^\\s*' + pattern);
 }
 
-/** @param {HTMLParserHandler} handler */
-function getAttrRegexForHandler(handler) {
-  const cached = attrRegexCache.get(handler);
-  if (cached) return cached;
-  const compiled = buildAttrRegex(handler);
-  attrRegexCache.set(handler, compiled);
-  return compiled;
-}
+// Compiled attribute regexes, the sticky one (`y`) for matching at a position in the whole
+// input: By handler where it holds custom patterns, else by the flags they depend on, as
+// a handler lasts one parse only
+/** @type {WeakMap<HTMLParserHandler, {attribute: RegExp, attributeY: RegExp}>} */
+const attrRegexCache = new WeakMap();
+/** @type {Map<number, {attribute: RegExp, attributeY: RegExp}>} */
+const attrRegexPlainCache = new Map();
 
-// Cache for sticky attribute regexes (`y` flag for position-based matching on full string)
-const attrRegexStickyCache = new WeakMap();
+/** @param {unknown} value */
+const isEmptyOption = value => !value || (Array.isArray(value) && !value.length);
 
 /** @param {HTMLParserHandler} handler */
-function getAttrRegexStickyForHandler(handler) {
-  const cached = attrRegexStickyCache.get(handler);
+function getAttrRegexes(handler) {
+  const plain = isEmptyOption(handler.customAttrAssign) && isEmptyOption(handler.customAttrSurround);
+  // An empty `customAttrSurround` still shapes the pattern, if not what it matches
+  const key = (handler.continueOnParseError ? 1 : 0) + (handler.customAttrSurround ? 2 : 0);
+  const cached = plain ? attrRegexPlainCache.get(key) : attrRegexCache.get(handler);
   if (cached) return cached;
-  const nonSticky = getAttrRegexForHandler(handler);
-  // Derive sticky version: Remove `^` anchor, add `y` flag
-  const compiled = new RegExp(nonSticky.source.slice(1), 'y');
-  attrRegexStickyCache.set(handler, compiled);
+  const attribute = buildAttrRegex(handler);
+  // Without the `^` anchor, as stickiness anchors it
+  const compiled = { attribute, attributeY: new RegExp(attribute.source.slice(1), 'y') };
+  if (plain) {
+    attrRegexPlainCache.set(key, compiled);
+  } else {
+    attrRegexCache.set(handler, compiled);
+  }
   return compiled;
 }
 
@@ -377,8 +373,7 @@ export class HTMLParser {
     // Lowercase counterpart of `lastTag`, kept in sync to avoid per-iteration lowercasing
     /** @type {string} */
     let lastTagLower = '';
-    const attribute = getAttrRegexForHandler(handler);
-    const attributeY = getAttrRegexStickyForHandler(handler);
+    const { attribute, attributeY } = getAttrRegexes(handler);
     // Index of the attribute name in a match, after each `customAttrSurround` pattern’s captures
     const baseIndex = 1 + (handler.customAttrSurround ? handler.customAttrSurround.length * NCP : 0);
     /** @type {string | undefined} */
@@ -1056,7 +1051,7 @@ export class HTMLParser {
           break;
         }
 
-        const attrLen = attr[0].length;
+        const attrLen = /** @type {string} */ (attr[0]).length;
         currentPos += attrLen;
         consumed += attrLen;
         match.attrs.push(attr);

package/src/lib/attributes.js

@@ -697,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
@@ -755,8 +781,9 @@ 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) {
+  // 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);
   }
 
@@ -1048,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
@@ -1111,9 +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) &&
-      !isAttributeSelected(attrName, options)) {
+  if (removesEmptyAttribute(tag, attrName, attrValue, options, tagOut, attrNameOut)) {
     return;
   }
 
@@ -1275,6 +1298,8 @@ export {
   isStyleElement,
   isMetaWithoutEffect,
   hasAttrName,
+  nameAttrOut,
+  removesEmptyAttribute,
 
   // Cleaners
   normalizeAttr,

package/src/lib/constants.js

@@ -66,7 +66,7 @@ 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', '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']);
@@ -309,7 +309,8 @@ 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>`
@@ -332,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
@@ -515,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;
   }
 

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/unused-css.js

@@ -41,6 +41,8 @@ const fragmentReferenceAttributes = new Set([
 
 const attributePattern = /(?:^|[\s/])([-\w:.]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/g;
 const identifierPattern = /--[\w-]*|-?[A-Za-z_][\w-]*/g;
+const whitespacePattern = /\s/;
+const whitespaceRunPattern = /\s+/;
 // SVG paints and filters reach elements by ID through `url(#gradient)`, in
 // presentation attributes as well as in `style`
 const fragmentURLPattern = /url\(\s*['"]?#([^)'"\s]+)/gi;
@@ -58,8 +60,8 @@ const cssIdentifierPattern = /(?<!\\)[.#]((?:[-_a-zA-Z]|\\[0-9a-fA-F]{1,6}[ \t\n
 // name used there is off limits even when no element carries it as a class or ID
 const reservedAtRulePattern = /@(?:-\w+-)?(?:keyframes|counter-style)\s+(-?[_a-zA-Z][\w-]*)/gi;
 const escapePattern = /\\(?:([0-9a-fA-F]{1,6})[ \t\n]?|(.))/g;
-// Run over case-folded markup; matches inside comments and scripts only add names
-const startTagPattern = /<([a-z][^\s/>]*)/g;
+// Matches inside comments and scripts only add names
+const startTagPattern = /<([a-z][^\s/>]*)/gi;
 
 /**
  * Resolve CSS escape sequences in an identifier.
@@ -83,20 +85,43 @@ function unescapeIdentifier(identifier) {
 }
 
 /**
- * Lowercase for matching without disturbing offsets.
- *
- * `toLowerCase()` can change a string's length—U+0130 becomes two code units—which
- * would misalign every offset taken from the result. Folding just ASCII preserves
- * length, and tag names are ASCII anyway.
- *
+ * Add what `identifierPattern` matches in `text`
+ * @param {string} text
+ * @param {Set<string>} used
+ * @param {Set<string>} [names] - Also receives each identifier lowercased
+ * @param {Set<string>} [seen] - Identifiers added before, which are skipped
+ */
+function addIdentifiers(text, used, names, seen) {
+  for (const identifier of text.match(identifierPattern) ?? []) {
+    if (seen) {
+      if (seen.has(identifier)) {
+        continue;
+      }
+      seen.add(identifier);
+    }
+    used.add(identifier);
+    names?.add(identifier.toLowerCase());
+  }
+}
+
+/**
+ * Add what splitting `text` at `/\s+/` yields, but empty strings
  * @param {string} text
- * @returns {string} Same length as `text`
+ * @param {Set<string>} used
  */
-function foldCase(text) {
-  const lowercased = text.toLowerCase();
-  return lowercased.length === text.length
-    ? lowercased
-    : text.replace(/[A-Z]+/g, uppercase => uppercase.toLowerCase());
+function addTokens(text, used) {
+  // Most values are a single token, which needs no array
+  if (!whitespacePattern.test(text)) {
+    if (text) {
+      used.add(text);
+    }
+    return;
+  }
+  for (const token of text.split(whitespaceRunPattern)) {
+    if (token) {
+      used.add(token);
+    }
+  }
 }
 
 /**
@@ -107,15 +132,21 @@ function foldCase(text) {
  * quadratically over a document full of near-matches, and bounding it would make
  * long start tags go unrecognized.
  *
- * @param {string} haystack - Case-folded markup, as returned by `foldCase`
+ * Tag names are matched in ASCII case only, as browsers do, and on the markup itself,
+ * so offsets need no mapping back.
+ *
+ * @param {string} html
  * @param {string} tagName - Lowercase element name
  * @returns {Array<{start: number, bodyStart: number, bodyEnd: number, end: number, closed: boolean}>}
  */
-function findRawTextElements(haystack, tagName) {
+function findRawTextElements(html, tagName) {
   /** @type {Array<{start: number, bodyStart: number, bodyEnd: number, end: number, closed: boolean}>} */
   const found = [];
-  const openTag = '<' + tagName;
-  const closeTag = '</' + tagName;
+  // Without the `u` flag, `i` folds no non-ASCII character into ASCII
+  const openTag = new RegExp('<' + tagName, 'gi');
+  const closeTag = new RegExp('</' + tagName, 'gi');
+  const lengthOpen = tagName.length + 1;
+  const lengthClose = tagName.length + 2;
   // A tag name ends at whitespace, a slash, or the closing bracket—so `<styles>`
   // and `</scriptfoo>` name different elements and must not match
   const endsName = (/** @type {string} */ character) =>
@@ -123,17 +154,18 @@ function findRawTextElements(haystack, tagName) {
 
   let cursor = 0;
   for (;;) {
-    const start = haystack.indexOf(openTag, cursor);
+    openTag.lastIndex = cursor;
+    const start = openTag.exec(html)?.index ?? -1;
     if (start === -1) {
       break;
     }
-    if (!endsName(haystack.charAt(start + openTag.length))) {
-      cursor = start + openTag.length;
+    if (!endsName(html.charAt(start + lengthOpen))) {
+      cursor = start + lengthOpen;
       continue;
     }
     // A quoted attribute value may hold a `>`, so the tag ends where the parser
     // says it does, not at the next bracket
-    const startTagEnd = findTagEnd(haystack, start + openTag.length);
+    const startTagEnd = findTagEnd(html, start + lengthOpen);
     if (startTagEnd === -1) {
       break;
     }
@@ -143,30 +175,31 @@ function findRawTextElements(haystack, tagName) {
     let bodyEnd = -1;
     let end = -1;
     for (;;) {
-      const candidate = haystack.indexOf(closeTag, search);
+      closeTag.lastIndex = search;
+      const candidate = closeTag.exec(html)?.index ?? -1;
       if (candidate === -1) {
         break;
       }
-      if (endsName(haystack.charAt(candidate + closeTag.length))) {
-        const closeEnd = findTagEnd(haystack, candidate + closeTag.length);
+      if (endsName(html.charAt(candidate + lengthClose))) {
+        const closeEnd = findTagEnd(html, candidate + lengthClose);
         if (closeEnd !== -1) {
           bodyEnd = candidate;
           end = closeEnd + 1;
         }
         break;
       }
-      search = candidate + closeTag.length;
+      search = candidate + lengthClose;
     }
 
     const closed = bodyEnd !== -1;
     found.push({
       start,
       bodyStart,
-      bodyEnd: closed ? bodyEnd : haystack.length,
-      end: closed ? end : haystack.length,
+      bodyEnd: closed ? bodyEnd : html.length,
+      end: closed ? end : html.length,
       closed
     });
-    cursor = closed ? end : haystack.length;
+    cursor = closed ? end : html.length;
   }
 
   return found;
@@ -189,39 +222,20 @@ function findRawTextElements(haystack, tagName) {
  */
 function collectUsedSymbols(html, includeScripts, decode, elements) {
   const used = new Set();
-  const haystack = foldCase(html);
-
-  // Style sheets are skipped rather than cut out, so both scans share one folded
-  // copy and offsets keep pointing into `html`. Only the body is skipped—the start
-  // tag carries ordinary attributes, and `<style id="theme">` could be what
-  // `#theme` refers to. An unclosed element is not skipped: Reading its contents
-  // as markup can only add symbols, whereas ignoring the rest of the document
-  // would lose them.
-  const skipped = findRawTextElements(haystack, 'style')
+
+  // Style sheets are skipped rather than cut out, so offsets keep pointing into
+  // `html`. Only the body is skipped—the start tag carries ordinary attributes,
+  // and `<style id="theme">` could be what `#theme` refers to. An unclosed
+  // element is not skipped: Reading its contents as markup can only add symbols,
+  // whereas ignoring the rest of the document would lose them.
+  const skipped = findRawTextElements(html, 'style')
     .filter(element => element.closed)
     .map(element => ({ start: element.bodyStart, end: element.bodyEnd }));
 
   if (elements) {
-    collectUsedElements(haystack, skipped, elements);
+    collectUsedElements(html, skipped, elements);
   }
 
-  const addIdentifiers = (/** @type {string} */ text, /** @type {Set<string> | undefined} */ names = undefined) => {
-    identifierPattern.lastIndex = 0;
-    let identifier;
-    while ((identifier = identifierPattern.exec(text))) {
-      used.add(identifier[0]);
-      names?.add(identifier[0].toLowerCase());
-    }
-  };
-
-  const addTokens = (/** @type {string} */ text) => {
-    for (const token of text.split(/\s+/)) {
-      if (token) {
-        used.add(token);
-      }
-    }
-  };
-
   // Both loops below walk forward, so one cursor over the skipped ranges suffices
   let skipCursor = 0;
   const isSkipped = (/** @type {number} */ index) => {
@@ -243,20 +257,20 @@ function collectUsedSymbols(html, includeScripts, decode, elements) {
     // `class="us&#101;d"` names the class `used`, so compare against the decoded value
     const value = (decode && raw.indexOf('&') !== -1) ? decode(raw) : raw;
     if (name === 'class' || name === 'id' || idReferenceAttributes.has(name)) {
-      addTokens(value);
+      addTokens(value, used);
     } else if (name.startsWith('data-')) {
       // Class names are commonly parked in `data-*` attributes for scripts to apply later
-      addIdentifiers(value);
-      addTokens(value);
+      addIdentifiers(value, used);
+      addTokens(value, used);
     } else if (fragmentReferenceAttributes.has(name) && value.charAt(0) === '#') {
       // Only a leading `#`: `href="/page#sec"` names a section of another document
-      addTokens(value.slice(1));
+      addTokens(value.slice(1), used);
     }
     if (value.indexOf('(') !== -1) {
       fragmentURLPattern.lastIndex = 0;
       let reference;
       while ((reference = fragmentURLPattern.exec(value))) {
-        addTokens(reference[1] ?? '');
+        addTokens(reference[1] ?? '', used);
       }
     }
   }
@@ -267,18 +281,21 @@ function collectUsedSymbols(html, includeScripts, decode, elements) {
     // isn’t tracked here, both readings count where they differ. An unclosed
     // `script` runs to the end of the document, as it does in a browser.
     skipCursor = 0;
-    for (const element of findRawTextElements(haystack, 'script')) {
+    // Scripts repeat their identifiers, which need adding only once
+    /** @type {Set<string>} */
+    const identifiersScript = new Set();
+    for (const element of findRawTextElements(html, 'script')) {
       if (isSkipped(element.start)) {
         continue;
       }
       const body = html.slice(element.bodyStart, element.bodyEnd);
       const decoded = (decode && body.indexOf('&') !== -1) ? decode(body) : body;
       for (const text of decoded === body ? [body] : [body, decoded]) {
-        addIdentifiers(text, elements);
+        addIdentifiers(text, used, elements, identifiersScript);
         stringLiteralPattern.lastIndex = 0;
         let literal;
         while ((literal = stringLiteralPattern.exec(text))) {
-          addTokens(literal[1] ?? literal[2] ?? literal[3] ?? '');
+          addTokens(literal[1] ?? literal[2] ?? literal[3] ?? '', used);
         }
       }
     }
@@ -342,11 +359,11 @@ function isSafelisted(symbol, safelist) {
 /**
  * Collect the element names a document contains, including those the parser
  * supplies when the markup leaves them out.
- * @param {string} haystack - Case-folded markup, as returned by `foldCase`
+ * @param {string} html
  * @param {Array<{start: number, end: number}>} skipped - Style sheet bodies, in document order
  * @param {Set<string>} elements - Lowercase element names, added to
  */
-function collectUsedElements(haystack, skipped, elements) {
+function collectUsedElements(html, skipped, elements) {
   elements.add('html');
   elements.add('head');
   elements.add('body');
@@ -354,7 +371,7 @@ function collectUsedElements(haystack, skipped, elements) {
   let skipIndex = 0;
   startTagPattern.lastIndex = 0;
   let match;
-  while ((match = startTagPattern.exec(haystack))) {
+  while ((match = startTagPattern.exec(html))) {
     while (skipIndex < skipped.length && (skipped[skipIndex]?.end ?? 0) <= match.index) {
       skipIndex++;
     }
@@ -362,7 +379,7 @@ function collectUsedElements(haystack, skipped, elements) {
     if (element && match.index >= element.start) {
       continue;
     }
-    elements.add(match[1] ?? '');
+    elements.add((match[1] ?? '').toLowerCase());
   }
 }
 

package/src/lib/utils.js

@@ -133,6 +133,14 @@ function escapeXML(value, attribute = false) {
   return value.replace(attribute ? RE_XML_ESCAPE_ATTR : RE_XML_ESCAPE_TEXT, escapeXMLMatch);
 }
 
+/**
+ * Script and style text as browsers read it, for code minifiers
+ * @param {string} text
+ */
+function replaceNUL(text) {
+  return text.indexOf('\0') === -1 ? text : text.replace(/\0/g, '\uFFFD');
+}
+
 /**
  * Read text in foreign content as HTML does: CDATA sections hold text as written,
  * while what surrounds them reads character references
@@ -938,6 +946,15 @@ function describeQuantifierRisk(pattern) {
     : null;
 }
 
+// The characters `\s` matches, by code: tab through carriage return, space, and the
+// Unicode whitespace and line terminators
+/** @param {number} code */
+function isWhitespaceCode(code) {
+  return (code >= 9 && code <= 13) || code === 32 || code === 0xA0 || code === 0x1680 ||
+    (code >= 0x2000 && code <= 0x200A) || code === 0x2028 || code === 0x2029 ||
+    code === 0x202F || code === 0x205F || code === 0x3000 || code === 0xFEFF;
+}
+
 /**
  * Find the index of the `>` that closes an opening tag, correctly skipping
  * over quoted attribute values (which may contain `>`).
@@ -1011,10 +1028,12 @@ export {
   hashContent,
   uniqueId,
   escapeXML,
+  replaceNUL,
   decodeForeignText,
   identity,
   isQuirksDoctype,
   isThenable,
+  isWhitespaceCode,
   lowercase,
   paramCase,
   replaceAsync,

package/src/lib/whitespace.js

@@ -18,6 +18,7 @@ import {
   formControlElementsEither,
   toEndTags
 } from './constants.js';
+import { isWhitespaceCode } from './utils.js';
 
 const RE_ANY_WS_NBSP = /[ \n\r\t\f\xA0]/;
 const RE_TAB_NBSP = /[\t\xA0]/;
@@ -53,10 +54,7 @@ function isWsOrNbsp(code) {
 /** @param {string} str */
 function isAllWhitespace(str) {
   for (let i = 0; i < str.length; i++) {
-    const code = str.charCodeAt(i);
-    if (!((code >= 9 && code <= 13) || code === 32 || code === 0xA0 || code === 0x1680 ||
-        (code >= 0x2000 && code <= 0x200A) || code === 0x2028 || code === 0x2029 ||
-        code === 0x202F || code === 0x205F || code === 0x3000 || code === 0xFEFF)) {
+    if (!isWhitespaceCode(str.charCodeAt(i))) {
       return false;
     }
   }