html-minifier-next 7.1.0 → 7.3.0

package/src/lib/options.js

@@ -1,5 +1,5 @@
 import { createUrlMinifier } from './urls.js';
-import { LRU, stableStringify, hashContent, identity, lowercase, replaceAsync, parseRegExp } from './utils.js';
+import { LRU, MAX_CACHE_ENTRY_SIZE, stableStringify, hashContent, identity, lowercase, replaceAsync, parseRegExp } from './utils.js';
 import { RE_TRAILING_SEMICOLON } from './constants.js';
 import { canCollapseWhitespace, canTrimWhitespace } from './whitespace.js';
 import { wrapCSS, unwrapCSS } from './content.js';
@@ -50,7 +50,7 @@ function shouldMinifyInnerHTML(options) {
 }
 
 // User-facing option keys that are valid but not listed in `optionDefinitions`
-const optionKeysExtra = new Set(['preset', 'log', 'canCollapseWhitespace', 'canTrimWhitespace', 'cacheCSS', 'cacheJS', 'cacheSVG']);
+const optionKeysExtra = new Set(['preset', 'log', 'canCollapseWhitespace', 'canTrimWhitespace']);
 
 // Unknown option keys and preset names already warned about—warn once per
 // key per process, so repeated `minify` calls (e.g., batch runs) don’t flood STDERR
@@ -183,15 +183,20 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
         // Cache key: Content + type + options signature; large inputs are hashed to avoid huge Map keys
         const inputCSS = wrapCSS(text, type);
         const cssSig = stableStringify({ type, opts: lightningCssOptions, cont: !!options.continueOnMinifyError });
-        const cssKey = inputCSS.length > 2048
-          ? (hashContent(inputCSS) + '|' + type + '|' + cssSig)
-          : (inputCSS + '|' + type + '|' + cssSig);
+        const isCacheable = inputCSS.length <= MAX_CACHE_ENTRY_SIZE;
+        const cssKey = isCacheable
+          ? (inputCSS.length > 2048
+            ? (hashContent(inputCSS) + '|' + type + '|' + cssSig)
+            : (inputCSS + '|' + type + '|' + cssSig))
+          : undefined;
 
         try {
-          const cached = /** @type {string | Promise<string> | undefined} */ (cssCache.get(cssKey));
-          if (cached !== undefined) {
-            // Support both resolved values and in-flight promises
-            return await cached;
+          if (cssKey !== undefined) {
+            const cached = /** @type {string | Promise<string> | undefined} */ (cssCache.get(cssKey));
+            if (cached !== undefined) {
+              // Support both resolved values and in-flight promises
+              return await cached;
+            }
           }
 
           // In-flight promise caching: Prevent duplicate concurrent minifications
@@ -224,12 +229,12 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
             return (text.trim() && !outputCSS.trim() && (looksLikeTemplate || hasUID)) ? text : outputCSS;
           })();
 
-          cssCache.set(cssKey, inFlight);
+          if (cssKey !== undefined) cssCache.set(cssKey, inFlight);
           const resolved = await inFlight;
