html-minifier-next 4.12.2 → 4.14.0

package/src/lib/options.js

@@ -0,0 +1,300 @@
+// Imports
+
+import RelateURL from 'relateurl';
+import { stableStringify, identity, identityAsync, replaceAsync } from './utils.js';
+import { RE_TRAILING_SEMICOLON } from './constants.js';
+import { canCollapseWhitespace, canTrimWhitespace } from './whitespace.js';
+import { wrapCSS, unwrapCSS } from './content.js';
+
+// Helper functions
+
+function shouldMinifyInnerHTML(options) {
+  return Boolean(
+    options.collapseWhitespace ||
+    options.removeComments ||
+    options.removeOptionalTags ||
+    options.minifyJS !== identity ||
+    options.minifyCSS !== identityAsync ||
+    options.minifyURLs !== identity
+  );
+}
+
+// Main options processor
+
+/**
+ * @param {Partial<MinifierOptions>} inputOptions - User-provided options
+ * @param {Object} deps - Dependencies from htmlminifier.js
+ * @param {Function} deps.getLightningCSS - Function to lazily load lightningcss
+ * @param {Function} deps.getTerser - Function to lazily load terser
+ * @param {Function} deps.getSwc - Function to lazily load @swc/core
+ * @param {LRU} deps.cssMinifyCache - CSS minification cache
+ * @param {LRU} deps.jsMinifyCache - JS minification cache
+ * @returns {MinifierOptions} Normalized options with defaults applied
+ */
+const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, cssMinifyCache, jsMinifyCache } = {}) => {
+  const options = {
+    name: function (name) {
+      return name.toLowerCase();
+    },
+    canCollapseWhitespace,
+    canTrimWhitespace,
+    continueOnMinifyError: true,
+    html5: true,
+    ignoreCustomComments: [
+      /^!/,
+      /^\s*#/
+    ],
+    ignoreCustomFragments: [
+      /<%[\s\S]*?%>/,
+      /<\?[\s\S]*?\?>/
+    ],
+    includeAutoGeneratedTags: true,
+    log: identity,
+    minifyCSS: identityAsync,
+    minifyJS: identity,
+    minifyURLs: identity
+  };
+
+  Object.keys(inputOptions).forEach(function (key) {
+    const option = inputOptions[key];
+
+    if (key === 'caseSensitive') {
+      if (option) {
+        options.name = identity;
+      }
+    } else if (key === 'log') {
+      if (typeof option === 'function') {
+        options.log = option;
+      }
+    } else if (key === 'minifyCSS' && typeof option !== 'function') {
+      if (!option) {
+        return;
+      }
+
+      const lightningCssOptions = typeof option === 'object' ? option : {};
+
+      options.minifyCSS = async function (text, type) {
+        // Fast path: Nothing to minify
+        if (!text || !text.trim()) {
+          return text;
+        }
+        text = await replaceAsync(
+          text,
+          /(url\s*\(\s*)(?:"([^"]*)"|'([^']*)'|([^\s)]+))(\s*\))/ig,
+          async function (match, prefix, dq, sq, unq, suffix) {
+            const quote = dq != null ? '"' : (sq != null ? "'" : '');
+            const url = dq ?? sq ?? unq ?? '';
+            try {
+              const out = await options.minifyURLs(url);
+              return prefix + quote + (typeof out === 'string' ? out : url) + quote + suffix;
+            } catch (err) {
+              if (!options.continueOnMinifyError) {
+                throw err;
+              }
+              options.log && options.log(err);
+              return match;
+            }
+          }
+        );
+        // Cache key: Wrapped content, type, options signature
+        const inputCSS = wrapCSS(text, type);
+        const cssSig = stableStringify({ type, opts: lightningCssOptions, cont: !!options.continueOnMinifyError });
+        // For large inputs, use length and content fingerprint (first/last 50 chars) to prevent collisions
+        const cssKey = inputCSS.length > 2048
+          ? (inputCSS.length + '|' + inputCSS.slice(0, 50) + inputCSS.slice(-50) + '|' + type + '|' + cssSig)
+          : (inputCSS + '|' + type + '|' + cssSig);
+
+        try {
+          const cached = cssMinifyCache.get(cssKey);
+          if (cached) {
+            return cached;
+          }
+
+          const transformCSS = await getLightningCSS();
+          const result = transformCSS({
+            filename: 'input.css',
+            code: Buffer.from(inputCSS),
+            minify: true,
+            errorRecovery: !!options.continueOnMinifyError,
+            ...lightningCssOptions
+          });
+
+          const outputCSS = unwrapCSS(result.code.toString(), type);
+
+          // If Lightning CSS removed significant content that looks like template syntax or UIDs, return original
+          // This preserves:
+          // 1. Template code like `<?php ?>`, `<%= %>`, `{{ }}`, etc. (contain `<` or `>` but not `CDATA`)
+          // 2. UIDs representing custom fragments (only lowercase letters and digits, no spaces)
+          // CDATA sections, HTML entities, and other invalid CSS are allowed to be removed
+          const isCDATA = text.includes('<![CDATA[');
+          const uidPattern = /[a-z0-9]{10,}/; // UIDs are long alphanumeric strings
+          const hasUID = uidPattern.test(text) && !isCDATA; // Exclude CDATA from UID detection
+          const looksLikeTemplate = (text.includes('<') || text.includes('>')) && !isCDATA;
+
+          // Preserve if output is empty and input had template syntax or UIDs
+          // This catches cases where Lightning CSS removed content that should be preserved
+          const finalOutput = (text.trim() && !outputCSS.trim() && (looksLikeTemplate || hasUID)) ? text : outputCSS;
+
+          cssMinifyCache.set(cssKey, finalOutput);
+          return finalOutput;
+        } catch (err) {
+          cssMinifyCache.delete(cssKey);
+          if (!options.continueOnMinifyError) {
+            throw err;
+          }
+          options.log && options.log(err);
+          return text;
+        }
+      };
+    } else if (key === 'minifyJS' && typeof option !== 'function') {
+      if (!option) {
+        return;
+      }
+
+      // Parse configuration
+      const config = typeof option === 'object' ? option : {};
+      const engine = (config.engine || 'terser').toLowerCase();
+
+      // Validate engine
+      const supportedEngines = ['terser', 'swc'];
+      if (!supportedEngines.includes(engine)) {
+        throw new Error(`Unsupported JS minifier engine: "${engine}". Supported engines: ${supportedEngines.join(', ')}`);
+      }
+
+      // Extract engine-specific options (excluding `engine` field itself)
+      const engineOptions = { ...config };
+      delete engineOptions.engine;
+
+      // Terser options (needed for inline JS and when engine is `terser`)
+      const terserOptions = engine === 'terser' ? engineOptions : {};
+      terserOptions.parse = {
+        ...terserOptions.parse,
+        bare_returns: false
+      };
+
+      // SWC options (when engine is `swc`)
+      const swcOptions = engine === 'swc' ? engineOptions : {};
+
+      // Pre-compute option signatures once for performance (avoid repeated stringification)
+      const terserSig = stableStringify({
+        ...terserOptions,
+        cont: !!options.continueOnMinifyError
+      });
+      const swcSig = stableStringify({
+        ...swcOptions,
+        cont: !!options.continueOnMinifyError
+      });
+
+      options.minifyJS = async function (text, inline) {
+        const start = text.match(/^\s*<!--.*/);
+        const code = start ? text.slice(start[0].length).replace(/\n\s*-->\s*$/, '') : text;
+
+        // Fast path: Avoid invoking minifier for empty/whitespace-only content
+        if (!code || !code.trim()) {
+          return '';
+        }
+
+        // Hybrid strategy: Always use Terser for inline JS (needs bare returns support)
+        // Use user’s chosen engine for script blocks
+        const useEngine = inline ? 'terser' : engine;
+
+        let jsKey;
+        try {
+          // Select pre-computed signature based on engine
+          const optsSig = useEngine === 'terser' ? terserSig : swcSig;
+
+          // For large inputs, use length and content fingerprint to prevent collisions
+          jsKey = (code.length > 2048 ? (code.length + '|' + code.slice(0, 50) + code.slice(-50) + '|') : (code + '|'))
+            + (inline ? '1' : '0') + '|' + useEngine + '|' + optsSig;
+
+          const cached = jsMinifyCache.get(jsKey);
+          if (cached) {
+            return await cached;
+          }
+
+          const inFlight = (async () => {
+            // Dispatch to appropriate minifier
+            if (useEngine === 'terser') {
+              // Create a copy to avoid mutating shared `terserOptions` (race condition)
+              const terserCallOptions = {
+                ...terserOptions,
+                parse: {
+                  ...terserOptions.parse,
+                  bare_returns: inline
+                }
+              };
+              const terser = await getTerser();
+              const result = await terser(code, terserCallOptions);
+              return result.code.replace(RE_TRAILING_SEMICOLON, '');
+            } else if (useEngine === 'swc') {
+              const swc = await getSwc();
+              // `swc.minify()` takes compress and mangle directly as options
+              const result = await swc.minify(code, {
+                compress: true,
+                mangle: true,
+                ...swcOptions, // User options override defaults
+              });
+              return result.code.replace(RE_TRAILING_SEMICOLON, '');
+            }
+            throw new Error(`Unknown JS minifier engine: ${useEngine}`);
+          })();
+
+          jsMinifyCache.set(jsKey, inFlight);
+          const resolved = await inFlight;
+          jsMinifyCache.set(jsKey, resolved);
+          return resolved;
+        } catch (err) {
+          if (jsKey) jsMinifyCache.delete(jsKey);
+          if (!options.continueOnMinifyError) {
+            throw err;
+          }
+          options.log && options.log(err);
+          return text;
+        }
+      };
+    } else if (key === 'minifyURLs' && typeof option !== 'function') {
+      if (!option) {
+        return;
+      }
+
+      let relateUrlOptions = option;
+
+      if (typeof option === 'string') {
+        relateUrlOptions = { site: option };
+      } else if (typeof option !== 'object') {
+        relateUrlOptions = {};
+      }
+
+      // Cache RelateURL instance for reuse (expensive to create)
+      const relateUrlInstance = new RelateURL(relateUrlOptions.site || '', relateUrlOptions);
+
+      options.minifyURLs = function (text) {
+        // Fast-path: Skip if text doesn’t look like a URL that needs processing
+        // Only process if contains URL-like characters (`/`, `:`, `#`, `?`) or spaces that need encoding
+        if (!/[/:?#\s]/.test(text)) {
+          return text;
+        }
+
+        try {
+          return relateUrlInstance.relate(text);
+        } catch (err) {
+          if (!options.continueOnMinifyError) {
+            throw err;
+          }
+          options.log && options.log(err);
+          return text;
+        }
+      };
+    } else {
+      options[key] = option;
+    }
+  });
+  return options;
+};
+
+// Exports
+
+export {
+  shouldMinifyInnerHTML,
+  processOptions
+};

package/src/lib/utils.js

@@ -0,0 +1,90 @@
+// Stringify for options signatures (sorted keys, shallow, nested objects)
+
+function stableStringify(obj) {
+  if (obj == null || typeof obj !== 'object') return JSON.stringify(obj);
+  if (Array.isArray(obj)) return '[' + obj.map(stableStringify).join(',') + ']';
+  const keys = Object.keys(obj).sort();
+  let out = '{';
+  for (let i = 0; i < keys.length; i++) {
+    const k = keys[i];
+    out += JSON.stringify(k) + ':' + stableStringify(obj[k]) + (i < keys.length - 1 ? ',' : '');
+  }
+  return out + '}';
+}
+
+// LRU cache for strings and promises
+
+class LRU {
+  constructor(limit = 200) {
+    this.limit = limit;
+    this.map = new Map();
+  }
+  get(key) {
+    if (this.map.has(key)) {
+      const v = this.map.get(key);
+      this.map.delete(key);
+      this.map.set(key, v);
+      return v;
+    }
+    return undefined;
+  }
+  set(key, value) {
+    if (this.map.has(key)) this.map.delete(key);
+    this.map.set(key, value);
+    if (this.map.size > this.limit) {
+      const first = this.map.keys().next().value;
+      this.map.delete(first);
+    }
+  }
+  delete(key) { this.map.delete(key); }
+}
+
+// Unique ID generator
+
+function uniqueId(value) {
+  let id;
+  do {
+    id = Math.random().toString(36).replace(/^0\.[0-9]*/, '');
+  } while (~value.indexOf(id));
+  return id;
+}
+
+// Identity functions
+
+function identity(value) {
+  return value;
+}
+
+function identityAsync(value) {
+  return Promise.resolve(value);
+}
+
+// Replace async helper
+
+/**
+ * Asynchronously replace matches in a string
+ * @param {string} str - Input string
+ * @param {RegExp} regex - Regular expression with global flag
+ * @param {Function} asyncFn - Async function to process each match
+ * @returns {Promise<string>} Processed string
+ */
+async function replaceAsync(str, regex, asyncFn) {
+  const promises = [];
+
+  str.replace(regex, (match, ...args) => {
+    const promise = asyncFn(match, ...args);
+    promises.push(promise);
+  });
+
+  const data = await Promise.all(promises);
+  return str.replace(regex, () => data.shift());
+}
+
+// Exports
+
+export { stableStringify };
+export { LRU };
+export { uniqueId };
+export { identity };
+export { identityAsync };
+export { replaceAsync };

package/src/lib/whitespace.js

@@ -0,0 +1,139 @@
+// Imports
+
+import {
+  RE_WS_START,
+  RE_WS_END,
+  RE_ALL_WS_NBSP,
+  RE_NBSP_LEADING_GROUP,
+  RE_NBSP_LEAD_GROUP,
+  RE_NBSP_TRAILING_GROUP,
+  RE_NBSP_TRAILING_STRIP,
+  inlineElementsToKeepWhitespace
+} from './constants.js';
+
+// Trim whitespace
+
+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, '');
+};
+
+// Collapse all whitespace
+
+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)) {
+    return str;
+  }
+  // No-break space is specifically handled inside the replacer function here:
+  return str.replace(RE_ALL_WS_NBSP, function (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 original regex approach
+    return spaces.replace(RE_NBSP_LEADING_GROUP, '$1 ');
+  });
+}
+
+// Collapse whitespace with options
+
+function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll) {
+  let lineBreakBefore = ''; let lineBreakAfter = '';
+
+  if (!str) return str;
+
+  // Fast path: Nothing to do
+  if (!trimLeft && !trimRight && !collapseAll && !options.preserveLineBreaks) {
+    return str;
+  }
+
+  // Fast path: No whitespace at all
+  if (!/[ \n\r\t\f\xA0]/.test(str)) {
+    return str;
+  }
+
+  if (options.preserveLineBreaks) {
+    str = str.replace(/^[ \n\r\t\f]*?[\n\r][ \n\r\t\f]*/, function () {
+      lineBreakBefore = '\n';
+      return '';
+    }).replace(/[ \n\r\t\f]*?[\n\r][ \n\r\t\f]*$/, function () {
+      lineBreakAfter = '\n';
+      return '';
+    });
+  }
+
+  if (trimLeft) {
+    // Non-breaking space is specifically handled inside the replacer function
+    str = str.replace(/^[ \n\r\t\f\xA0]+/, function (spaces) {
+      const conservative = !lineBreakBefore && options.conservativeCollapse;
+      if (conservative && spaces === '\t') {
+        return '\t';
+      }
+      return spaces.replace(/^[^\xA0]+/, '').replace(RE_NBSP_LEAD_GROUP, '$1 ') || (conservative ? ' ' : '');
+    });
+  }
+
+  if (trimRight) {
+    // Non-breaking space is specifically handled inside the replacer function
+    str = str.replace(/[ \n\r\t\f\xA0]+$/, function (spaces) {
+      const conservative = !lineBreakAfter && options.conservativeCollapse;
+      if (conservative && spaces === '\t') {
+        return '\t';
+      }
+      return spaces.replace(RE_NBSP_TRAILING_GROUP, ' $1').replace(RE_NBSP_TRAILING_STRIP, '') || (conservative ? ' ' : '');
+    });
+  }
+
+  if (collapseAll) {
+    // Strip non-space whitespace then compress spaces to one
+    str = collapseWhitespaceAll(str);
+  }
+
+  // Avoid string concatenation when no line breaks (common case)
+  if (!lineBreakBefore && !lineBreakAfter) return str;
+  if (!lineBreakBefore) return str + lineBreakAfter;
+  if (!lineBreakAfter) return lineBreakBefore + str;
+  return lineBreakBefore + str + lineBreakAfter;
+}
+
+// Collapse whitespace smartly based on surrounding tags
+
+function collapseWhitespaceSmart(str, prevTag, nextTag, options, inlineElements, inlineTextSet) {
+  let trimLeft = prevTag && !inlineElementsToKeepWhitespace.has(prevTag);
+  if (trimLeft && !options.collapseInlineTagWhitespace) {
+    trimLeft = prevTag.charAt(0) === '/' ? !inlineElements.has(prevTag.slice(1)) : !inlineTextSet.has(prevTag);
+  }
+  let trimRight = nextTag && !inlineElementsToKeepWhitespace.has(nextTag);
+  if (trimRight && !options.collapseInlineTagWhitespace) {
+    trimRight = nextTag.charAt(0) === '/' ? !inlineTextSet.has(nextTag.slice(1)) : !inlineElements.has(nextTag);
+  }
+  return collapseWhitespace(str, options, trimLeft, trimRight, prevTag && nextTag);
+}
+
+// Collapse/trim whitespace for given tag
+
+function canCollapseWhitespace(tag) {
+  return !/^(?:script|style|pre|textarea)$/.test(tag);
+}
+
+function canTrimWhitespace(tag) {
+  return !/^(?:pre|textarea)$/.test(tag);
+}
+
+// Exports
+
+export {
+  trimWhitespace,
+  collapseWhitespaceAll,
+  collapseWhitespace,
+  collapseWhitespaceSmart,
+  canCollapseWhitespace,
+  canTrimWhitespace
+};

package/src/presets.js

@@ -22,7 +22,6 @@ export const presets = {
     useShortDoctype: true
   },
   comprehensive: {
-    // @@ Add `collapseAttributeWhitespace: true` (also add to preset in demo)
     caseSensitive: true,
     collapseBooleanAttributes: true,
     collapseInlineTagWhitespace: true,

package/src/tokenchain.js

@@ -60,7 +60,7 @@ class TokenChain {
     const sorter = new Sorter();
     sorter.sorterMap = new Map();
 
-    // Convert Map entries to array and sort
+    // Convert Map entries to array and sort by frequency (descending) then alphabetically
     const entries = Array.from(this.map.entries()).sort((a, b) => {
       const m = a[1].arrays.length;
       const n = b[1].arrays.length;

package/dist/types/utils.d.ts

@@ -1,2 +0,0 @@
-export function replaceAsync(str: any, regex: any, asyncFn: any): Promise<any>;
-//# sourceMappingURL=utils.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.js"],"names":[],"mappings":"AAAA,+EAUC"}