html-minifier 3.5.21 → 5.0.0

package/src/lib/content.js

@@ -0,0 +1,237 @@
+/**
+ * CSS and script content wrapping for minification
+ */
+
+import {
+  RE_ESCAPE_LT,
+  jsonScriptTypes
+} from './constants.js';
+import { isExecutableScript } from './attributes.js';
+import { findTagEnd } from './utils.js';
+import { trimWhitespace } from './whitespace.js';
+
+/** @import { ProcessedOptions } from './options.js' */
+
+// CSS processing
+
+// Give bare declarations and media queries a parseable context for CSS minifiers
+/**
+ * @param {string} text
+ * @param {string} [type]
+ */
+function wrapCSS(text, type) {
+  switch (type) {
+    case 'inline':
+      return '*{' + text + '}';
+    case 'media':
+      return '@media ' + text + '{a{top:0}}';
+    default:
+      return text;
+  }
+}
+
+/**
+ * @param {string} text
+ * @param {string} [type]
+ */
+function unwrapCSS(text, type) {
+  let matches;
+  switch (type) {
+    case 'inline':
+      matches = text.match(/^\*\{([\s\S]*)\}$/);
+      break;
+    case 'media':
+      matches = text.match(/^@media ([\s\S]*?)\s*{[\s\S]*}$/);
+      break;
+  }
+  return matches ? matches[1] ?? text : text;
+}
+
+// Script processing
+
+/** @param {number} code */
+function isJsonWhitespace(code) {
+  return code === 32 || code === 10 || code === 13 || code === 9;
+}
+
+// Remove whitespace between tokens of valid JSON in one pass, copying strings as written
+// unless they hold escapes (re-serialized to shorten them) or `<` (escaped)
+/** @param {string} text */
+function stripJsonWhitespace(text) {
+  const length = text.length;
+  let out = '';
+  let start = 0;
+  let i = 0;
+  while (i < length) {
+    const code = text.charCodeAt(i);
+    if (code === 34) { // `"`
+      let end = i + 1;
+      let hasEscape = false;
+      let hasLt = false;
+      for (;;) {
+        const c = text.charCodeAt(end);
+        if (c === 34) break;
+        if (c === 92) { // `\`
+          hasEscape = true;
+          end += 2;
+          continue;
+        }
+        if (c === 60) hasLt = true; // `<`
+        end++;
+      }
+      if (hasEscape || hasLt) {
+        let string = text.slice(i, end + 1);
+        if (hasEscape) string = JSON.stringify(JSON.parse(string));
+        out += text.slice(start, i) + string.replace(RE_ESCAPE_LT, '\\u003C');
+        start = end + 1;
+      }
+      i = end + 1;
+    } else if (isJsonWhitespace(code)) {
+      out += text.slice(start, i);
+      do i++;
+      while (i < length && isJsonWhitespace(text.charCodeAt(i)));
+      start = i;
+    } else {
+      i++;
+    }
+  }
+  return out + text.slice(start);
+}
+
+// Minify JSON script content, keeping `<` escaped—parsing only validates,
+// as serializing the parsed value would change some values (e.g., large numbers)
+/**
+ * @param {string} text
+ * @param {{continueOnMinifyError?: boolean, log: Function}} options
+ */
+function minifyJson(text, options) {
+  try {
+    JSON.parse(text);
+    return stripJsonWhitespace(text);
+  }
+  catch (err) {
+    if (!options.continueOnMinifyError) {
+      throw err;
+    }
+    options.log(err);
+    return text;
+  }
+}
+
+/** @param {Array<{name: string, value?: string}>} attrs */
+function hasJsonScriptType(attrs) {
+  for (const attr of attrs) {
+    if (attr.name.toLowerCase() === 'type') {
+      const attrValue = trimWhitespace((attr.value || '').split(/;/, 2)[0] ?? '').toLowerCase();
+      if (jsonScriptTypes.has(attrValue)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+/**
+ * @param {string} text
+ * @param {ProcessedOptions} options
+ * @param {string} tag
+ * @param {Array<{name: string, value?: string | undefined}>} currentAttrs
+ * @param {Function} minifyHTML
+ */
+async function processScript(text, options, tag, currentAttrs, minifyHTML) {
+  for (const attr of currentAttrs) {
+    const attrName = attr.name.toLowerCase();
+    if (attrName === 'type') {
+      const rawValue = attr.value;
+      const normalizedValue = trimWhitespace((rawValue || '').split(/;/, 2)[0] ?? '').toLowerCase();
+      if (tag === 'script' && jsonScriptTypes.has(normalizedValue)) {
+        return options.minifyJSON ? minifyJson(text, options) : text;
+      }
+      if (options.processScripts && rawValue && options.processScripts.indexOf(rawValue) > -1) {
+        return await minifyHTML(text, options);
+      }
+    }
+  }
+  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;
+}
+
+export {
+  // CSS
+  wrapCSS,
+  unwrapCSS,
+
+  // Scripts
+  hasJsonScriptType,
+  extractScriptBodies,
+  processScript
+};

package/src/lib/elements.js

@@ -0,0 +1,268 @@
+/**
+ * HTML element tag omission rules
+ */
+
+import {
+  headerElements,
+  descriptionElements,
+  pBlockElements,
+  rubyEndTagOmission,
+  rubyRtcEndTagOmission,
+  optionElements,
+  tableContentElements,
+  tableSectionElements,
+  cellElements
+} from './constants.js';
+import { hasAttrName } from './attributes.js';
+
+/** @import { HTMLAttribute } from './attributes.js' */
+/** @import { ProcessedOptions } from './options.js' */
+
+/**
+ * @param {string} optionalStartTag
+ * @param {string} tag
+ */
+function canRemoveParentTag(optionalStartTag, tag) {
+  switch (optionalStartTag) {
+    case 'html':
+    case 'head':
+      return true;
+    case 'body':
+      return !headerElements.has(tag);
+    case 'colgroup':
+      return tag === 'col';
+    case 'tbody':
+      return tag === 'tr';
+  }
+  return false;
+}
+
+/**
+ * @param {string} optionalEndTag
+ * @param {string} tag
+ */
+function isStartTagMandatory(optionalEndTag, tag) {
+  switch (tag) {
+    case 'colgroup':
+      return optionalEndTag === 'colgroup';
+    case 'tbody':
+      return tableSectionElements.has(optionalEndTag);
+  }
+  return false;
+}
+
+/**
+ * @param {string} optionalEndTag
+ * @param {string} tag
+ */
+function canRemovePrecedingTag(optionalEndTag, tag) {
+  switch (optionalEndTag) {
+    case 'html':
+    case 'head':
+    case 'body':
+    case 'colgroup':
+    case 'caption':
+      return true;
+    case 'li':
+    case 'optgroup':
+    case 'tr':
+      return tag === optionalEndTag;
+    case 'dt':
+    case 'dd':
+      return descriptionElements.has(tag);
+    case 'p':
+      return pBlockElements.has(tag);
+    case 'rb':
+    case 'rt':
+    case 'rp':
+      return rubyEndTagOmission.has(tag);
+    case 'rtc':
+      return rubyRtcEndTagOmission.has(tag);
+    case 'option':
+      return optionElements.has(tag);
+    case 'thead':
+    case 'tbody':
+      return tableContentElements.has(tag);
+    case 'tfoot':
+      return tag === 'tbody';
+    case 'td':
+    case 'th':
+      return cellElements.has(tag);
+  }
+  return false;
+}
+
+/**
+ * @param {string} tag
+ * @param {HTMLAttribute[]} attrs
+ */
+function canRemoveElement(tag, attrs) {
+  // 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)) {
+    return false;
+  }
+
+  // Nor must elements that carry accessibility semantics, take focus, or point elsewhere
+  // with `for` (a `label` activates a control, an `output` shows its result, a `template`
+  // replaces content, even with nothing), unless the value is empty
+  const takesFor = tag === 'label' || tag === 'output' || tag === 'template';
+  for (const attr of attrs) {
+    const name = attr.name.toLowerCase();
+    if ((name === 'role' || name === 'tabindex' || name.startsWith('aria-') || (takesFor && name === 'for')) && attr.value?.trim()) {
+      return false;
+    }
+  }
+
+  // Custom elements and `canvas` are there for scripts to fill or draw into
+  if (tag.includes('-')) {
+    return false;
+  }
+
+  switch (tag) {
+    case 'canvas':
+    case 'textarea':
+      return false;
+    case 'audio':
+    case 'script':
+    case 'video':
+      if (hasAttrName('src', attrs)) {
+        return false;
+      }
+      break;
+    case 'iframe':
+      if (hasAttrName('src', attrs) || hasAttrName('srcdoc', attrs)) {
+        return false;
+      }
+      break;
+    case 'object':
+      if (hasAttrName('data', attrs)) {
+        return false;
+      }
+      break;
+    case 'applet':
+      if (hasAttrName('code', attrs)) {
+        return false;
+      }
+      break;
+  }
+  return true;
+}
+
+/**
+ * @param {string} str - Tag name or HTML-like element spec (e.g., `td` or `<span aria-hidden='true'>`)
+ * @param {ProcessedOptions} options - Options object for name normalization
+ * @returns {{tag: string, attrs: Object.<string, string|undefined>|null}|null} Parsed spec or null if invalid
+ */
+function parseElementSpec(str, options) {
+  const trimmed = str.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  // Simple tag name: `td`
+  if (!/[<>]/.test(trimmed)) {
+    return { tag: options.name(trimmed), attrs: null };
+  }
+
+  // HTML-like markup: `<span aria-hidden='true'>` or `<td></td>`
+  const match = trimmed.match(/^<([a-zA-Z][\w:-]*)((?:\s+[^>]*)?)>/);
+  if (!match) {
+    return null;
+  }
+
+  const tag = options.name(match[1] ?? '');
+  const attrString = match[2] ?? '';
+
+  if (!attrString.trim()) {
+    return { tag, attrs: null };
+  }
+
+  /** @type {{[key: string]: string | undefined}} */
+  const attrs = {};
+  const attrRegex = /([a-zA-Z][\w:-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>/]+)))?/g;
+  let attrMatch;
+
+  while ((attrMatch = attrRegex.exec(attrString))) {
+    const attrName = options.name(attrMatch[1] ?? '');
+    const attrValue = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4];
+    // Boolean attributes have no value (undefined)
+    attrs[attrName] = attrValue;
+  }
+
+  return {
+    tag,
+    attrs: Object.keys(attrs).length > 0 ? attrs : null
+  };
+}
+
+/**
+ * @param {string[]} input - Array of element specifications from `removeEmptyElementsExcept` option
+ * @param {ProcessedOptions} options - Options object for parsing
+ * @returns {Array<{tag: string, attrs: Object.<string, string|undefined>|null}>} Array of parsed element specs
+ */
+function parseRemoveEmptyElementsExcept(input, options) {
+  return /** @type {Array<{tag: string, attrs: {[x: string]: string | undefined} | null}>} */ (input.map(item => {
+    if (typeof item === 'string') {
+      const spec = parseElementSpec(item, options);
+      if (!spec) {
+        options.log('Warning: Unable to parse `removeEmptyElementsExcept` specification: “' + item + '”');
+      }
+      return spec;
+    }
+    options.log('Warning: `removeEmptyElementsExcept` specification must be a string, received: ' + typeof item);
+    return null;
+  }).filter(Boolean));
+}
+
+/**
+ * @param {string} tag - Element tag name
+ * @param {HTMLAttribute[]} attrs - Array of element attributes
+ * @param {Array<{tag: string, attrs: Object.<string, string|undefined>|null}>} preserveList - Parsed preserve specs
+ * @returns {boolean} True if the empty element should be preserved
+ */
+function shouldPreserveEmptyElement(tag, attrs, preserveList) {
+  for (const spec of preserveList) {
+    if (spec.tag !== tag) {
+      continue;
+    }
+
+    if (!spec.attrs) {
+      return true;
+    }
+
+    const allAttrsMatch = Object.entries(spec.attrs).every(([name, value]) => {
+      const attr = attrs.find(a => a.name === name);
+      if (!attr) {
+        return false; // Attribute not present
+      }
+      // Boolean attribute in spec (undefined value) matches if attribute is present
+      if (value === undefined) {
+        return true;
+      }
+      return attr.value === value;
+    });
+
+    if (allAttrsMatch) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export {
+  // Tag omission
+  canRemoveParentTag,
+  isStartTagMandatory,
+  canRemovePrecedingTag,
+
+  // Element removal
+  canRemoveElement,
+  parseRemoveEmptyElementsExcept,
+  shouldPreserveEmptyElement
+};

package/src/lib/file-pool.js

@@ -0,0 +1,193 @@
+/**
+ * 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';
+import { writeFileAtomic } from './file-write.js';
+
+// 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 writeFileAtomic(task.outputFile, minified);
+      }
+      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);
+
+/**
+ * The order to hand files to the pool in: Largest first, so the file that takes longest
+ * doesn’t start last and hold up the run on its own (ties keep their order)
+ * @template T
+ * @param {T[]} items - One per file
+ * @param {number[]} sizes - Byte size per file, in the order of `items`
+ * @returns {T[]}
+ */
+export function orderLargestFirst(items, sizes) {
+  return items
+    .map((item, index) => ({ item, size: sizes[index] ?? 0 }))
+    .sort((a, b) => b.size - a.size)
+    .map(entry => entry.item);
+}
+
+/**
+ * @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()));
+    }
+  };
+}