html-minifier-next 6.2.11 → 7.1.0

package/src/lib/attributes.js

@@ -19,6 +19,8 @@ import { trimWhitespace, collapseWhitespaceAll } from './whitespace.js';
 import { shouldMinifyInnerHTML } from './options.js';
 import { identity, isThenable } from './utils.js';
 
+/** @import { ProcessedOptions } from './options.js' */
+
 // Type definitions
 
 /**
@@ -41,11 +43,9 @@ async function getDecodeHTMLStrict() {
 
 /**
  * @param {string} text
- * @param {{ignoreCustomComments: RegExp[]}} options
+ * @param {ProcessedOptions} options
  */
 function isIgnoredComment(text, options) {
-  // @@ Optimize: `Array.isArray(options.ignoreCustomComments)` runs on every comment node; it could be eliminated once `parseRegExpArray` is tightened to coerce non-arrays to `[]` at setup time
-  if (!Array.isArray(options.ignoreCustomComments)) return false;
   for (const pattern of options.ignoreCustomComments) {
     if (pattern.test(text)) {
       return true;
@@ -303,7 +303,8 @@ function isMediaQuery(tag, attrs, attrName) {
  * @param {string} tag
  */
 function isSrcset(attrName, tag) {
-  return attrName === 'srcset' && srcsetElements.has(tag);
+  return (attrName === 'srcset' && srcsetElements.has(tag)) ||
+    (attrName === 'imagesrcset' && tag === 'link');
 }
 
 /**
@@ -380,7 +381,7 @@ const valueWhitespaceExemptElements = new Set(['button', 'data', 'input', 'optio
  * @param {string} tag
  * @param {string} attrName
  * @param {string} attrValue
- * @param {Record<string, any>} options
+ * @param {ProcessedOptions} options
  * @param {HTMLAttribute[]} attrs
  * @param {Function} minifyHTMLSelf
  */
@@ -432,7 +433,8 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTM
   if (attrName === 'class') {
     attrValue = trimWhitespace(attrValue);
     if (options.sortClassNames) {
-      attrValue = options.sortClassNames(attrValue);
+      // By the time attributes are processed, `createSortFns` has replaced any truthy non-function value
+      attrValue = /** @type {(value: string) => string} */ (options.sortClassNames)(attrValue);
     } else {
       attrValue = collapseWhitespaceAll(attrValue);
     }
@@ -491,8 +493,34 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTM
   }
 
   if (isSrcset(attrName, tag)) {
-    // https://html.spec.whatwg.org/multipage/embedded-content.html#attr-img-srcset
-    const candidates = trimWhitespace(attrValue).split(/\s*,\s*/);
+    // Split into image candidate strings following the spec parsing algorithm
+    // (https://html.spec.whatwg.org/multipage/images.html#parsing-a-srcset-attribute);
+    // a naive split on commas would corrupt URLs that contain commas
+    const value = trimWhitespace(attrValue);
+    /** @type {string[]} */
+    const candidates = [];
+    let pos = 0;
+    while (pos < value.length) {
+      // Skip whitespace and separator commas
+      while (pos < value.length && /[\s,]/.test(value.charAt(pos))) pos++;
+      if (pos >= value.length) break;
+      const start = pos;
+      // URL: a run of non-whitespace characters (which may contain commas)
+      while (pos < value.length && !/\s/.test(value.charAt(pos))) pos++;
+      if (value.charAt(pos - 1) === ',') {
+        // Trailing comma(s) end the candidate—a URL without descriptor
+        candidates.push(value.slice(start, pos).replace(/,+$/, ''));
+        continue;
+      }
+      // Descriptor: everything up to the next comma outside parentheses
+      let inParens = false;
+      while (pos < value.length && (inParens || value.charAt(pos) !== ',')) {
+        if (value.charAt(pos) === '(') inParens = true;
+        else if (value.charAt(pos) === ')') inParens = false;
+        pos++;
+      }
+      candidates.push(trimWhitespace(value.slice(start, pos)));
+    }
     const processed = candidates.map(candidate => {
       let url = candidate;
       let descriptor = '';
@@ -602,7 +630,7 @@ function chooseAttributeQuote(attrValue, options) {
  * @param {HTMLAttribute} attr
  * @param {HTMLAttribute[]} attrs
  * @param {string} tag
- * @param {Record<string, any>} options
+ * @param {ProcessedOptions} options
  * @param {Function} minifyHTML
  */
 function normalizeAttr(attr, attrs, tag, options, minifyHTML) {
@@ -626,16 +654,16 @@ function normalizeAttr(attr, attrs, tag, options, minifyHTML) {
  * @param {HTMLAttribute} attr
  * @param {HTMLAttribute[]} attrs
  * @param {string} tag
- * @param {Record<string, any>} options
+ * @param {ProcessedOptions} options
  * @param {Function} minifyHTML
  */
 function normalizeAttrContinue(attrName, attrValue, attr, attrs, tag, options, minifyHTML) {
   if ((options.removeRedundantAttributes &&
        isAttributeRedundant(tag, attrName, attrValue ?? '', attrs)) ||
-      (options.removeScriptTypeAttributes && tag === 'script' &&
-       attrName === 'type' && isScriptTypeAttribute(attrValue) && !keepScriptTypeAttribute(attrValue)) ||
-      (options.removeStyleLinkTypeAttributes && (tag === 'style' || tag === 'link') &&
-       attrName === 'type' && isStyleLinkTypeAttribute(attrValue))) {
+      (options.removeDefaultTypeAttributes && attrName === 'type' && (
+        ((tag === 'style' || tag === 'link') && isStyleLinkTypeAttribute(attrValue)) ||
+        (tag === 'script' && isScriptTypeAttribute(attrValue) && !keepScriptTypeAttribute(attrValue))
+      ))) {
     return;
   }
 
@@ -656,7 +684,7 @@ function normalizeAttrContinue(attrName, attrValue, attr, attrs, tag, options, m
  * @param {string | undefined} attrValue
  * @param {HTMLAttribute} attr
  * @param {string} tag
- * @param {Record<string, any>} options
+ * @param {ProcessedOptions} options
  */
 function normalizeAttrFinish(attrName, attrValue, attr, tag, options) {
   if (options.removeEmptyAttributes &&
@@ -676,9 +704,9 @@ function normalizeAttrFinish(attrName, attrValue, attr, tag, options) {
 }
 
 /**
- * @param {{name: string, value?: string, attr: HTMLAttribute}} normalized
+ * @param {{name: string, value: string | undefined, attr: HTMLAttribute}} normalized
  * @param {string | boolean | undefined} hasUnarySlash
- * @param {Record<string, any>} options
+ * @param {ProcessedOptions} options
  * @param {boolean} isLast
  * @param {string | undefined} uidAttr
  */

package/src/lib/content.js

@@ -3,13 +3,15 @@ import {
 } from './constants.js';
 import { trimWhitespace } from './whitespace.js';
 
+/** @import { ProcessedOptions } from './options.js' */
+
 // CSS processing
 
 // Wrap CSS declarations for inline styles and media queries
 // This ensures proper context for CSS minification
 /**
  * @param {string} text
- * @param {string} type
+ * @param {string} [type]
  */
 function wrapCSS(text, type) {
   switch (type) {
@@ -24,7 +26,7 @@ function wrapCSS(text, type) {
 
 /**
  * @param {string} text
- * @param {string} type
+ * @param {string} [type]
  */
 function unwrapCSS(text, type) {
   let matches;
@@ -73,7 +75,7 @@ function hasJsonScriptType(attrs) {
 
 /**
  * @param {string} text
- * @param {{continueOnMinifyError?: boolean, log?: Function, processScripts?: string[]}} options
+ * @param {ProcessedOptions} options
  * @param {Array<{name: string, value?: string | undefined}>} currentAttrs
  * @param {Function} minifyHTML
  */

package/src/lib/elements.js

@@ -12,12 +12,7 @@ import {
 import { hasAttrName } from './attributes.js';
 
 /** @import { HTMLAttribute } from './attributes.js' */
-
-// Type definitions
-
-/**
- * @typedef {{ name: (str: string) => string, log?: Function }} MinifierOptions
- */
+/** @import { ProcessedOptions } from './options.js' */
 
 // Tag omission rules
 
@@ -143,7 +138,7 @@ function canRemoveElement(tag, attrs) {
 
 /**
  * @param {string} str - Tag name or HTML-like element spec (e.g., “td” or “<span aria-hidden='true'>”)
- * @param {MinifierOptions} options - Options object for name normalization
+ * @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) {
@@ -196,7 +191,7 @@ function parseElementSpec(str, options) {
 
 /**
  * @param {string[]} input - Array of element specifications from `removeEmptyElementsExcept` option
- * @param {MinifierOptions} options - Options object for parsing
+ * @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) {

package/src/lib/option-definitions.js

@@ -138,6 +138,10 @@ const optionDefinitions = {
     description: 'Strip HTML comments',
     type: 'boolean'
   },
+  removeDefaultTypeAttributes: {
+    description: 'Remove default `type` attributes from `style`/`link` (e.g., `type="text/css"`) and `script` (e.g., `type="text/javascript"`) elements; other `type` attribute values are left intact',
+    type: 'boolean'
+  },
   removeEmptyAttributes: {
     description: 'Remove all attributes with whitespace-only values',
     type: 'boolean'
@@ -158,14 +162,6 @@ const optionDefinitions = {
     description: 'Remove attributes when value matches default',
     type: 'boolean'
   },
-  removeScriptTypeAttributes: {
-    description: 'Remove `type="text/javascript"` from `script` elements; other `type` attribute values are left intact',
-    type: 'boolean'
-  },
-  removeStyleLinkTypeAttributes: {
-    description: 'Remove `type="text/css"` from `style` and `link` elements; other `type` attribute values are left intact',
-    type: 'boolean'
-  },
   removeTagWhitespace: {
     description: 'Remove space between attributes whenever possible; note that this will result in invalid HTML',
     type: 'boolean'

package/src/lib/options.js

@@ -4,19 +4,39 @@ import { RE_TRAILING_SEMICOLON } from './constants.js';
 import { canCollapseWhitespace, canTrimWhitespace } from './whitespace.js';
 import { wrapCSS, unwrapCSS } from './content.js';
 import { getPreset, getPresetNames } from '../presets.js';
-import { optionDefaults } from './option-definitions.js';
+import { optionDefinitions, optionDefaults } from './option-definitions.js';
+
+/** @import { MinifierOptions, HTMLAttribute } from '../htmlminifier.js' */
 
 // Type definitions
 
 /**
- * @typedef {Record<string, any>} MinifierOptions
+ * Options object produced by `processOptions` and consumed by `minifyHTML` and
+ * the `lib/` helpers; normalization guarantees that the function-valued options
+ * below are always present (defaulting to identity/built-in functions), and
+ * minification adds writable internal state on top of the public options
+ * (set on prototype-chain forks during SVG/MathML namespace transitions)
+ *
+ * @typedef {Omit<MinifierOptions, 'preset' | 'canCollapseWhitespace' | 'canTrimWhitespace' | 'ignoreCustomComments' | 'log' | 'minifyCSS' | 'minifyJS' | 'minifyURLs' | 'minifySVG'> & {
+ *   name: (name: string) => string,
+ *   log: (message: any) => unknown,
+ *   ignoreCustomComments: RegExp[],
+ *   canCollapseWhitespace: (tag: string, attrs: HTMLAttribute[], defaultFn: (tag: string) => boolean) => boolean,
+ *   canTrimWhitespace: (tag: string, attrs: HTMLAttribute[], defaultFn: (tag: string) => boolean) => boolean,
+ *   minifyCSS: (text: string, type?: string) => string | Promise<string>,
+ *   minifyJS: (text: string, inline?: boolean, isModule?: boolean) => string | Promise<string>,
+ *   minifyURLs: (text: string) => string | Promise<string>,
+ *   minifySVG: ((svgContent: string) => string | Promise<string>) | null,
+ *   nameParent?: (name: string) => string,
+ *   nameHTML?: (name: string) => string,
+ *   insideSVG?: boolean,
+ *   insideForeignContent?: boolean
+ * }} ProcessedOptions
  */
 
-// @@ Extract a `ProcessedOptions` typedef (with `name`, `log`, `canCollapseWhitespace`, `canTrimWhitespace`,`minifyCSS`, `minifyJS`, `minifyURLs` typed as required, non-optional) to replace the current `Record<string, any>` escape hatch and eliminate the `/** @type {Function} */` casts in htmlminifier.js
-
 // Helper functions
 
-/** @param {MinifierOptions} options */
+/** @param {ProcessedOptions} options */
 function shouldMinifyInnerHTML(options) {
   return Boolean(
     options.collapseWhitespace ||
@@ -29,15 +49,23 @@ 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']);
+
+// 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
+const optionKeysWarned = new Set();
+const presetNamesWarned = new Set();
+
 // Main options processor
 
 /**
  * @param {MinifierOptions} inputOptions - User-provided options
  * @param {{getLightningCSS?: Function | undefined, getTerser?: Function | undefined, getSwc?: Function | undefined, getSvgo?: Function | undefined, cssMinifyCache?: LRU | undefined, jsMinifyCache?: LRU | undefined, svgMinifyCache?: LRU | undefined}} [deps] - Dependencies from htmlminifier.js
- * @returns {MinifierOptions} Normalized options with defaults applied
+ * @returns {ProcessedOptions} Normalized options with defaults applied
  */
 const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getSvgo, cssMinifyCache, jsMinifyCache, svgMinifyCache } = {}) => {
-  /** @type {MinifierOptions} */
+  /** @type {ProcessedOptions} */
   const options = {
     name: lowercase,
     canCollapseWhitespace,
@@ -67,6 +95,18 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
     });
   };
 
+  // Route warnings through the user-provided `log` hook so API consumers can
+  // capture or suppress them consistently; fall back to `console.warn`
+  const warn = typeof inputOptions.log === 'function' ? inputOptions.log : console.warn;
+
+  // Warn about unrecognized options—catches typos as well as options removed in earlier versions
+  Object.keys(inputOptions).forEach(function (key) {
+    if (!Object.hasOwn(optionDefinitions, key) && !optionKeysExtra.has(key) && !optionKeysWarned.has(key)) {
+      optionKeysWarned.add(key);
+      warn(`HTML Minifier Next: Ignoring unknown or deprecated option “${key}” (see README for available options)`);
+    }
+  });
+
   // Merge preset with user options so all values go through normalization
   // User options take precedence over preset values
   let effectiveInput = inputOptions;
@@ -74,17 +114,22 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
     const preset = getPreset(inputOptions.preset);
     if (preset) {
       effectiveInput = { ...preset, ...inputOptions };
-    } else {
+    } else if (!presetNamesWarned.has(inputOptions.preset)) {
+      presetNamesWarned.add(inputOptions.preset);
       const available = getPresetNames().join(', ');
-      console.warn(`HTML Minifier Next: Unknown preset “${inputOptions.preset}”. Available presets: ${available}`);
+      warn(`HTML Minifier Next: Unknown preset “${inputOptions.preset}”; available presets: ${available}`);
     }
   }
 
+  // Escape hatch for the loop below, which reads and assigns user-provided values by dynamic key
+  const optionsDynamic = /** @type {Record<string, any>} */ (options);
+
   Object.keys(effectiveInput).forEach(function (key) {
-    const option = effectiveInput[key];
+    const option = /** @type {Record<string, any>} */ (effectiveInput)[key];
 
-    // Skip preset key—it’s already been processed
-    if (key === 'preset') {
+    // Skip `preset` (already processed) and unrecognized keys (warned about above)—
+    // the latter also keeps internal keys from being overridden
+    if (key === 'preset' || (!Object.hasOwn(optionDefinitions, key) && !optionKeysExtra.has(key))) {
       return;
     }
 
@@ -106,7 +151,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
       const cssLoader = getLightningCSS;
       const cssCache = cssMinifyCache;
 
-      options.minifyCSS = async function (/** @type {string} */ text, /** @type {string} */ type) {
+      options.minifyCSS = async function (/** @type {string} */ text, /** @type {string | undefined} */ type) {
         // Fast path: Nothing to minify
         if (!text || !text.trim()) {
           return text;
@@ -143,7 +188,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
           : (inputCSS + '|' + type + '|' + cssSig);
 
         try {
-          const cached = cssCache.get(cssKey);
+          const cached = /** @type {string | Promise<string> | undefined} */ (cssCache.get(cssKey));
           if (cached !== undefined) {
             // Support both resolved values and in-flight promises
             return await cached;
@@ -236,7 +281,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
         cont: !!options.continueOnMinifyError
       });
 
-      options.minifyJS = async function (/** @type {string} */ text, /** @type {boolean} */ inline, /** @type {boolean} */ isModule) {
+      options.minifyJS = async function (/** @type {string} */ text, /** @type {boolean | undefined} */ inline, /** @type {boolean | undefined} */ isModule) {
         const start = text.match(/^\s*<!--.*/);
         const code = start ? text.slice(start[0].length).replace(/\n\s*-->\s*$/, '') : text;
 
@@ -258,7 +303,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
           jsKey = (code.length > 2048 ? (hashContent(code) + '|') : (code + '|'))
             + (inline ? '1' : '0') + '|' + (isModule ? 'm' : '') + '|' + useEngine + '|' + optsSig;
 
-          const cached = jsCache.get(jsKey);
+          const cached = /** @type {string | Promise<string> | undefined} */ (jsCache.get(jsKey));
           if (cached !== undefined) {
             return await cached;
           }
@@ -331,7 +376,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
         }
 
         // Check cache
-        const cached = instanceCache.get(text);
+        const cached = /** @type {string | undefined} */ (instanceCache.get(text));
         if (cached !== undefined) {
           return cached;
         }
@@ -377,7 +422,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
           : (svgContent + '|' + svgSig);
 
         try {
-          const cached = svgCache.get(svgKey);
+          const cached = /** @type {string | Promise<string> | undefined} */ (svgCache.get(svgKey));
           if (cached !== undefined) {
             return await cached;
           }
@@ -403,15 +448,15 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
       };
     } else if (key === 'customAttrCollapse') {
       // Single regex pattern
-      options[key] = parseRegExp(option);
+      optionsDynamic[key] = parseRegExp(option);
     } else if (key === 'customAttrSurround') {
       // Nested array of RegExp pairs: `[[openRegExp, closeRegExp], …]`
-      options[key] = parseNestedRegExpArray(option);
+      optionsDynamic[key] = parseNestedRegExpArray(option);
     } else if (['customAttrAssign', 'customEventAttributes', 'ignoreCustomComments', 'ignoreCustomFragments'].includes(key)) {
       // Array of regex patterns
-      options[key] = parseRegExpArray(option);
+      optionsDynamic[key] = parseRegExpArray(option);
     } else {
-      options[key] = option;
+      optionsDynamic[key] = option;
     }
   });
   return options;

package/src/lib/utils.js

@@ -80,7 +80,10 @@ function identity(value) {
   return value;
 }
 
-/** @param {unknown} value */
+/**
+ * @param {unknown} value
+ * @returns {value is PromiseLike<any>}
+ */
 function isThenable(value) {
   return value != null && typeof value === 'object' && typeof /** @type {any} */ (value).then === 'function';
 }

package/src/lib/whitespace.js

@@ -39,7 +39,7 @@ function collapseWhitespaceAll(str) {
     // 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
+    // For no-break space handling, use the nested regex
     return spaces.replace(RE_NBSP_LEADING_GROUP, '$1 ');
   });
 }

package/src/presets.js

@@ -14,8 +14,7 @@ export const presets = {
     conservativeCollapse: true,
     preserveLineBreaks: true,
     removeComments: true,
-    removeScriptTypeAttributes: true,
-    removeStyleLinkTypeAttributes: true,
+    removeDefaultTypeAttributes: true,
     useShortDoctype: true
   },
   comprehensive: {
@@ -30,11 +29,10 @@ export const presets = {
     minifyURLs: true,
     removeAttributeQuotes: true,
     removeComments: true,
+    removeDefaultTypeAttributes: true,
     removeEmptyAttributes: true,
     removeOptionalTags: true,
     removeRedundantAttributes: true,
-    removeScriptTypeAttributes: true,
-    removeStyleLinkTypeAttributes: true,
     useShortDoctype: true
   }
 };