html-minifier-next 6.2.10 → 7.0.0

package/src/htmlminifier.js

@@ -54,6 +54,8 @@ import {
 
 import { processOptions } from './lib/options.js';
 
+/** @import { ProcessedOptions } from './lib/options.js' */
+
 // Type definitions
 
 /**
@@ -171,7 +173,7 @@ import { processOptions } from './lib/options.js';
  *
  * @prop {RegExp[]} [customAttrAssign]
  *  Array of regexes used to recognise custom attribute assignment
- *  operators (e.g. `'<div flex?="{{mode != cover}}"></div>'`).
+ *  operators (e.g., `'<div flex?="{{mode != cover}}"></div>'`).
  *  These are concatenated with the built-in assignment patterns.
  *
  *  Default: `[]`
@@ -179,16 +181,16 @@ import { processOptions } from './lib/options.js';
  * @prop {RegExp} [customAttrCollapse]
  *  Regex matching attribute names whose values should be collapsed.
  *  Basically used to remove newlines and excess spaces inside attribute values,
- *  e.g. `/ng-class/`.
+ *  e.g., `/ng-class/`.
  *
  * @prop {[RegExp, RegExp][]} [customAttrSurround]
  *  Array of `[openRegExp, closeRegExp]` pairs used by the parser to
  *  detect custom attribute surround patterns (for non-standard syntaxes,
- *  e.g. `<input {{#if value}}checked="checked"{{/if}}>`).
+ *  e.g., `<input {{#if value}}checked="checked"{{/if}}>`).
  *
  * @prop {RegExp[]} [customEventAttributes]
  *  Array of regexes used to detect event handler attributes for `minifyJS`
- *  (e.g. `ng-click`). The default matches standard `on…` event attributes.
+ *  (e.g., `ng-click`). The default matches standard `on…` event attributes.
  *
  *  Default: `[/^on[a-z]{3,}$/]`
  *
@@ -303,13 +305,6 @@ import { processOptions } from './lib/options.js';
  *
  *  Default: `false`
  *
- * @prop {(name: string) => string} [name]
- *  Function used to normalise tag/attribute names. By default, this lowercases
- *  names, unless `caseSensitive` is enabled.
- *
- *  Default: `(name) => name.toLowerCase()`,
- *  or `(name) => name` (no-op function) if `caseSensitive` is enabled.
- *
  * @prop {boolean} [noNewlinesBeforeTagClose]
  *  When wrapping lines, prevent inserting a newline directly before a
  *  closing tag (useful to keep tags like `</a>` on the same line).
@@ -332,6 +327,13 @@ import { processOptions } from './lib/options.js';
  *
  *  Default: `false`
  *
+ * @prop {string} [preset]
+ *  Name of a preset configuration to use as a base (`conservative` or
+ *  `comprehensive`). Explicitly provided options take precedence over
+ *  preset values. Unknown preset names are ignored (with a warning).
+ *
+ *  Default: No preset
+ *
  * @prop {boolean} [preventAttributesEscaping]
  *  When true, attribute values will not be HTML-escaped (dangerous for
  *  untrusted input). By default, attributes are escaped.
@@ -341,7 +343,7 @@ import { processOptions } from './lib/options.js';
  * @prop {string[]} [processScripts]
  *  Array of `type` attribute values for `<script>` elements whose contents
  *  should be processed as HTML
- *  (e.g. `text/ng-template`, `text/x-handlebars-template`, etc.).
+ *  (e.g., `text/ng-template`, `text/x-handlebars-template`, etc.).
  *  When present, the contents of matching script tags are recursively minified,
  *  like normal HTML content.
  *
@@ -366,6 +368,12 @@ import { processOptions } from './lib/options.js';
  *
  *  Default: `false`
  *
+ *  @prop {boolean} [removeDefaultTypeAttributes]
+ *  Remove default `type` attributes from `<style>`/`<link>` (e.g., `type="text/css"`)
+ *  and `<script>` (e.g., `type="text/javascript"`) elements.
+ *
+ *  Default: `false`
+ *
  * @prop {boolean | ((attrName: string, tag: string) => boolean)} [removeEmptyAttributes]
  *  If true, removes attributes whose values are empty (some attributes
  *  are excluded by name). Can also be a function to customise which empty
@@ -420,18 +428,6 @@ import { processOptions } from './lib/options.js';
  *
  *  Default: `false`
  *
- * @prop {boolean} [removeScriptTypeAttributes]
- *  Remove `type` attributes from `<script>` when they are unnecessary
- *  (e.g. `type="text/javascript"`).
- *
- *  Default: `false`
- *
- * @prop {boolean} [removeStyleLinkTypeAttributes]
- *  Remove `type` attributes from `<style>` and `<link>` elements when
- *  they are unnecessary (e.g. `type="text/css"`).
- *
- *  Default: `false`
- *
  * @prop {boolean} [removeTagWhitespace]
  *  **Note that this will result in invalid HTML!**
  *
@@ -469,11 +465,6 @@ import { processOptions } from './lib/options.js';
  *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#use_short_doctype
  *
  *  Default: `false`
- *
- * @prop {boolean} [insideSVG] - Internal: Set when inside SVG/MathML context
- * @prop {boolean} [insideForeignContent] - Internal: Set when inside SVG `foreignObject`
- * @prop {Function} [parentName] - Internal: Preserved name function during namespace transitions
- * @prop {Function} [htmlName] - Internal: HTML name function preserved from outer context
  */
 
 // Lazy-load heavy dependencies only when needed
@@ -717,7 +708,7 @@ function mergeConsecutiveScripts(html) {
 
 /**
  * @param {string} value
- * @param {MinifierOptions} options
+ * @param {ProcessedOptions} options
  * @param {string} uidIgnore
  * @param {string} uidAttr
  * @param {string[]} ignoredMarkupChunks
@@ -725,7 +716,7 @@ function mergeConsecutiveScripts(html) {
 async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupChunks) {
   const attrChains = options.sortAttributes && typeof options.sortAttributes !== 'function' && Object.create(null);
   const classChain = options.sortClassNames && typeof options.sortClassNames !== 'function' && new TokenChain();
-  const resolveName = /** @type {(name: string) => string} */ (options.name);
+  const resolveName = options.name;
 
   function attrNames(/** @type {HTMLAttribute[]} */ attrs) {
     return attrs.map(function (attr) {
@@ -804,7 +795,7 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
   }
 
   // For the first pass, create a copy of options and disable aggressive minification.
-  // Keep attribute transformations (like `removeStyleLinkTypeAttributes`) for accurate analysis.
+  // Keep attribute transformations (like `removeDefaultTypeAttributes`) for accurate analysis.
   // This is safe because `createSortFns` is called before custom fragment UID markers (`uidAttr`) are added.
   // Note: `htmlmin:ignore` UID markers (`uidIgnore`) already exist and are expanded for analysis.
   const firstPassOptions = Object.assign({}, options, {
@@ -818,7 +809,6 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
     decodeEntities: false,
     processScripts: false,
     // Keep `ignoreCustomFragments` to handle template syntax correctly
-    // This is safe because `createSortFns` is now called before UID markers are added
     // Continue on parse errors during analysis (e.g., template syntax)
     continueOnParseError: true,
     log: identity
@@ -848,7 +838,7 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
       uidReplacePattern.lastIndex = 0;
     }
 
-    // First pass minification applies attribute transformations like `removeStyleLinkTypeAttributes` for accurate frequency analysis
+    // First pass minification applies attribute transformations like `removeDefaultTypeAttributes` for accurate frequency analysis
     const firstPassOutput = await minifyHTML(expandedValue, firstPassOptions);
 
     // For frequency analysis, remove custom fragments temporarily
@@ -944,7 +934,7 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
 
 /**
  * @param {string} value - HTML content to minify
- * @param {MinifierOptions} options - Normalized minification options
+ * @param {ProcessedOptions} options - Normalized minification options
  * @param {boolean} [partialMarkup] - Whether treating input as partial markup
  * @returns {Promise<string>} Minified HTML
  */
@@ -958,7 +948,7 @@ async function minifyHTML(value, options, partialMarkup) {
     value = collapseWhitespace(value, options, true, true);
   }
 
-  const resolveName = /** @type {(name: string) => string} */ (options.name);
+  const resolveName = options.name;
   /** @type {HTMLAttribute[]} */
   const emptyAttrs = [];
 
@@ -1015,7 +1005,7 @@ async function minifyHTML(value, options, partialMarkup) {
     }
     removeEmptyElementsExcept = [];
   } else {
-    removeEmptyElementsExcept = parseRemoveEmptyElementsExcept(options.removeEmptyElementsExcept || [], /** @type {any} */ (options)) || [];
+    removeEmptyElementsExcept = parseRemoveEmptyElementsExcept(options.removeEmptyElementsExcept || [], options) || [];
   }
 
   // Temporarily replace ignored chunks with comments, so that there’s no need to worry what’s there;
@@ -1096,8 +1086,8 @@ async function minifyHTML(value, options, partialMarkup) {
           uidAttrLeadingPattern = new RegExp('^\\s*' + uidAttr + '(\\d+)' + uidAttr);
 
           if (options.minifyCSS !== identity) {
-            /** @type {any} */ (options).minifyCSS = (function (/** @type {Function} */ fn) {
-              return function (/** @type {string} */ text, /** @type {string} */ type) {
+            options.minifyCSS = (function (/** @type {ProcessedOptions['minifyCSS']} */ fn) {
+              return function (/** @type {string} */ text, /** @type {string | undefined} */ type) {
                 text = text.replace(/** @type {RegExp} */ (uidPattern), function (/** @type {string} */ _match, /** @type {string} */ _prefix, /** @type {string} */ index) {
                   const chunks = ignoredCustomMarkupChunks[+index];
                   return (chunks?.[1] ?? '') + uidAttr + index + uidAttr + (chunks?.[2] ?? '');
@@ -1105,18 +1095,18 @@ async function minifyHTML(value, options, partialMarkup) {
 
                 return fn(text, type);
               };
-            })(/** @type {Function} */ (options.minifyCSS));
+            })(options.minifyCSS);
           }
 
           if (options.minifyJS !== identity) {
-            options.minifyJS = (function (/** @type {Function} */ fn) {
-              return function (/** @type {string} */ text, /** @type {boolean} */ inline, /** @type {boolean} */ isModule) {
+            options.minifyJS = (function (/** @type {ProcessedOptions['minifyJS']} */ fn) {
+              return function (/** @type {string} */ text, /** @type {boolean | undefined} */ inline, /** @type {boolean | undefined} */ isModule) {
                 return fn(text.replace(/** @type {RegExp} */ (uidPattern), function (/** @type {string} */ _match, /** @type {string} */ _prefix, /** @type {string} */ index) {
                   const chunks = ignoredCustomMarkupChunks[+index];
                   return (chunks?.[1] ?? '') + uidAttr + index + uidAttr + (chunks?.[2] ?? '');
                 }), inline, isModule);
               };
-            })(/** @type {Function} */ (options.minifyJS));
+            })(options.minifyJS);
           }
         }
 
@@ -1128,11 +1118,11 @@ async function minifyHTML(value, options, partialMarkup) {
   }
 
   function canCollapseWhitespace(/** @type {string} */ tag, /** @type {HTMLAttribute[]} */ attrs) {
-    return /** @type {Function} */ (options.canCollapseWhitespace)(tag, attrs, defaultCanCollapseWhitespace);
+    return options.canCollapseWhitespace(tag, attrs, defaultCanCollapseWhitespace);
   }
 
   function canTrimWhitespace(/** @type {string} */ tag, /** @type {HTMLAttribute[]} */ attrs) {
-    return /** @type {Function} */ (options.canTrimWhitespace)(tag, attrs, defaultCanTrimWhitespace);
+    return options.canTrimWhitespace(tag, attrs, defaultCanTrimWhitespace);
   }
 
   function removeStartTag() {
@@ -1195,10 +1185,14 @@ async function minifyHTML(value, options, partialMarkup) {
     start: async function (/** @type {string} */ tag, /** @type {HTMLAttribute[]} */ attrs, /** @type {boolean} */ unary, /** @type {string} */ unarySlash, /** @type {boolean} */ autoGenerated) {
       const lowerTag = tag.toLowerCase();
       if (lowerTag === 'svg' || lowerTag === 'math') {
+        // Preserve the surrounding HTML context’s name function (e.g., `identity`
+        // under `caseSensitive`) so `foreignObject`/`annotation-xml` can restore it
+        const nameHTML = options.name;
         options = Object.create(options);
         options.caseSensitive = true;
         options.keepClosingSlash = true;
         options.name = identity;
+        options.nameHTML = nameHTML;
         options.insideSVG = lowerTag === 'svg';
         options.insideForeignContent = true;
         // Disable HTML-specific options that produce invalid XML:
@@ -1212,23 +1206,24 @@ async function minifyHTML(value, options, partialMarkup) {
       }
       // `foreignObject` in SVG and `annotation-xml` in MathML contain HTML content
       // Note: The element itself is in SVG/MathML namespace, only its children are HTML
-      let useParentNameForTag = false;
+      let useNameParentForTag = false;
       if (options.insideForeignContent && (lowerTag === 'foreignobject' ||
           (lowerTag === 'annotation-xml' && attrs.some((/** @type {HTMLAttribute} */ a) => a.name.toLowerCase() === 'encoding' &&
             RE_HTML_ENCODING.test(a.value ?? ''))))) {
-        const parentName = /** @type {(name: string) => string} */ (options.name);
+        const nameParent = options.name;
         options = Object.create(options);
         options.caseSensitive = false;
         options.keepClosingSlash = false;
-        options.parentName = parentName; // Preserve for the element tag itself
-        options.name = /** @type {(name: string) => string} */ (options.htmlName ?? lowercase);
+        options.nameParent = nameParent; // Preserve for the element tag itself
+        options.name = options.nameHTML ?? lowercase;
         options.insideForeignContent = false;
         // Note: `removeAttributeQuotes`, `removeTagWhitespace`, and `decodeEntities`
         // stay disabled (inherited from SVG context) because the entire SVG block
         // must be valid XML for SVGO processing
-        useParentNameForTag = true;
+        useNameParentForTag = true;
       }
-      tag = /** @type {(name: string) => string} */ (useParentNameForTag ? options.parentName : options.name)(tag);
+      // `nameParent` is always set when `useNameParentForTag` is true; the extra check only narrows the type
+      tag = (useNameParentForTag && options.nameParent ? options.nameParent : options.name)(tag);
       currentTag = tag;
       charsPrevTag = tag;
       if (!inlineTextSet.has(tag)) {
@@ -1297,16 +1292,19 @@ async function minifyHTML(value, options, partialMarkup) {
       deduplicateAttributes(attrs, Boolean(options.caseSensitive));
 
       if (options.sortAttributes) {
-        /** @type {Function} */ (options.sortAttributes)(tag, attrs);
+        // By the time tags are processed, `createSortFns` has replaced any truthy non-function value
+        /** @type {(tag: string, attrs: HTMLAttribute[]) => void} */ (options.sortAttributes)(tag, attrs);
       }
 
       const attrResults = attrs.map(attr => normalizeAttr(attr, attrs, tag, options, minifyHTML));
-      const normalizedAttrs = attrResults.some(isThenable) ? await Promise.all(attrResults) : attrResults;
+      // The `isThenable` probe guarantees the sync branch holds no promises
+      const normalizedAttrs = /** @type {Array<{name: string, value: string | undefined, attr: HTMLAttribute} | undefined>} */ (attrResults.some(isThenable) ? await Promise.all(attrResults) : attrResults);
       const parts = [];
       let isLast = true;
       for (let i = normalizedAttrs.length - 1; i >= 0; i--) {
-        if (normalizedAttrs[i]) {
-          parts.push(buildAttr(normalizedAttrs[i], hasUnarySlash, options, isLast, uidAttr));
+        const normalizedAttr = normalizedAttrs[i];
+        if (normalizedAttr) {
+          parts.push(buildAttr(normalizedAttr, hasUnarySlash, options, isLast, uidAttr));
           isLast = false;
         }
       }
@@ -1336,7 +1334,7 @@ async function minifyHTML(value, options, partialMarkup) {
                  !options.insideForeignContent && Object.getPrototypeOf(options).insideForeignContent) {
         options = Object.getPrototypeOf(options);
       }
-      tag = /** @type {Function} */ (options.name)(tag);
+      tag = options.name(tag);
 
       // Check if current tag is in a whitespace stack
       if (options.collapseWhitespace) {
@@ -1604,10 +1602,10 @@ async function minifyHTML(value, options, partialMarkup) {
           text = await processScript(text, options, currentAttrs, minifyHTML);
         }
         if (needsMinifyJS) {
-          text = await /** @type {Function} */ (options.minifyJS)(text, false, isModuleScript);
+          text = await options.minifyJS(text, false, isModuleScript);
         }
         if (needsMinifyCSS) {
-          text = await /** @type {Function} */ (options.minifyCSS)(text);
+          text = await options.minifyCSS(text);
         }
         charsFinalize(text);
       })();
@@ -1724,7 +1722,7 @@ async function minifyHTML(value, options, partialMarkup) {
       }
 
       if (options.removeComments) {
-        if (isIgnoredComment(text, /** @type {any} */ (options))) {
+        if (isIgnoredComment(text, options)) {
           text = prefix + text + suffix;
         } else {
           text = '';
@@ -1746,10 +1744,11 @@ async function minifyHTML(value, options, partialMarkup) {
 
   // Post-processing: Optimize SVG blocks with SVGO
   // Run all SVGO calls in parallel, then splice results in reverse to preserve indices
-  if (options.minifySVG && svgBlocks.length) {
+  const minifySVG = options.minifySVG;
+  if (minifySVG && svgBlocks.length) {
     const optimized = await Promise.all(
       svgBlocks.map(({ start, end }) =>
-        /** @type {Function} */ (options.minifySVG)(buffer.slice(start, end).join(''))
+        minifySVG(buffer.slice(start, end).join(''))
       )
     );
     for (let i = svgBlocks.length - 1; i >= 0; i--) {
@@ -1803,7 +1802,7 @@ async function minifyHTML(value, options, partialMarkup) {
 
 /**
  * @param {string[]} results
- * @param {MinifierOptions} options
+ * @param {ProcessedOptions} options
  * @param {Function} restoreCustom
  * @param {Function} restoreIgnore
  */
@@ -1905,7 +1904,7 @@ export const minify = async function (value, options) {
   // Initialize caches on first use with configurable sizes
   const caches = initCaches(options || {});
 
-  options = processOptions(options || {}, {
+  const processedOptions = processOptions(options || {}, {
     getLightningCSS,
     getTerser,
     getSwc,
@@ -1914,14 +1913,14 @@ export const minify = async function (value, options) {
     jsMinifyCache: caches.jsMinifyCache ?? undefined,
     svgMinifyCache: caches.svgMinifyCache ?? undefined
   });
-  let result = await minifyHTML(value, options);
+  let result = await minifyHTML(value, processedOptions);
 
   // Post-processing: Merge consecutive inline scripts if enabled
-  if (options.mergeScripts) {
+  if (processedOptions.mergeScripts) {
     result = mergeConsecutiveScripts(result);
   }
 
-  /** @type {Function} */ (options.log)('minified in: ' + (Date.now() - start) + 'ms');
+  processedOptions.log('minified in: ' + (Date.now() - start) + 'ms');
   return result;
 };
 

package/src/htmlparser.js

@@ -428,7 +428,7 @@ export class HTMLParser {
           advance(m[0].length);
           await parseEndTag('</' + stackedTag + '>', stackedTag);
         } else {
-          // No closing tag found; to avoid infinite loop, break similarly to previous behavior
+          // No closing tag found; break to avoid an infinite loop
           if (handler.continueOnParseError && handler.chars && pos < fullLength) {
             const result = handler.chars(fullHtml[pos], prevTag, '', prevAttrs, []);
             if (isThenable(result)) await result;

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;
@@ -380,7 +380,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 +432,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);
     }
@@ -602,7 +603,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 +627,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 +657,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 +677,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'