html-minifier-next 8.4.0 → 8.4.2

package/README.md

@@ -36,13 +36,13 @@ Use `npx html-minifier-next --help` to check all available options:
 | `--input-dir <dir>`, `-I <dir>` | Specify an input directory | `--input-dir=src` |
 | `--ignore-dir <patterns>`, `-X <patterns>` | Exclude directories—relative to input directory—from processing (comma-separated, overrides config file setting) | `--ignore-dir=libs`, `--ignore-dir=libs,vendor,node_modules` |
 | `--output-dir <dir>`, `-O <dir>` | Specify an output directory | `--output-dir=dist` |
-| `--workers <n>`, `-w <n>` | Number of worker threads for multi-file runs; defaults to half the available cores, at most 6, for runs of 128 files or more (below that threads cost more than they save) | `--workers=4` |
+| `--workers <n>`, `-w <n>` | Number of worker threads for multi-file runs; defaults to half the available cores (at most 6) for runs large enough to justify them | `--workers=4` |
 | `--input <file>`, `-i <file>` | Specify input file (alternative to positional argument; pair with `--output` for file output) | `npx html-minifier-next -i input.html -o output.html` |
 | `--output <file>`, `-o <file>` | Specify output file (reads from `--input` file argument or STDIN; outputs to STDOUT if not specified) | File to file: `npx html-minifier-next input.html -o output.html`<br>File to file (explicit): `npx html-minifier-next -i input.html -o output.html`<br>Pipe to file: `cat input.html \| npx html-minifier-next -o output.html`<br>File to STDOUT: `npx html-minifier-next input.html` |
 | `--file-ext <extensions>`, `-f <extensions>` | Specify file extension(s) to process (comma-separated, overrides config file setting); defaults to `html,htm,shtml,shtm`; use `*` for all files | `--file-ext=html,php`, `--file-ext='*'` |
 | `--preset <name>`, `-p <name>` | Use a preset configuration (conservative or comprehensive) | `--preset=conservative` |
 | `--config-file <file>`, `-c <file>` | Use a configuration file (defaults to html-minifier-next.config.json in the working directory, if present) | `--config-file=path/to/config.json` |
-| `--verbose`, `-v` | Show detailed processing information (active options, file statistics, and minifier warnings) | `npx html-minifier-next --input-dir=src --output-dir=dist --verbose --collapse-whitespace` |
+| `--verbose`, `-v` | Show detailed processing information (active options, worker thread count, file statistics, and minifier warnings) | `npx html-minifier-next --input-dir=src --output-dir=dist --verbose --collapse-whitespace` |
 | `--dry`, `-d` | Dry run: Process and report statistics without writing output | `npx html-minifier-next input.html --dry --collapse-whitespace` |
 
 ### Configuration file

package/cli.js

