html-minifier-next 8.2.1 → 8.2.2

package/README.md

@@ -94,6 +94,8 @@ const result = await minify('<p title="example" id="moo">foo</p>', {
 console.log(result); // `<p title=example id=moo>foo`
 ```
 
+(CommonJS consumers can still use dynamic import—`const { minify } = await import('html-minifier-next')`—as `minify()` is async.)
+
 See [the original blog post](https://perfectionkills.com/experimenting-with-html-minifier/) for details of [how it works](https://perfectionkills.com/experimenting-with-html-minifier/#how_it_works), [descriptions of most options](https://perfectionkills.com/experimenting-with-html-minifier/#options), [testing results](https://perfectionkills.com/experimenting-with-html-minifier/#field_testing), and [conclusions](https://perfectionkills.com/experimenting-with-html-minifier/#cost_and_benefits).
 
 ## Presets
@@ -135,9 +137,9 @@ Options can be used in config files (camelCase) or via CLI flags (kebab-case wit
 | `caseSensitive`<br>`--case-sensitive` | Treat attributes in case-sensitive manner (useful for custom HTML elements) | `false` |
 | `collapseAttributeWhitespace`<br>`--collapse-attribute-whitespace` | Trim and collapse whitespace characters within attribute values | `false` |
 | `collapseBooleanAttributes`<br>`--collapse-boolean-attributes` | [Omit attribute values from boolean attributes](https://perfectionkills.com/experimenting-with-html-minifier/#collapse_boolean_attributes) | `false` |
-| `collapseInlineTagWhitespace`<br>`--collapse-inline-tag-whitespace` | Collapse whitespace more aggressively between inline elements—use with `collapseWhitespace: true` | `false` |
-| `collapseWhitespace`<br>`--collapse-whitespace` | [Collapse whitespace that contributes to text nodes in a document tree](https://perfectionkills.com/experimenting-with-html-minifier/#collapse_whitespace) | `false` |
-| `conservativeCollapse`<br>`--conservative-collapse` | Always collapse to one space (never remove it entirely)—use with `collapseWhitespace: true` | `false` |
+| `collapseInlineTagWhitespace`<br>`--collapse-inline-tag-whitespace` | Collapse whitespace more aggressively between inline elements—use with [`collapseWhitespace`](#combining-whitespace-options) | `false` |
+| `collapseWhitespace`<br>`--collapse-whitespace` | [Collapse whitespace that contributes to text nodes in a document tree](https://perfectionkills.com/experimenting-with-html-minifier/#collapse_whitespace); [enable other whitespace options](#combining-whitespace-options) | `false` |
+| `conservativeCollapse`<br>`--conservative-collapse` | Always collapse to one space (never remove it entirely)—use with [`collapseWhitespace`](#combining-whitespace-options) | `false` |
 | `continueOnMinifyError`<br>`--continue-on-minify-error`<br>`--no-continue-on-minify-error` | Continue on minification errors; when `false`, minification errors throw and abort processing | `true` |
 | `continueOnParseError`<br>`--continue-on-parse-error` | [Handle parse errors](https://html.spec.whatwg.org/multipage/parsing.html#parse-errors) instead of aborting | `false` |
 | `customAttrAssign`<br>`--custom-attr-assign` | Array of regexes that allow to support custom attribute assign expressions (e.g., `<div flex?="{{mode != cover}}"></div>`) | `[]` |
@@ -159,7 +161,7 @@ Options can be used in config files (camelCase) or via CLI flags (kebab-case wit
 | `minifyURLs`<br>`--minify-urls` | Minify URLs in various attributes | `false` (could be `true`, `String`, `Object`, `Function(text)`) |
 | `noNewlinesBeforeTagClose`<br>`--no-newlines-before-tag-close` | Never add a newline before a tag that closes an element | `false` |
 | `partialMarkup`<br>`--partial-markup` | Treat input as a partial HTML fragment, preserving stray end tags (closing tags without opening tags) and preventing auto-closing of unclosed tags at end of input | `false` |
-| `preserveLineBreaks`<br>`--preserve-line-breaks` | Always collapse to one line break (never remove it entirely) when whitespace between tags includes a line break—use with `collapseWhitespace: true` | `false` |
+| `preserveLineBreaks`<br>`--preserve-line-breaks` | Always collapse to one line break (never remove it entirely) when whitespace between tags includes a line break—use with [`collapseWhitespace`](#combining-whitespace-options) | `false` |
 | `preventAttributesEscaping`<br>`--prevent-attributes-escaping` | Prevents the escaping of the values of attributes | `false` |
 | `processScripts`<br>`--process-scripts` | Array of strings corresponding to types of `script` elements to process through minifier (e.g., `text/ng-template`, `text/x-handlebars-template`, etc.) | `[]` |
 | `quoteCharacter`<br>`--quote-character` | Type of quote to use for attribute values (`'` or `"`) | Auto-detected (uses the quote requiring less escaping; defaults to `"` when equal) |
@@ -172,7 +174,7 @@ Options can be used in config files (camelCase) or via CLI flags (kebab-case wit
 | `removeOptionalTags`<br>`--remove-optional-tags` | [Remove optional tags](https://perfectionkills.com/experimenting-with-html-minifier/#remove_optional_tags) | `false` |
 | `removeRedundantAttributes`<br>`--remove-redundant-attributes` | [Remove attributes when value matches default](https://meiert.com/blog/optional-html/#toc-attribute-values) | `false` |
 | `removeTagWhitespace`<br>`--remove-tag-whitespace` | Remove space between attributes whenever possible; **note that this will result in invalid HTML** | `false` |
-| `removeUnusedCSS`<br>`--remove-unused-css` | [Remove unused CSS rules](#unused-css-removal) from `style` elements; requires `minifyCSS`; **note that this can change how a document renders** | `false` (could be `true`, `{ safelist, scripts }`) |
+| `removeUnusedCSS`<br>`--remove-unused-css` | [Remove unused CSS rules](#unused-css-removal) from `style` elements—use with `minifyCSS`; **note that this can change how a document renders** | `false` (could be `true`, `{ safelist, scripts }`) |
 | `sortAttributes`<br>`--sort-attributes` | [Sort attributes by frequency](#sorting-attributes-and-style-classes) | `false` |
 | `sortClassNames`<br>`--sort-class-names` | [Sort style classes by frequency](#sorting-attributes-and-style-classes) | `false` |
 | `strictCustomFragments`<br>`--strict-custom-fragments` | [Reject `ignoreCustomFragments` patterns that risk catastrophic backtracking](#redos-protection) (rather than warning about them) | `false` |
@@ -189,6 +191,31 @@ A few options take functions and are therefore only available programmatically,
 | `canTrimWhitespace` | `Function(tag, attrs, defaultFn)` that determines whether leading and trailing whitespace around an element may be trimmed | Built-in handling |
 | `log` | `Function(message)` called with warnings and errors, including minification errors swallowed by `continueOnMinifyError` (e.g., pass `console.error` to surface them); the CLI wires this up under `--verbose` and `--dry` | No-op (errors are silent) |
 
+### Combining whitespace options
+
+`collapseInlineTagWhitespace`, `conservativeCollapse`, and `preserveLineBreaks` are modifiers: They do nothing on their own, and only take effect when `collapseWhitespace` is enabled.
+
+Given input
+
+```html
+<nav>
+  <button>A</button> <button>B</button>
+</nav>
+```
+
+you get the following output (condensed, `\n` represents an actual line break):
+
+| Options | Output |
+| --- | --- |
+| `collapseInlineTagWhitespace` | `<nav>\n  <button>A</button> <button>B</button>\n</nav>` (unchanged) |
+| `collapseWhitespace` | `<nav><button>A</button> <button>B</button></nav>` |
+| `collapseWhitespace`, `collapseInlineTagWhitespace` | `<nav><button>A</button><button>B</button></nav>` |
+| `collapseWhitespace`, `conservativeCollapse` | `<nav> <button>A</button> <button>B</button> </nav>` |
+| `collapseWhitespace`, `preserveLineBreaks` | `<nav>\n<button>A</button> <button>B</button>\n</nav>` |
+| `collapseWhitespace`, `preserveLineBreaks`, `collapseInlineTagWhitespace` | `<nav>\n<button>A</button><button>B</button>\n</nav>` |
+
+Where the modifiers disagree, the preserving one wins—`conservativeCollapse` and `preserveLineBreaks` do not let `collapseInlineTagWhitespace` remove a space or line break entirely.
+
 ### Sorting attributes and style classes
 
 Minifier options like `sortAttributes` and `sortClassNames` won’t impact the plain-text size of the output. However, using these options for more consistent ordering improves the compression ratio for Gzip and Brotli used over HTTP.
@@ -234,7 +261,7 @@ const result = await minify(html, {
 
 ### Unused CSS removal
 
-`removeUnusedCSS` removes rules from `style` elements whose class or ID selectors the document doesn’t reference. It requires `minifyCSS`, because the removal runs through Lightning CSS—passing `minifyCSS` a function of your own replaces that step, so the removal does not apply, either. Both cases are reported through [the `log` hook](#api-only-options). It does not touch `style` or `media` attributes.
+`removeUnusedCSS` removes rules from `style` elements whose class or ID selectors the document doesn’t reference. It needs to be used with `minifyCSS`, because the removal runs through Lightning CSS—passing `minifyCSS` a function of your own replaces that step, so the removal does not apply, either. Both cases are reported through [the `log` hook](#api-only-options). It does not touch `style` or `media` attributes.
 
 ```js
 const result = await minify(html, {

package/dist/types/htmlparser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"htmlparser.d.ts","sourceRoot":"","sources":["../../src/htmlparser.js"],"names":[],"mappings":"AAeG,YAYG,iBAAiB,GAZV;IACR,KAAK,CAAC,WAAW;IACjB,GAAG,CAAC,WAAW;IACf,KAAK,CAAC,WAAW;IACjB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,WAAW;IACnB,oBAAoB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3C,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACpC,YAAY,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACnC,gBAAgB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,kBAAkB,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,SAAS,CAAC;IAC5C,gBAAgB,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;CACxC,CAAmB;AA0CvB,eAAO,MAAM,MAAM,QAA8C,CAAC;AAoJlE,qBAAa,UAAU;IAMd,IAAI;IACJ,OAAO;IANd;;;OAGG;IACH,YAAY,IAAI,EAHL,MAGK,EAAE,OAAO,EAFd,iBAEc,EAGxB;IAEK,KAAK,kBAovBV;CACF"}
+{"version":3,"file":"htmlparser.d.ts","sourceRoot":"","sources":["../../src/htmlparser.js"],"names":[],"mappings":"AAeG,YAYG,iBAAiB,GAZV;IACR,KAAK,CAAC,WAAW;IACjB,GAAG,CAAC,WAAW;IACf,KAAK,CAAC,WAAW;IACjB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,WAAW;IACnB,oBAAoB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3C,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACpC,YAAY,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACnC,gBAAgB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,kBAAkB,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,SAAS,CAAC;IAC5C,gBAAgB,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;CACxC,CAAmB;AA0CvB,eAAO,MAAM,MAAM,QAA8C,CAAC;AA2JlE,qBAAa,UAAU;IAMd,IAAI;IACJ,OAAO;IANd;;;OAGG;IACH,YAAY,IAAI,EAHL,MAGK,EAAE,OAAO,EAFd,iBAEc,EAGxB;IAEK,KAAK,kBAkxBV;CACF"}

package/dist/types/lib/whitespace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"whitespace.d.ts","sourceRoot":"","sources":["../../../src/lib/whitespace.js"],"names":[],"mappings":"AAeA,0BAA0B;AAC1B,QAAA,MAAM,cAAc,QADR,MAAM,WAQjB,CAAC;AAIF,0BAA0B;AAC1B,iBAAS,qBAAqB,CAAC,GAAG,EADtB,MACsB,UAgBjC;AAID;;;;;;GAMG;AACH,iBAAS,kBAAkB,CAAC,GAAG,EANpB,MAMoB,EAAE,OAAO,EAL7B;IAAC,kBAAkB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAAC,oBAAoB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAKxD,EAAE,QAAQ,EAJvC,OAIuC,EAAE,SAAS,EAHlD,OAGkD,EAAE,WAAW,AAFvE,CAA8B,EAAtB,OAEuE,UAqFjF;AAoBD;;;;;;;;;GASG;AACH,iBAAS,uBAAuB,CAAC,GAAG,EATzB,MASyB,EAAE,OAAO,EARlC,MAQkC,EAAE,OAAO,EAP3C,MAO2C,EAAE,SAAS,EANtD,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAC,CAMkB,EAAE,SAAS,EALjE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAC,CAK6B,EAAE,OAAO,EAJ1E;IAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAAC,2BAA2B,CAAC,EAAE,OAAO,CAAA;CAI1B,EAAE,cAAc,EAH1F,GAAG,CAAC,MAAM,CAGgF,EAAE,aAAa,EAFzG,GAAG,CAAC,MAAM,CAE+F,UAiEnH;AASD,0BAA0B;AAC1B,iBAAS,qBAAqB,CAAC,GAAG,EADtB,MACsB,WAEjC;AAED,0BAA0B;AAC1B,iBAAS,iBAAiB,CAAC,GAAG,EADlB,MACkB,WAE7B;AAID,OAAO,EACL,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EAClB,uBAAuB,EACvB,qBAAqB,EACrB,iBAAiB,EAClB,CAAC"}
+{"version":3,"file":"whitespace.d.ts","sourceRoot":"","sources":["../../../src/lib/whitespace.js"],"names":[],"mappings":"AAeA,0BAA0B;AAC1B,QAAA,MAAM,cAAc,QADR,MAAM,WAQjB,CAAC;AAIF,0BAA0B;AAC1B,iBAAS,qBAAqB,CAAC,GAAG,EADtB,MACsB,UAgBjC;AAID;;;;;;GAMG;AACH,iBAAS,kBAAkB,CAAC,GAAG,EANpB,MAMoB,EAAE,OAAO,EAL7B;IAAC,kBAAkB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAAC,oBAAoB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAKxD,EAAE,QAAQ,EAJvC,OAIuC,EAAE,SAAS,EAHlD,OAGkD,EAAE,WAAW,AAFvE,CAA8B,EAAtB,OAEuE,UAqFjF;AAoBD;;;;;;;;;GASG;AACH,iBAAS,uBAAuB,CAAC,GAAG,EATzB,MASyB,EAAE,OAAO,EARlC,MAQkC,EAAE,OAAO,EAP3C,MAO2C,EAAE,SAAS,EANtD,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAC,CAMkB,EAAE,SAAS,EALjE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAC,CAK6B,EAAE,OAAO,EAJ1E;IAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAAC,2BAA2B,CAAC,EAAE,OAAO,CAAA;CAI1B,EAAE,cAAc,EAH1F,GAAG,CAAC,MAAM,CAGgF,EAAE,aAAa,EAFzG,GAAG,CAAC,MAAM,CAE+F,UA4EnH;AASD,0BAA0B;AAC1B,iBAAS,qBAAqB,CAAC,GAAG,EADtB,MACsB,WAEjC;AAED,0BAA0B;AAC1B,iBAAS,iBAAiB,CAAC,GAAG,EADlB,MACkB,WAE7B;AAID,OAAO,EACL,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EAClB,uBAAuB,EACvB,qBAAqB,EACrB,iBAAiB,EAClB,CAAC"}

package/html-minifier-next.schema.json

@@ -275,7 +275,7 @@
       "type": "boolean"
     },
     "removeUnusedCSS": {
-      "description": "Remove rules from `style` elements whose class or ID selectors the document never references (requires `--minify-css`); note that class names only applied by external scripts cannot be detected—use `{\"safelist\": […]}` for those",
+      "description": "Remove rules from `style` elements whose class or ID selectors the document never references—use with `--minify-css`; note that class names only applied by external scripts cannot be detected—use `{\"safelist\": […]}` for those",
       "type": [
         "boolean",
         "object"

package/package.json

@@ -95,5 +95,5 @@
   },
   "type": "module",
   "types": "dist/types/htmlminifier.d.ts",
-  "version": "8.2.1"
+  "version": "8.2.2"
 }

package/src/htmlparser.js

@@ -103,6 +103,13 @@ const nonPhrasing = new Set(['address', 'article', 'aside', 'base', 'blockquote'
 const endsTagName = (/** @type {string} */ character) =>
   character === '' || character === '/' || character === '>' || /\s/.test(character);
 
+// 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
@@ -251,8 +258,6 @@ export class HTMLParser {
 
     // Sticky regex versions for position-based matching (avoids string slicing)
     const startTagOpenY = new RegExp(startTagOpen.source.slice(1), 'y');
-    // `\s*` with sticky flag is O(n) at worst—no retry from different positions possible
-    const startTagCloseY = /\s*(\/?)>/y;
     const endTagOpenY = new RegExp(endTagOpen.source.slice(1), 'y');
     const doctypeY = /<!DOCTYPE[^<>]+>/iy;
     const commentTestY = /<!--/y;
@@ -386,77 +391,84 @@ export class HTMLParser {
           cachedNextStartTag = null;
           cachedNextEndTag = null;
 
-          // Comment
-          commentTestY.lastIndex = pos;
-          if (commentTestY.test(fullHtml)) {
-            const commentEnd = commentEndAhead ? fullHtml.indexOf('-->', pos + 4) : -1;
-            if (commentEnd === -1) commentEndAhead = false;
-
-            if (commentEnd >= 0) {
-              if (handler.comment) {
-                const result = handler.comment(fullHtml.substring(pos + 4, commentEnd));
-                if (isThenable(result)) await result;
+          // Dispatch on the character after `<`: Each branch below can only match
+          // with one leading character (`!` for markup declarations, `/` for end
+          // tags, a name character for start tags), so the matchers that require
+          // another one never run—a name lookup costs several regex executions
+          const nextCode = fullHtml.charCodeAt(pos + 1);
+          if (nextCode === 33) { // `!`
+            // Comment
+            commentTestY.lastIndex = pos;
+            if (commentTestY.test(fullHtml)) {
+              const commentEnd = commentEndAhead ? fullHtml.indexOf('-->', pos + 4) : -1;
+              if (commentEnd === -1) commentEndAhead = false;
+
+              if (commentEnd >= 0) {
+                if (handler.comment) {
+                  const result = handler.comment(fullHtml.substring(pos + 4, commentEnd));
+                  if (isThenable(result)) await result;
+                }
+                advance(commentEnd + 3 - pos);
+                prevTag = '';
+                prevAttrs = [];
+                continue;
               }
-              advance(commentEnd + 3 - pos);
-              prevTag = '';
-              prevAttrs = [];
-              continue;
             }
-          }
 
-          // https://web.archive.org/web/20241201212701/https://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
-          conditionalTestY.lastIndex = pos;
-          if (conditionalTestY.test(fullHtml)) {
-            const conditionalEnd = conditionalEndAhead ? fullHtml.indexOf(']>', pos + 3) : -1;
-            if (conditionalEnd === -1) conditionalEndAhead = false;
+            // https://web.archive.org/web/20241201212701/https://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+            conditionalTestY.lastIndex = pos;
+            if (conditionalTestY.test(fullHtml)) {
+              const conditionalEnd = conditionalEndAhead ? fullHtml.indexOf(']>', pos + 3) : -1;
+              if (conditionalEnd === -1) conditionalEndAhead = false;
+
+              if (conditionalEnd >= 0) {
+                if (handler.comment) {
+                  const result = handler.comment(fullHtml.substring(pos + 2, conditionalEnd + 1), true /* Non-standard */);
+                  if (isThenable(result)) await result;
+                }
+                advance(conditionalEnd + 2 - pos);
+                prevTag = '';
+                prevAttrs = [];
+                continue;
+              }
+            }
 
-            if (conditionalEnd >= 0) {
-              if (handler.comment) {
-                const result = handler.comment(fullHtml.substring(pos + 2, conditionalEnd + 1), true /* Non-standard */);
-                if (isThenable(result)) await result;
+            // Doctype
+            doctypeY.lastIndex = pos;
+            const doctypeMatch = doctypeY.exec(fullHtml);
+            if (doctypeMatch) {
+              if (handler.doctype) {
+                handler.doctype(doctypeMatch[0]);
               }
-              advance(conditionalEnd + 2 - pos);
+              advance(doctypeMatch[0].length);
               prevTag = '';
               prevAttrs = [];
               continue;
             }
-          }
-
-          // Doctype
-          doctypeY.lastIndex = pos;
-          const doctypeMatch = doctypeY.exec(fullHtml);
-          if (doctypeMatch) {
-            if (handler.doctype) {
-              handler.doctype(doctypeMatch[0]);
+          } else if (nextCode === 47) { // `/`
+            // End tag—skip when no `>` lies ahead: The tag cannot be complete, and matching
+            // its name at every position would cost O(n²) on a long unclosed name
+            if (hasCloseAtOrAfter(pos)) {
+              const endTagMatch = matchEndTag(pos);
+              if (endTagMatch) {
+                advance(endTagMatch.text.length);
+                await parseEndTag(endTagMatch.text, endTagMatch.name);
+                prevTag = '/' + endTagMatch.name.toLowerCase();
+                prevAttrs = [];
+                continue;
+              }
             }
-            advance(doctypeMatch[0].length);
-            prevTag = '';
-            prevAttrs = [];
-            continue;
-          }
-
-          // End tag—skip when no `>` lies ahead: The tag cannot be complete, and matching
-          // its name at every position would cost O(n²) on a long unclosed name
-          if (hasCloseAtOrAfter(pos)) {
-            const endTagMatch = matchEndTag(pos);
-            if (endTagMatch) {
-              advance(endTagMatch.text.length);
-              await parseEndTag(endTagMatch.text, endTagMatch.name);
-              prevTag = '/' + endTagMatch.name.toLowerCase();
-              prevAttrs = [];
+          } else {
+            // Start tag
+            const startTagMatch = parseStartTag(pos);
+            if (startTagMatch) {
+              advance(startTagMatch.advance);
+              await handleStartTag(startTagMatch);
+              prevTag = startTagMatch.tagName.toLowerCase();
               continue;
             }
           }
 
-          // Start tag
-          const startTagMatch = parseStartTag(pos);
-          if (startTagMatch) {
-            advance(startTagMatch.advance);
-            await handleStartTag(startTagMatch);
-            prevTag = startTagMatch.tagName.toLowerCase();
-            continue;
-          }
-
           // Treat `<` as text
           if (handler.continueOnParseError) {
             // Continue looking for next tag
@@ -474,13 +486,21 @@ export class HTMLParser {
 
         // Next tag for whitespace processing context
         if (handler.wantsNextTag) {
-          const nextStartTagMatch = parseStartTag(pos);
-          if (nextStartTagMatch) {
-            nextTag = nextStartTagMatch.tagName;
-            // Extract minimal attribute info for whitespace logic (just name/value pairs)
-            nextAttrs = extractAttrInfo(nextStartTagMatch.attrs);
-            cachedNextStartTag = { match: nextStartTagMatch, pos };
-          } else if (hasCloseAtOrAfter(pos)) {
+          // Same dispatch as above: A start tag cannot follow `<` + `/` or `!`,
+          // an end tag requires `/`—the other matcher never runs
+          const nextCode = fullHtml.charCodeAt(pos + 1);
+          if (nextCode !== 47 && nextCode !== 33) {
+            const nextStartTagMatch = parseStartTag(pos);
+            if (nextStartTagMatch) {
+              nextTag = nextStartTagMatch.tagName;
+              // Extract minimal attribute info for whitespace logic (just name/value pairs)
+              nextAttrs = extractAttrInfo(nextStartTagMatch.attrs);
+              cachedNextStartTag = { match: nextStartTagMatch, pos };
+            } else {
+              nextTag = '';
+              nextAttrs = [];
+            }
+          } else if (nextCode === 47 && hasCloseAtOrAfter(pos)) {
             const nextEndTagMatch = matchEndTag(pos);
             if (nextEndTagMatch) {
               nextTag = '/' + nextEndTagMatch.name;
@@ -603,6 +623,23 @@ export class HTMLParser {
       return close === -1 ? null : { text: fullHtml.slice(startPos, close + 1), name: open[1] ?? '' };
     }
 
+    // Where a tag ends: After optional whitespace, at `>` or `/>`. Scanned by hand in a
+    // single pass, where a regex did the same with one execution per attribute.
+    function matchTagClose(/** @type {number} */ currentPos) {
+      let scan = currentPos;
+      let code = fullHtml.charCodeAt(scan);
+      while (isWhitespaceCode(code)) {
+        code = fullHtml.charCodeAt(++scan);
+      }
+      if (code === 62) { // `>`
+        return { len: scan - currentPos + 1, slash: '' };
+      }
+      if (code === 47 && fullHtml.charCodeAt(scan + 1) === 62) { // `/>`
+        return { len: scan - currentPos + 2, slash: '/' };
+      }
+      return null;
+    }
+
     function parseStartTag(/** @type {number} */ startPos) {
       startTagOpenY.lastIndex = startPos;
       const start = startTagOpenY.exec(fullHtml);
@@ -615,17 +652,16 @@ export class HTMLParser {
         };
         let consumed = start[0].length;
         let currentPos = startPos + consumed;
-        let end, attr;
+        let close, attr;
 
         // Safety limit: Max length of input to check for attributes
         // Protects against catastrophic backtracking on massive attribute values
         const MAX_ATTR_PARSE_LENGTH = 20000; // 20 KB should be enough for any reasonable tag
 
         while (true) {
-          // Check for closing tag first (sticky regex—no slicing)
-          startTagCloseY.lastIndex = currentPos;
-          end = startTagCloseY.exec(fullHtml);
-          if (end) {
+          // Check for closing tag first (manual scan, regex only for the unusual)
+          close = matchTagClose(currentPos);
+          if (close) {
             break;
           }
 
@@ -748,12 +784,13 @@ export class HTMLParser {
           match.attrs.push(attr);
         }
 
-        // Check for closing tag (sticky regex—no slicing)
-        startTagCloseY.lastIndex = currentPos;
-        end = startTagCloseY.exec(fullHtml);
-        if (end) {
-          match.unarySlash = end[1] ?? '';
-          consumed += (end[0] ?? '').length;
+        // Check for closing tag (manual scan, regex only for the unusual)
+        if (!close) {
+          close = matchTagClose(currentPos);
+        }
+        if (close) {
+          match.unarySlash = close.slash;
+          consumed += close.len;
           match.advance = consumed;
           return match;
         }

package/src/lib/option-definitions.js

@@ -183,7 +183,7 @@ const optionDefinitions = {
     type: 'boolean'
   },
   removeUnusedCSS: {
-    description: 'Remove rules from `style` elements whose class or ID selectors the document never references (requires `--minify-css`); note that class names only applied by external scripts cannot be detected—use `{"safelist": […]}` for those',
+    description: 'Remove rules from `style` elements whose class or ID selectors the document never references—use with `--minify-css`; note that class names only applied by external scripts cannot be detected—use `{"safelist": […]}` for those',
     type: 'jsonObject'
   },
   sortAttributes: {

package/src/lib/whitespace.js

@@ -169,6 +169,14 @@ function isHiddenInput(tagName, attrs) {
  * @param {Set<string>} inlineTextSet
  */
 function collapseWhitespaceSmart(str, prevTag, nextTag, prevAttrs, nextAttrs, options, inlineElements, inlineTextSet) {
+  if (!str) return str;
+
+  // Fast path: No whitespace at all—every decision below would leave `str`
+  // untouched (`collapseWhitespace` returns such strings unchanged)
+  if (!/[ \n\r\t\f\xA0]/.test(str)) {
+    return str;
+  }
+
   const prevTagName = prevTag && (prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag);
   const nextTagName = nextTag && (nextTag.charAt(0) === '/' ? nextTag.slice(1) : nextTag);
 
@@ -178,14 +186,17 @@ function collapseWhitespaceSmart(str, prevTag, nextTag, prevAttrs, nextAttrs, op
 
   let trimLeft = prevTag && !inlineElementsToKeepWhitespace.has(prevTag);
 
+  // Whether the text is whitespace only—one scan, shared by the checks below
+  // (`str` is known non-empty here)
+  const isPureWhitespace = !/\S/.test(str);
+
   // Smart default behavior: Collapse space after non-rendering elements (`type="hidden"`)
   // This happens even in basic `collapseWhitespace` mode (safe optimization)
-  if (!trimLeft && prevIsHidden && str && !/\S/.test(str)) {
+  if (!trimLeft && prevIsHidden && isPureWhitespace) {
     trimLeft = true;
   }
 
   // Aggressive mode: Collapse between all form controls (pure whitespace only)
-  const isPureWhitespace = str && !/\S/.test(str);
   if (!trimLeft && prevTagName && nextTagName &&
       options.collapseInlineTagWhitespace &&
       isPureWhitespace &&
@@ -208,7 +219,7 @@ function collapseWhitespaceSmart(str, prevTag, nextTag, prevAttrs, nextAttrs, op
   let trimRight = nextTag && !inlineElementsToKeepWhitespace.has(nextTag);
 
   // Smart default behavior: Collapse space before non-rendering elements (`type="hidden"`)
-  if (!trimRight && nextIsHidden && str && !/\S/.test(str)) {
+  if (!trimRight && nextIsHidden && isPureWhitespace) {
     trimRight = true;
   }