html-minifier-next 8.3.0 → 8.4.0

package/src/lib/content.js

@@ -1,6 +1,12 @@
+/**
+ * CSS and script content wrapping for minification
+ */
+
 import {
   jsonScriptTypes
 } from './constants.js';
+import { isExecutableScript } from './attributes.js';
+import { findTagEnd } from './utils.js';
 import { trimWhitespace } from './whitespace.js';
 
 /** @import { ProcessedOptions } from './options.js' */
@@ -99,6 +105,76 @@ async function processScript(text, options, currentAttrs, minifyHTML) {
   return text;
 }
 
+// A `script` element is walked in three steps rather than matched by one pattern—
+// a pattern spanning the whole element rescans the same text for every candidate
+// tag, which turns markup repeating `<script` or `</script` into a quadratic scan
+const RE_SCRIPT_START = /<script\b/gi;
+// A tag name ends at whitespace, a slash, or the closing bracket, so `</scriptx>` names a
+// different element and leaves the body running, as it does for the parser
+const RE_SCRIPT_END = /<\/script(?=[\s/>])/gi;
+const RE_TYPE_ATTRIBUTE = /(?:^|\s)type\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/i;
+
+/**
+ * Collects the bodies of executable inline scripts, in document order, so they can be
+ * minified as one batch ahead of the parse. Duplicates are dropped: The minifier is
+ * content-keyed, so the same body only needs dispatching once.
+ * @param {string} html
+ * @returns {Array<{code: string, isModule: boolean}>}
+ */
+function extractScriptBodies(html) {
+  /** @type {Array<{code: string, isModule: boolean}>} */
+  const bodies = [];
+  const seen = new Set();
+
+  RE_SCRIPT_START.lastIndex = 0;
+  let startTag;
+  while ((startTag = RE_SCRIPT_START.exec(html))) {
+    const tagEnd = findTagEnd(html, RE_SCRIPT_START.lastIndex);
+    if (tagEnd === -1) {
+      break;
+    }
+    // Script content is raw text, so the body runs to the first `</script`—
+    // no nesting to account for
+    RE_SCRIPT_END.lastIndex = tagEnd + 1;
+    const endTag = RE_SCRIPT_END.exec(html);
+    if (!endTag) {
+      break;
+    }
+    const closeEnd = html.indexOf('>', RE_SCRIPT_END.lastIndex);
+    if (closeEnd === -1) {
+      break;
+    }
+    // Resuming past the element is what keeps every character visited once
+    RE_SCRIPT_START.lastIndex = closeEnd + 1;
+
+    const code = html.slice(tagEnd + 1, endTag.index);
+    // Whitespace-only and external scripts carry no work the minifier would do
+    if (!code.trim()) {
+      continue;
+    }
+
+    const typeMatch = RE_TYPE_ATTRIBUTE.exec(html.slice(startTag.index + '<script'.length, tagEnd));
+    /** @type {Array<{name: string, value: string}>} */
+    const attrs = typeMatch
+      ? [{ name: 'type', value: typeMatch[1] ?? typeMatch[2] ?? typeMatch[3] ?? '' }]
+      : [];
+    if (!isExecutableScript('script', attrs) || hasJsonScriptType(attrs)) {
+      continue;
+    }
+
+    // Module and classic scripts minify differently, so identical bodies in the two
+    // modes stay separate entries
+    const isModule = trimWhitespace((attrs[0]?.value ?? '')).toLowerCase() === 'module';
+    const key = (isModule ? 'm|' : '|') + code;
+    if (!seen.has(key)) {
+      seen.add(key);
+      bodies.push({ code, isModule });
+    }
+  }
+
+  return bodies;
+}
+
 // Exports
 
 export {
@@ -109,5 +185,6 @@ export {
   // Scripts
   minifyJson,
   hasJsonScriptType,
+  extractScriptBodies,
   processScript
 };

package/src/lib/elements.js

@@ -1,3 +1,7 @@
+/**
+ * HTML element tag omission rules
+ */
+
 import {
   headerElements,
   descriptionElements,

package/src/lib/file-pool.js

@@ -0,0 +1,177 @@
+/**
+ * Worker pool for whole files, as the CLI’s directory runs need them
+ *
+ * This pools one kind of work—read a file, minify it, write it—rather than arbitrary
+ * tasks: The worker body, the message contract, and the result are all about files. The
+ * spawning and queueing below would generalize, but nothing else asks for it yet.
+ *
+ * Minifying a document is CPU-bound work on one thread, so a run over a directory
+ * serializes no matter how the files are awaited. Whole files are the unit handed to
+ * workers, which is what makes threads pay here: A document takes long enough that the
+ * thread it crosses costs a fraction of a percent, and files share no state, so nothing
+ * travels but paths, options, and the resulting sizes.
+ *
+ * Scaling is bounded by what each thread has to re-learn rather than by the cores: Every
+ * worker runs its own isolate and warms up its own JIT, so the useful worker count tops
+ * out well short of the core count.
+ *
+ * Node-only: cli.js loads this module lazily and minifies in process wherever worker
+ * threads are unavailable or the options can’t cross a structured clone.
+ */
+
+import fs from 'node:fs';
+import { isMainThread, parentPort, workerData, Worker } from 'node:worker_threads';
+
+// This module is its own worker entry point: The pool spawns it by URL and the branch
+// below runs in the spawned copy. Keeping both halves in one file keeps the message
+// contract in one place. The minifier is imported dynamically so that loading the
+// pool on the main thread doesn’t drag it in; only workers ever pay for it.
+if (!isMainThread && parentPort) {
+  const port = parentPort;
+  const { minify } = await import('../htmlminifier.js');
+  const { options, wantsLog } = workerData;
+
+  // The pool hands a worker one file at a time, so the file a diagnostic belongs to is
+  // simply the one in hand
+  let fileCurrent = '';
+
+  // `log` cannot cross a structured clone, so it is rebuilt here and forwarded, and only
+  // where the CLI has somewhere to put it. Whether the minifier logged an `Error` travels
+  // with the message: The CLI words those differently, and an error that crossed as a
+  // plain string would lose that wording.
+  const taskOptions = wantsLog
+    ? {
+        ...options,
+        log: (/** @type {unknown} */ message) => port.postMessage({
+          log: message instanceof Error ? message.message : String(message),
+          logIsError: message instanceof Error,
+          logFile: fileCurrent
+        })
+      }
+    : options;
+
+  port.on('message', async (/** @type {{id: number, inputFile: string, outputFile: string, dryRun: boolean}} */ task) => {
+    // Which step failed decides how the CLI words the failure, and reading and writing
+    // name different files
+    let stage = 'read';
+    try {
+      fileCurrent = task.inputFile;
+      const data = await fs.promises.readFile(task.inputFile, 'utf8');
+      stage = 'minify';
+      const minified = await minify(data, taskOptions);
+      if (!task.dryRun) {
+        stage = 'write';
+        await fs.promises.writeFile(task.outputFile, minified, 'utf8');
+      }
+      port.postMessage({
+        id: task.id,
+        originalSize: Buffer.byteLength(data, 'utf8'),
+        minifiedSize: Buffer.byteLength(minified, 'utf8')
+      });
+    } catch (err) {
+      port.postMessage({ id: task.id, stage, error: err instanceof Error ? err.message : String(err) });
+    }
+  });
+}
+
+const urlWorker = new URL(import.meta.url);
+
+/**
+ * @param {object} args
+ * @param {import('../htmlminifier.js').MinifierOptions} args.options
+ * @param {number} args.size
+ * @param {((message: string, isError: boolean, file: string) => void) | undefined} [args.onLog]
+ */
+export function createFilePool({ options, size, onLog }) {
+  /** @type {Worker[]} */
+  const workers = [];
+  /** @type {Worker[]} */
+  const idle = [];
+  /** @type {Map<number, {resolve: (value: {originalSize: number, minifiedSize: number}) => void, reject: (reason: Error) => void}>} */
+  const pending = new Map();
+  /** @type {{task: object, resolve: Function, reject: Function}[]} */
+  const queue = [];
+  let idNext = 0;
+  /** @type {Error | null} */
+  let failure = null;
+  let closing = false;
+  const wantsLog = Boolean(onLog);
+
+  // A worker that dies takes its task with it, and any task still queued would wait for a
+  // turn that never comes; both are failed at once so the run ends rather than hangs
+  const failAll = (/** @type {Error} */ err) => {
+    failure = err;
+    for (const { reject } of pending.values()) reject(err);
+    pending.clear();
+    for (const item of queue.splice(0)) item.reject(err);
+  };
+
+  for (let i = 0; i < size; i++) {
+    // Workers inherit the parent’s `execArgv`, which can carry flags that are invalid for
+    // a module worker and would kill it on startup
+    const worker = new Worker(urlWorker, { workerData: { options, wantsLog }, execArgv: [] });
+    worker.unref();
+    worker.on('message', (/** @type {{id?: number, log?: string, logIsError?: boolean, logFile?: string, error?: string, stage?: string, originalSize?: number, minifiedSize?: number}} */ message) => {
+      if (message.log !== undefined) {
+        onLog?.(message.log, Boolean(message.logIsError), message.logFile ?? '');
+        return;
+      }
+      const entry = pending.get(/** @type {number} */ (message.id));
+      pending.delete(/** @type {number} */ (message.id));
+      idle.push(worker);
+      if (!pending.size && !queue.length) worker.unref();
+      drain();
+      if (!entry) return;
+      if (message.error !== undefined) {
+        const err = new Error(message.error);
+        // Which step failed rides along so the CLI can word the failure as it does for a
+        // file it minified itself
+        if (message.stage) /** @type {any} */ (err).stage = message.stage;
+        entry.reject(err);
+      } else {
+        entry.resolve({ originalSize: message.originalSize ?? 0, minifiedSize: message.minifiedSize ?? 0 });
+      }
+    });
+    worker.on('error', failAll);
+    // A worker can also go without an `error`—killed for memory, or exiting on its own.
+    // Its tasks would then wait forever, so an exit before `close()` ends the run, too
+    worker.on('exit', (/** @type {number} */ code) => {
+      if (closing || failure) return;
+      const index = idle.indexOf(worker);
+      if (index !== -1) idle.splice(index, 1);
+      failAll(new Error(`Worker stopped unexpectedly (exit code ${code})`));
+    });
+    workers.push(worker);
+    idle.push(worker);
+  }
+
+  function drain() {
+    while (idle.length && queue.length) {
+      const worker = /** @type {Worker} */ (idle.pop());
+      const item = /** @type {{task: object, resolve: Function, reject: Function}} */ (queue.shift());
+      const id = idNext++;
+      pending.set(id, /** @type {any} */ ({ resolve: item.resolve, reject: item.reject }));
+      // Only a worker with something outstanding may hold the process open
+      worker.ref();
+      worker.postMessage({ ...item.task, id });
+    }
+  }
+
+  return {
+    /**
+     * @param {{inputFile: string, outputFile: string, dryRun: boolean}} task
+     * @returns {Promise<{originalSize: number, minifiedSize: number}>}
+     */
+    run(task) {
+      if (failure) return Promise.reject(failure);
+      return new Promise((resolve, reject) => {
+        queue.push({ task, resolve, reject });
+        drain();
+      });
+    },
+    async close() {
+      closing = true;
+      await Promise.all(workers.map(worker => worker.terminate()));
+    }
+  };
+}

package/src/lib/option-definitions.js

@@ -1,4 +1,6 @@
-// Single source of truth for minifier option names, descriptions, types, and shared defaults
+/**
+ * Single source of truth for minifier option names, descriptions, types, and shared defaults
+ */
 
 /**
  * @typedef {object} OptionDefinition

package/src/lib/options.js

@@ -1,3 +1,7 @@
+/**
+ * Options processing and per-document minification state
+ */
+
 import { createUrlMinifier } from './urls.js';
 import { LRU, MAX_CACHE_ENTRY_SIZE, stableStringify, hashContent, identity, lowercase, paramCase, replaceAsync, parseRegExp, describeQuantifierRisk, lostFlag } from './utils.js';
 import { RE_TRAILING_SEMICOLON } from './constants.js';
@@ -45,6 +49,7 @@ import { optionDefinitions, optionDefaults } from './option-definitions.js';
  *   minifySVG: ((svgContent: string) => string | Promise<string>) | null,
  *   removeUnusedCSS: {safelist: Array<string | RegExp>, scripts: boolean} | null,
  *   cssContext?: CSSContext,
+ *   parallelJS?: boolean,
  *   nameParent?: (name: string) => string,
  *   nameHTML?: (name: string) => string,
  *   keepClosingSlashHTML?: boolean,
@@ -532,6 +537,13 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
           return text;
         }
       };
+
+      // Whether dispatching script bodies ahead of the parse pays off. It needs a minifier
+      // that leaves the main thread—SWC hands work to its own threadpool, where overlapping
+      // calls genuinely run at once, while Terser would only compete with the parse for the
+      // one thread both share. A user-supplied `minifyJS` is excluded either way—only this
+      // wrapper is content-keyed and free of side effects.
+      options.parallelJS = engine === 'swc';
     } else if (key === 'minifyURLs' && typeof option !== 'function') {
       if (!option) {
         return;

package/src/lib/unused-css.js

@@ -1,4 +1,6 @@
-// Unused-CSS removal
+/**
+ * Unused-CSS removal
+ */
 
 import { findTagEnd } from './utils.js';
 

package/src/lib/utils.js

@@ -1,4 +1,6 @@
-// Stringify for options signatures (sorted keys, shallow, nested objects)
+/**
+ * General utility functions
+ */
 
 /**
  * @param {unknown} obj

package/src/lib/whitespace.js

@@ -1,3 +1,7 @@
+/**
+ * Whitespace trimming and collapsing
+ */
+
 import {
   RE_WS_START,
   RE_WS_END,