-          cssCache.set(cssKey, resolved);
+          if (cssKey !== undefined) cssCache.set(cssKey, resolved);
           return resolved;
         } catch (err) {
-          cssCache.delete(cssKey);
+          if (cssKey !== undefined) cssCache.delete(cssKey);
           if (!options.continueOnMinifyError) {
             throw err;
           }
@@ -293,19 +298,22 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
         // 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;
+        const isCacheable = code.length <= MAX_CACHE_ENTRY_SIZE;
+
         try {
           // Select pre-computed signature based on engine
           const optsSig = useEngine === 'terser' ? terserSig : swcSig;
 
-          // For large inputs, hash the full content to avoid storing huge strings as Map keys
-          jsKey = (code.length > 2048 ? (hashContent(code) + '|') : (code + '|'))
-            + (inline ? '1' : '0') + '|' + (isModule ? 'm' : '') + '|' + useEngine + '|' + optsSig;
+          if (isCacheable) {
+            // For large inputs, hash the full content to avoid storing huge strings as Map keys
+            jsKey = (code.length > 2048 ? (hashContent(code) + '|') : (code + '|'))
+              + (inline ? '1' : '0') + '|' + (isModule ? 'm' : '') + '|' + useEngine + '|' + optsSig;
 
-          const cached = /** @type {string | Promise<string> | undefined} */ (jsCache.get(jsKey));
-          if (cached !== undefined) {
-            return await cached;
+            const cached = /** @type {string | Promise<string> | undefined} */ (jsCache.get(jsKey));
+            if (cached !== undefined) {
+              return await cached;
+            }
           }
 
           const inFlight = (async () => {
@@ -337,12 +345,12 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
             throw new Error(`Unknown JS minifier engine: ${useEngine}`);
           })();
 
-          jsCache.set(jsKey, inFlight);
+          if (jsKey !== undefined) jsCache.set(jsKey, inFlight);
           const resolved = await inFlight;
-          jsCache.set(jsKey, resolved);
+          if (jsKey !== undefined) jsCache.set(jsKey, resolved);
           return resolved;
         } catch (err) {
-          if (jsKey) jsCache.delete(jsKey);
+          if (jsKey !== undefined) jsCache.delete(jsKey);
           if (!options.continueOnMinifyError) {
             throw err;
           }
@@ -416,15 +424,19 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
           return svgContent;
         }
 
-        // Cache key: Large inputs are hashed to avoid huge Map keys
-        const svgKey = svgContent.length > 2048
-          ? (hashContent(svgContent) + '|' + svgSig)
-          : (svgContent + '|' + svgSig);
+        const isCacheable = svgContent.length <= MAX_CACHE_ENTRY_SIZE;
+        const svgKey = isCacheable
+          ? (svgContent.length > 2048
+            ? (hashContent(svgContent) + '|' + svgSig)
+            : (svgContent + '|' + svgSig))
+          : undefined;
 
         try {
-          const cached = /** @type {string | Promise<string> | undefined} */ (svgCache.get(svgKey));
-          if (cached !== undefined) {
-            return await cached;
+          if (svgKey !== undefined) {
+            const cached = /** @type {string | Promise<string> | undefined} */ (svgCache.get(svgKey));
+            if (cached !== undefined) {
+              return await cached;
+            }
           }
 
           const inFlight = (async () => {
@@ -433,12 +445,12 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
             return result.data;
           })();
 
-          svgCache.set(svgKey, inFlight);
+          if (svgKey !== undefined) svgCache.set(svgKey, inFlight);
           const resolved = await inFlight;
-          svgCache.set(svgKey, resolved);
+          if (svgKey !== undefined) svgCache.set(svgKey, resolved);
           return resolved;
         } catch (err) {
-          svgCache.delete(svgKey);
+          if (svgKey !== undefined) svgCache.delete(svgKey);
           if (!options.continueOnMinifyError) {
             throw err;
           }

package/src/lib/urls.js

@@ -79,7 +79,7 @@ function removeDirectoryIndex(pathname) {
 /**
  * Create a URL minifier function for the given site context
  * @param {string} site - The site base URL (used to compute relative URLs)
- * @returns {function(string): string} Minifier function that returns the shortest URL
+ * @returns {(url: string) => string} Minifier function that returns the shortest URL
  */
 export function createUrlMinifier(site) {
   let baseUrl;

package/src/lib/utils.js

@@ -21,12 +21,16 @@ function stableStringify(obj) {
 class LRU {
   constructor(limit = 200) {
     this.limit = limit;
+    this.gets = 0;
+    this.hits = 0;
     /** @type {Map<string, unknown>} */
     this.map = new Map();
   }
   /** @param {string} key */
   get(key) {
+    this.gets++;
     if (this.map.has(key)) {
+      this.hits++;
       const v = this.map.get(key);
       this.map.delete(key);
       this.map.set(key, v);
@@ -48,8 +52,17 @@ class LRU {
   }
   /** @param {string} key */
   delete(key) { this.map.delete(key); }
+  /** @returns {{ gets: number, hits: number, size: number, limit: number }} */
+  stats() {
+    return { gets: this.gets, hits: this.hits, size: this.map.size, limit: this.limit };
+  }
 }
 
+// Content longer than this (in UTF-16 code units, roughly bytes for typical CSS/JS/SVG) is
+// minified normally but never stored in a minification cache—caps worst-case cache memory
+// (entry count × this size) without affecting realistically sized inline content
+const MAX_CACHE_ENTRY_SIZE = 1024 * 1024; // 1 MB
+
 // FNV-1a 32-bit hash for large-input cache keys
 
 /** @param {string} str */
@@ -135,6 +148,7 @@ function parseRegExp(value) {
 
 export { stableStringify };
 export { LRU };
+export { MAX_CACHE_ENTRY_SIZE };
 export { hashContent };
 export { uniqueId };
 export { identity };