@@ -197,7 +197,7 @@ Object.entries(optionDefinitions).forEach(function ([key, { description, descrip
 });
 program.option('-i --input <file>', 'Specify input file (alternative to positional argument; pair with `--output` for output)');
 program.option('-o --output <file>', 'Specify output file (reads from `--input` file argument or STDIN; outputs to STDOUT if not specified)');
-program.option('-v --verbose', 'Show detailed processing information');
+program.option('-v --verbose', 'Show detailed processing information (active options, worker thread count, file statistics, and minifier warnings)');
 program.option('-d --dry', 'Dry run: Process and report statistics without writing output');
 program.addHelpText('after', '\nBoolean options support a `--no-<flag>` form to disable them, overriding a preset or config file (e.g., `--preset=comprehensive --no-collapse-whitespace`).');
 
@@ -312,7 +312,7 @@ program.option('-z, --zero', 'Minify all HTML files in the current folder and it
 program.option('-I --input-dir <dir>', 'Specify an input directory');
 program.option('-X --ignore-dir <patterns>', 'Exclude directories—relative to input directory—from processing (comma-separated, overrides config file setting)');
 program.option('-O --output-dir <dir>', 'Specify an output directory');
-program.option('-w --workers <n>', 'Number of worker threads for multi-file runs; defaults to half the available cores, at most 6, for runs of 128 files or more (below that threads cost more than they save)', parseValidInt('workers'));
+program.option('-w --workers <n>', 'Number of worker threads for multi-file runs; defaults to half the available cores (at most 6) for runs large enough to justify them', parseValidInt('workers'));
 program.option('-f --file-ext <extensions>', 'Specify file extension(s) to process (comma-separated, overrides config file setting); defaults to `html,htm,shtml,shtm`; use `*` for all files');
 program.option('-p --preset <name>', `Use a preset configuration (${getPresetNames().join(', ')})`);
 program.option('-c --config-file <file>', 'Use a configuration file (defaults to html-minifier-next.config.json in the working directory, if present)');
@@ -543,19 +543,29 @@ program.helpOption('-h, --help', 'Display help for command');
     return { originalSize, minifiedSize, saved, sign, percentage };
   }
 
-  // Below this many files the threads spend more time warming up than they save: Each
-  // runs its own isolate and so warms its own JIT, which a short run never earns back
+  // A run with many files earns back each worker’s isolate/JIT startup cost. A smaller
+  // run can do so too when it carries enough bytes to share out, which a file count
+  // alone cannot see.
   const FILES_PER_RUN_MIN = 128;
+  const PARALLEL_BYTES_MIN = 2 * 1024 * 1024;
   // Each worker warms up its own JIT, so the useful count tops out well short of the cores
   const WORKERS_MAX = 6;
 
   /**
    * A pool for this run, or `null` where one wouldn’t pay or wouldn’t work—in which case
    * the caller minifies in process exactly as before
-   * @param {number} fileCount
+   * @param {string[]} files
    */
-  async function createPool(fileCount) {
+  async function createPool(files) {
+    const fileCount = files.length;
     const requested = programOptions.workers;
+    const isVerbose = Boolean(programOptions.verbose || programOptions.dry);
+    // Whether the run went wide is worth saying, since the default weighs the file
+    // count and the bytes there are to share out, neither of which the caller sees
+    const inProcess = () => {
+      if (isVerbose) console.error('Worker threads: none (minifying in process)');
+      return null;
+    };
     // `availableParallelism` reports what this process may actually use, which under a
     // CPU affinity mask—a container, commonly—is less than the machine’s core count
     const isDefault = requested === undefined;
@@ -565,8 +575,21 @@ program.helpOption('-h, --help', 'Display help for command');
 
     // The file count only decides the default; asking for workers outright is the
     // caller’s judgment to make, whatever the run looks like
-    if (size <= 1 || (isDefault && fileCount < FILES_PER_RUN_MIN)) {
-      return null;
+    if (size <= 1) {
+      return inProcess();
+    }
+
+    if (isDefault && fileCount < FILES_PER_RUN_MIN) {
+      // `stat()` is cheaper than starting workers and is only needed for a run that
+      // would otherwise stay in-process. A failed stat leaves normal file processing
+      // to report the read error with its usual filename and wording.
+      const sizes = await Promise.all(files.map(file => fs.promises.stat(file).then(stat => stat.size, () => 0)));
+      // No single file is split across workers, so the largest one sets a floor no
+      // pool can beat; what the rest carry is the work there is to share out
+      const parallelBytes = sizes.reduce((sum, byteSize) => sum + byteSize, 0) - Math.max(0, ...sizes);
+      if (parallelBytes < PARALLEL_BYTES_MIN) {
+        return inProcess();
+      }
     }
 
     // `log` is a closure over this process’s console and is rebuilt inside the worker;
@@ -575,22 +598,31 @@ program.helpOption('-h, --help', 'Display help for command');
     try {
       structuredClone(options);
     } catch {
-      return null;
+      return inProcess();
+    }
+
+    // A pool this small has nothing to share out and still pays for its workers, so an
+    // explicit request for them lands in process as `--workers=1` does
+    const poolSize = Math.min(size, fileCount);
+    if (poolSize <= 1) {
+      return inProcess();
     }
 
     try {
       const { createFilePool } = await import('./src/lib/file-pool.js');
-      return createFilePool({
+      const pool = createFilePool({
         options,
-        size: Math.min(size, fileCount),
+        size: poolSize,
         // `log` is only set when the run asks for diagnostics
         onLog: log
           ? (/** @type {string} */ message, /** @type {boolean} */ isError, /** @type {string} */ file) =>
             createLog(path.relative(process.cwd(), file))(isError ? new Error(message) : message)
           : undefined
       });
+      if (isVerbose) console.error(`Worker threads: ${poolSize}`);
+      return pool;
     } catch {
-      return null;
+      return inProcess();
     }
   }
 
@@ -891,7 +923,7 @@ program.helpOption('-h, --help', 'Display help for command');
       }
     };
 
-    const pool = await createPool(list.length);
+    const pool = await createPool(list);
     if (pool) {
       try {
         await Promise.all(list.map(async (inputFile, idx) => {

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

@@ -1 +1 @@
-{"version":3,"file":"whitespace.d.ts","sourceRoot":"","sources":["../../../src/lib/whitespace.js"],"names":[],"mappings":"AAAA;;GAEG;AAiBH,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"}
+{"version":3,"file":"whitespace.d.ts","sourceRoot":"","sources":["../../../src/lib/whitespace.js"],"names":[],"mappings":"AAAA;;GAEG;AAqBH,0BAA0B;AAC1B,QAAA,MAAM,cAAc,QADR,MAAM,WAQjB,CAAC;AAuBF,0BAA0B;AAC1B,iBAAS,qBAAqB,CAAC,GAAG,EADtB,MACsB,UAOjC;AAeD;;;;;;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,UAcjF;AAsHD;;;;;;;;;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,UA6DnH;AAcD,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/package.json

@@ -7,7 +7,7 @@
   "bugs": "https://github.com/j9t/html-minifier-next/issues",
   "dependencies": {
     "commander": "^15.0.0",
-    "entities": "^8.0.0",
+    "entities": "^8.1.0",
     "lightningcss": "^1.33.0",
     "svgo": "^4.1.0",
     "terser": "^5.51.2"
@@ -16,8 +16,8 @@
   "devDependencies": {
     "@commitlint/cli": "^21.2.2",
     "@eslint/js": "^10.0.1",
-    "@swc/core": "^1.16.1",
-    "@types/node": "^26.4.1",
+    "@swc/core": "^1.16.2",
+    "@types/node": "^26.5.0",
     "eslint": "^10.10.0",
     "globals": "^17.12.0",
     "typescript": "^7.0.2",
@@ -95,5 +95,5 @@
   },
   "type": "module",
   "types": "dist/types/htmlminifier.d.ts",
-  "version": "8.4.0"
+  "version": "8.4.2"
 }

package/src/lib/whitespace.js

@@ -3,8 +3,6 @@
  */
 
 import {
-  RE_WS_START,
-  RE_WS_END,
   RE_ALL_WS_NBSP,
   RE_NBSP_LEADING_GROUP,
   RE_NBSP_LEAD_GROUP,
@@ -15,37 +13,64 @@ import {
   formControlElements
 } from './constants.js';
 
+const RE_ANY_WS_NBSP = /[ \n\r\t\f\xA0]/;
+const RE_TAB_NBSP = /[\t\xA0]/;
+const RE_ASCII_WS_RUN = /[ \n\r\f]+/g;
+const RE_NEEDS_COLLAPSE = /[\n\r\f]| {2}/;
+const RE_NON_WS = /\S/;
+
 // Trim whitespace
 
 /** @param {string} str */
 const trimWhitespace = str => {
   if (!str) return str;
-  // Fast path: If no whitespace at start or end, return early
-  if (!/^[ \n\r\t\f]/.test(str) && !/[ \n\r\t\f]$/.test(str)) {
-    return str;
-  }
-  return str.replace(RE_WS_START, '').replace(RE_WS_END, '');
+  let start = 0;
+  let end = str.length;
+  while (start < end && isAsciiWs(str.charCodeAt(start))) start++;
+  while (end > start && isAsciiWs(str.charCodeAt(end - 1))) end--;
+  return start === 0 && end === str.length ? str : str.slice(start, end);
 };
 
+/** @param {number} code */
+function isAsciiWs(code) {
+  return code === 32 || code === 10 || code === 13 || code === 9 || code === 12;
+}
+
+/** @param {number} code */
+function isWsOrNbsp(code) {
+  return code === 32 || code === 10 || code === 13 || code === 9 || code === 12 || code === 160;
+}
+
 // Collapse all whitespace
 
+// Module scope so the hot path doesn’t allocate a closure per call
+/** @param {string} spaces */
+function collapseRun(spaces) {
+  // Preserve standalone tabs
+  if (spaces === '\t') return '\t';
+  if (spaces.indexOf('\xA0') === -1) return ' ';
+  return spaces.replace(RE_NBSP_LEADING_GROUP, '$1 ');
+}
+
 /** @param {string} str */
 function collapseWhitespaceAll(str) {
   if (!str) return str;
   // Fast path: If there are no common whitespace characters, return early
-  if (!/[ \n\r\t\f\xA0]/.test(str)) {
+  if (!RE_ANY_WS_NBSP.test(str)) {
     return str;
   }
-  // No-break space is specifically handled inside the replacer function here:
-  return str.replace(RE_ALL_WS_NBSP, function (/** @param {string} spaces */ spaces) {
-    // Preserve standalone tabs
-    if (spaces === '\t') return '\t';
-    // Fast path: No no-break space, common case—just collapse to single space
-    // This avoids the nested regex for the majority of cases
-    if (spaces.indexOf('\xA0') === -1) return ' ';
-    // For no-break space handling, use the nested regex
-    return spaces.replace(RE_NBSP_LEADING_GROUP, '$1 ');
-  });
+  return collapseWhitespaceAllKnown(str);
+}
+
+// As `collapseWhitespaceAll`, for callers that already know `str` holds whitespace
+/** @param {string} str */
+function collapseWhitespaceAllKnown(str) {
+  // Only a tab or a no-break space makes the replacement depend on the run itself;
+  // without either, every run becomes one space and no per-match callback is needed
+  if (!RE_TAB_NBSP.test(str)) {
+    return RE_NEEDS_COLLAPSE.test(str) ? str.replace(RE_ASCII_WS_RUN, ' ') : str;
+  }
+  return str.replace(RE_ALL_WS_NBSP, collapseRun);
 }
 
 // Collapse whitespace with options
@@ -58,8 +83,6 @@ function collapseWhitespaceAll(str) {
  * @param {boolean} [collapseAll]
  */
 function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll = false) {
-  let lineBreakBefore = ''; let lineBreakAfter = '';
-
   if (!str) return str;
 
   // Fast path: Nothing to do
@@ -68,16 +91,30 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll = fal
   }
 
   // Fast path: No whitespace at all
-  if (!/[ \n\r\t\f\xA0]/.test(str)) {
+  if (!RE_ANY_WS_NBSP.test(str)) {
     return str;
   }
 
+  return collapseWhitespaceKnown(str, options, trimLeft, trimRight, collapseAll);
+}
+
+// As `collapseWhitespace`, for callers that already know `str` is non-empty, holds
+// whitespace, and has something to do
+/**
+ * @param {string} str
+ * @param {{preserveLineBreaks?: boolean | undefined, conservativeCollapse?: boolean | undefined}} options
+ * @param {boolean} trimLeft
+ * @param {boolean} trimRight
+ * @param {boolean} collapseAll
+ */
+function collapseWhitespaceKnown(str, options, trimLeft, trimRight, collapseAll) {
+  let lineBreakBefore = ''; let lineBreakAfter = '';
+
   if (options.preserveLineBreaks) {
     // Find leading/trailing whitespace containing line breaks manually
     // (avoids polynomial backtracking with end-anchored lazy quantifiers)
-    const WS_CHARS = ' \n\r\t\f';
     let leadEnd = 0;
-    while (leadEnd < str.length && WS_CHARS.includes(str.charAt(leadEnd))) {
+    while (leadEnd < str.length && isAsciiWs(str.charCodeAt(leadEnd))) {
       leadEnd++;
     }
     if (leadEnd > 0) {
@@ -88,7 +125,7 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll = fal
       }
     }
     let trailStart = str.length;
-    while (trailStart > 0 && WS_CHARS.includes(str.charAt(trailStart - 1))) {
+    while (trailStart > 0 && isAsciiWs(str.charCodeAt(trailStart - 1))) {
       trailStart--;
     }
     if (trailStart < str.length) {
@@ -101,21 +138,34 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll = fal
   }
 
   if (trimLeft) {
-    // No-break space is specifically handled inside the replacer function
-    str = str.replace(/^[ \n\r\t\f\xA0]+/, function (/** @type {string} */ spaces) {
+    // Find the leading whitespace boundary with a loop, so the common case neither
+    // allocates a replacer closure nor runs the regex machinery
+    let start = 0;
+    while (start < str.length && isWsOrNbsp(str.charCodeAt(start))) {
+      start++;
+    }
+    if (start > 0) {
+      const spaces = str.slice(0, start);
       const conservative = !lineBreakBefore && options.conservativeCollapse;
+      let replacement;
       if (conservative && spaces === '\t') {
-        return '\t';
+        replacement = '\t';
+      } else if (spaces.indexOf('\xA0') === -1) {
+        // No no-break space: The whole run goes
+        replacement = conservative ? ' ' : '';
+      } else {
+        // No-break space is specifically handled via the nested regexes
+        replacement = spaces.replace(/^[^\xA0]+/, '').replace(RE_NBSP_LEAD_GROUP, '$1 ') || (conservative ? ' ' : '');
       }
-      return spaces.replace(/^[^\xA0]+/, '').replace(RE_NBSP_LEAD_GROUP, '$1 ') || (conservative ? ' ' : '');
-    });
+      str = replacement + str.slice(start);
+    }
   }
 
   if (trimRight) {
     // Find trailing whitespace boundary manually (avoids polynomial backtracking
     // with `/[ \n\r\t\f\xA0]+$/` on strings with long internal whitespace runs)
     let end = str.length;
-    while (end > 0 && ' \n\r\t\f\xA0'.includes(str.charAt(end - 1))) {
+    while (end > 0 && isWsOrNbsp(str.charCodeAt(end - 1))) {
       end--;
     }
     if (end < str.length) {
@@ -124,6 +174,9 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll = fal
       let replacement;
       if (conservative && spaces === '\t') {
         replacement = '\t';
+      } else if (spaces.indexOf('\xA0') === -1) {
+        // No no-break space: The whole run goes
+        replacement = conservative ? ' ' : '';
       } else {
         // No-break space is specifically handled via the nested regexes
         replacement = spaces.replace(RE_NBSP_TRAILING_GROUP, ' $1').replace(RE_NBSP_TRAILING_STRIP, '') || (conservative ? ' ' : '');
@@ -132,9 +185,9 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll = fal
     }
   }
 
-  if (collapseAll) {
+  if (collapseAll && str) {
     // Strip non-space whitespace then compress spaces to one
-    str = collapseWhitespaceAll(str);
+    str = collapseWhitespaceAllKnown(str);
   }
 
   // Avoid string concatenation when no line breaks (common case)
@@ -149,11 +202,10 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll = fal
 // Check if an input element has `type="hidden"`; module-scope so the hot path
 // doesn’t allocate a closure per text node
 /**
- * @param {string} tagName
  * @param {Array<{name: string, value?: string}>} attrs
  */
-function isHiddenInput(tagName, attrs) {
-  if (tagName !== 'input' || !attrs || !attrs.length) return false;
+function isHiddenInput(attrs) {
+  if (!attrs || !attrs.length) return false;
   for (const attr of attrs) {
     if (attr.name === 'type') {
       return attr.value === 'hidden';
@@ -177,77 +229,67 @@ function collapseWhitespaceSmart(str, prevTag, nextTag, prevAttrs, nextAttrs, op
 
   // 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)) {
+  if (!RE_ANY_WS_NBSP.test(str)) {
     return str;
   }
 
-  const prevTagName = prevTag && (prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag);
-  const nextTagName = nextTag && (nextTag.charAt(0) === '/' ? nextTag.slice(1) : nextTag);
-
-  // Check if prev/next are non-rendering (hidden) elements
-  const prevIsHidden = isHiddenInput(prevTagName, prevAttrs);
-  const nextIsHidden = isHiddenInput(nextTagName, nextAttrs);
-
-  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);
+  const inlineOption = Boolean(options.collapseInlineTagWhitespace);
 
-  // Smart default behavior: Collapse space after non-rendering elements (`type="hidden"`)
-  // This happens even in basic `collapseWhitespace` mode (safe optimization)
-  if (!trimLeft && prevIsHidden && isPureWhitespace) {
-    trimLeft = true;
-  }
-
-  // Aggressive mode: Collapse between all form controls (pure whitespace only)
-  if (!trimLeft && prevTagName && nextTagName &&
-      options.collapseInlineTagWhitespace &&
-      isPureWhitespace &&
-      formControlElements.has(prevTagName) && formControlElements.has(nextTagName)) {
-    trimLeft = true;
-  }
+  let trimLeft = Boolean(prevTag) && !inlineElementsToKeepWhitespace.has(prevTag);
+  let trimRight = Boolean(nextTag) && !inlineElementsToKeepWhitespace.has(nextTag);
 
-  if (trimLeft && !options.collapseInlineTagWhitespace) {
-    trimLeft = prevTag.charAt(0) === '/' ? !inlineElements.has(prevTag.slice(1)) : !inlineTextSet.has(prevTag);
-  }
+  // Every branch below that consults the text’s content needs a side left untrimmed,
+  // so the scan for a non-whitespace character is only worth making then
+  const isPureWhitespace = (!trimLeft || !trimRight) && !RE_NON_WS.test(str);
 
-  // When `collapseInlineTagWhitespace` is enabled, still preserve whitespace around inline text elements
-  if (trimLeft && options.collapseInlineTagWhitespace) {
-    const tagName = prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag;
-    if (inlineElementsToKeepWhitespaceWithin.has(tagName)) {
-      trimLeft = false;
+  if (isPureWhitespace) {
+    // Smart default behavior: Collapse space around non-rendering elements
+    // (`type="hidden"`); this happens even in basic `collapseWhitespace` mode
+    if (!trimLeft && prevTag === 'input' && isHiddenInput(prevAttrs)) {
+      trimLeft = true;
+    }
+    if (!trimRight && nextTag === 'input' && isHiddenInput(nextAttrs)) {
+      trimRight = true;
+    }
+    // Aggressive mode: Collapse between all form controls
+    if (inlineOption && (!trimLeft || !trimRight) &&
+        formControlElements.has(stripSlash(prevTag)) && formControlElements.has(stripSlash(nextTag))) {
+      trimLeft = true;
+      trimRight = true;
     }
   }
 
-  let trimRight = nextTag && !inlineElementsToKeepWhitespace.has(nextTag);
-
-  // Smart default behavior: Collapse space before non-rendering elements (`type="hidden"`)
-  if (!trimRight && nextIsHidden && isPureWhitespace) {
-    trimRight = true;
-  }
-
-  // Aggressive mode: Same as `trimLeft`
-  if (!trimRight && prevTagName && nextTagName &&
-      options.collapseInlineTagWhitespace &&
-      isPureWhitespace &&
-      formControlElements.has(prevTagName) && formControlElements.has(nextTagName)) {
-    trimRight = true;
+  if (trimLeft) {
+    if (inlineOption) {
+      // Still preserve whitespace around inline text elements
+      if (inlineElementsToKeepWhitespaceWithin.has(stripSlash(prevTag))) {
+        trimLeft = false;
+      }
+    } else {
+      trimLeft = prevTag.charCodeAt(0) === 47 /* / */ ? !inlineElements.has(prevTag.slice(1)) : !inlineTextSet.has(prevTag);
+    }
   }
 
-  if (trimRight && !options.collapseInlineTagWhitespace) {
-    trimRight = nextTag.charAt(0) === '/' ? !inlineTextSet.has(nextTag.slice(1)) : !inlineElements.has(nextTag);
+  if (trimRight) {
+    if (inlineOption) {
+      if (inlineElementsToKeepWhitespaceWithin.has(stripSlash(nextTag))) {
+        trimRight = false;
+      }
+    } else {
+      trimRight = nextTag.charCodeAt(0) === 47 /* / */ ? !inlineTextSet.has(nextTag.slice(1)) : !inlineElements.has(nextTag);
+    }
   }
 
-  // When `collapseInlineTagWhitespace` is enabled, still preserve whitespace around inline text elements
-  if (trimRight && options.collapseInlineTagWhitespace) {
-    const tagName = nextTag.charAt(0) === '/' ? nextTag.slice(1) : nextTag;
-    if (inlineElementsToKeepWhitespaceWithin.has(tagName)) {
-      trimRight = false;
-    }
+  const collapseAll = Boolean(prevTag && nextTag);
+  if (!trimLeft && !trimRight && !collapseAll && !options.preserveLineBreaks) {
+    return str;
   }
+  return collapseWhitespaceKnown(str, options, trimLeft, trimRight, collapseAll);
+}
 
-  return collapseWhitespace(str, options, Boolean(trimLeft), Boolean(trimRight), Boolean(prevTag && nextTag));
+/** @param {string} tag */
+function stripSlash(tag) {
+  return tag && tag.charCodeAt(0) === 47 /* / */ ? tag.slice(1) : tag;
 }
 
 // Collapse/trim whitespace for given tag