html-minifier-next 6.2.11 → 7.1.0

package/dist/types/lib/options.d.ts

@@ -1,13 +1,55 @@
-export type MinifierOptions = Record<string, any>;
 /**
- * @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)
  */
-/** @param {MinifierOptions} options */
-export function shouldMinifyInnerHTML(options: MinifierOptions): boolean;
+export type ProcessedOptions = 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;
+};
+/** @import { MinifierOptions, HTMLAttribute } from '../htmlminifier.js' */
+/**
+ * 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
+ */
+/** @param {ProcessedOptions} options */
+export function shouldMinifyInnerHTML(options: ProcessedOptions): boolean;
 /**
  * @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
  */
 export function processOptions(inputOptions: MinifierOptions, { getLightningCSS, getTerser, getSwc, getSvgo, cssMinifyCache, jsMinifyCache, svgMinifyCache }?: {
     getLightningCSS?: Function | undefined;
@@ -17,6 +59,8 @@ export function processOptions(inputOptions: MinifierOptions, { getLightningCSS,
     cssMinifyCache?: LRU | undefined;
     jsMinifyCache?: LRU | undefined;
     svgMinifyCache?: LRU | undefined;
-}): MinifierOptions;
+}): ProcessedOptions;
+import type { MinifierOptions } from '../htmlminifier.js';
+import type { HTMLAttribute } from '../htmlminifier.js';
 import { LRU } from './utils.js';
 //# sourceMappingURL=options.d.ts.map

package/dist/types/lib/options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/lib/options.js"],"names":[],"mappings":"8BAWa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;AADhC;;GAEG;AAMH,uCAAuC;AACvC,+CADY,eAAe,WAW1B;AAID;;;;GAIG;AACH,6CAJW,eAAe,mGACf;IAAC,eAAe,CAAC,EAAE,WAAW,SAAS,CAAC;IAAC,SAAS,CAAC,EAAE,WAAW,SAAS,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,SAAS,CAAC;IAAC,OAAO,CAAC,EAAE,WAAW,SAAS,CAAC;IAAC,cAAc,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC;IAAC,aAAa,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC;IAAC,cAAc,CAAC,EAAE,GAAG,GAAG,SAAS,CAAA;CAAC,GAC5O,eAAe,CA6X3B;oBAhaiG,YAAY"}
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/lib/options.js"],"names":[],"mappings":";;;;;;;+BAmBa,IAAI,CAAC,eAAe,EAAE,QAAQ,GAAG,uBAAuB,GAAG,mBAAmB,GAAG,sBAAsB,GAAG,KAAK,GAAG,WAAW,GAAG,UAAU,GAAG,YAAY,GAAG,WAAW,CAAC,GAAG;IACnL,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAC/B,GAAG,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,OAAO,CAAC;IAC/B,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,qBAAqB,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO,CAAC;IAC7G,iBAAiB,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO,CAAC;IACzG,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACrE,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,OAAO,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC3F,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACvD,SAAS,EAAE,CAAC,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC;IACrE,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACtC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACpC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B;AAzBJ,2EAA2E;AAI3E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH,wCAAwC;AACxC,+CADY,gBAAgB,WAW3B;AAYD;;;;GAIG;AACH,6CAJW,eAAe,mGACf;IAAC,eAAe,CAAC,EAAE,WAAW,SAAS,CAAC;IAAC,SAAS,CAAC,EAAE,WAAW,SAAS,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,SAAS,CAAC;IAAC,OAAO,CAAC,EAAE,WAAW,SAAS,CAAC;IAAC,cAAc,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC;IAAC,aAAa,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC;IAAC,cAAc,CAAC,EAAE,GAAG,GAAG,SAAS,CAAA;CAAC,GAC5O,gBAAgB,CA8Y5B;qCAtcmD,oBAAoB;mCAApB,oBAAoB;oBAP0B,YAAY"}

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

@@ -24,8 +24,11 @@ export function hashContent(str: string): string;
 export function uniqueId(value: string): string;
 /** @param {string} value */
 export function identity(value: string): string;
-/** @param {unknown} value */
-export function isThenable(value: unknown): boolean;
+/**
+ * @param {unknown} value
+ * @returns {value is PromiseLike<any>}
+ */
+export function isThenable(value: unknown): value is PromiseLike<any>;
 /** @param {string} value */
 export function lowercase(value: string): string;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qCAHW,OAAO,GACL,MAAM,CAYlB;AAID;IACE,4BAIC;IAHC,cAAkB;IAClB,mCAAmC;IACnC,KADW,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CACX;IAEtB,0BAA0B;IAC1B,SADY,MAAM,WASjB;IACD;;;OAGG;IACH,SAHW,MAAM,SACN,OAAO,QASjB;IACD,0BAA0B;IAC1B,YADY,MAAM,QACmB;CACtC;AAID,0BAA0B;AAC1B,iCADY,MAAM,UAQjB;AAID,4BAA4B;AAC5B,gCADY,MAAM,UAOjB;AAID,4BAA4B;AAC5B,gCADY,MAAM,UAGjB;AAED,6BAA6B;AAC7B,kCADY,OAAO,WAGlB;AAED,4BAA4B;AAC5B,iCADY,MAAM,UAGjB;AAID;;;;;;GAMG;AACH,kCALW,MAAM,SACN,MAAM,sBAEJ,OAAO,CAAC,MAAM,CAAC,CAc3B;AAID,qCAAqC;AACrC,mCADY,MAAM,GAAG,MAAM,sBAW1B"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qCAHW,OAAO,GACL,MAAM,CAYlB;AAID;IACE,4BAIC;IAHC,cAAkB;IAClB,mCAAmC;IACnC,KADW,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CACX;IAEtB,0BAA0B;IAC1B,SADY,MAAM,WASjB;IACD;;;OAGG;IACH,SAHW,MAAM,SACN,OAAO,QASjB;IACD,0BAA0B;IAC1B,YADY,MAAM,QACmB;CACtC;AAID,0BAA0B;AAC1B,iCADY,MAAM,UAQjB;AAID,4BAA4B;AAC5B,gCADY,MAAM,UAOjB;AAID,4BAA4B;AAC5B,gCADY,MAAM,UAGjB;AAED;;;GAGG;AACH,kCAHW,OAAO,GACL,KAAK,IAAI,WAAW,CAAC,GAAG,CAAC,CAIrC;AAED,4BAA4B;AAC5B,iCADY,MAAM,UAGjB;AAID;;;;;;GAMG;AACH,kCALW,MAAM,SACN,MAAM,sBAEJ,OAAO,CAAC,MAAM,CAAC,CAc3B;AAID,qCAAqC;AACrC,mCADY,MAAM,GAAG,MAAM,sBAW1B"}

package/dist/types/presets.d.ts

@@ -17,8 +17,7 @@ export namespace presets {
         let conservativeCollapse: boolean;
         let preserveLineBreaks: boolean;
         let removeComments: boolean;
-        let removeScriptTypeAttributes: boolean;
-        let removeStyleLinkTypeAttributes: boolean;
+        let removeDefaultTypeAttributes: boolean;
         let useShortDoctype: boolean;
     }
     namespace comprehensive {
@@ -36,13 +35,11 @@ export namespace presets {
         export let removeAttributeQuotes: boolean;
         let removeComments_1: boolean;
         export { removeComments_1 as removeComments };
+        let removeDefaultTypeAttributes_1: boolean;
+        export { removeDefaultTypeAttributes_1 as removeDefaultTypeAttributes };
         export let removeEmptyAttributes: boolean;
         export let removeOptionalTags: boolean;
         export let removeRedundantAttributes: boolean;
-        let removeScriptTypeAttributes_1: boolean;
-        export { removeScriptTypeAttributes_1 as removeScriptTypeAttributes };
-        let removeStyleLinkTypeAttributes_1: boolean;
-        export { removeStyleLinkTypeAttributes_1 as removeStyleLinkTypeAttributes };
         let useShortDoctype_1: boolean;
         export { useShortDoctype_1 as useShortDoctype };
     }

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

@@ -1 +1 @@
-{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/presets.js"],"names":[],"mappings":"AAyCA;;;;GAIG;AACH,gCAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAMvB;AAED;;;GAGG;AACH,kCAFa,MAAM,EAAE,CAIpB"}
+{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/presets.js"],"names":[],"mappings":"AAuCA;;;;GAIG;AACH,gCAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAMvB;AAED;;;GAGG;AACH,kCAFa,MAAM,EAAE,CAIpB"}

package/package.json

@@ -12,32 +12,28 @@
     "svgo": "^4.0.1",
     "terser": "^5.47.1"
   },
-  "description": "Super-configurable and well-tested web page minifier (enhanced successor of HTML Minifier)",
+  "description": "Super-configurable and well-tested web page minifier (enhanced successor to HTML Minifier)",
   "devDependencies": {
-    "@commitlint/cli": "^21.0.1",
+    "@commitlint/cli": "^21.2.0",
     "@eslint/js": "^10.0.1",
-    "@rollup/plugin-commonjs": "^29.0.3",
-    "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^16.0.3",
-    "@swc/core": "^1.15.40",
-    "@types/node": "^25.9.1",
-    "eslint": "^10.4.0",
-    "rollup": "^4.60.4",
-    "rollup-plugin-polyfill-node": "^0.13.0",
+    "@swc/core": "^1.15.41",
+    "@types/node": "^26.1.0",
+    "eslint": "^10.6.0",
     "typescript": "^6.0.3",
-    "vite": "^8.0.14"
+    "vite": "^8.0.16"
+  },
+  "engines": {
+    "node": ">=22"
   },
   "exports": {
     ".": {
       "types": "./dist/types/htmlminifier.d.ts",
-      "import": "./src/htmlminifier.js",
-      "require": "./dist/htmlminifier.cjs"
+      "import": "./src/htmlminifier.js"
     },
     "./package.json": "./package.json"
   },
   "files": [
     "cli.js",
-    "dist/htmlminifier.cjs",
     "dist/types/",
     "src/"
   ],
@@ -68,8 +64,6 @@
     "uglify"
   ],
   "license": "MIT",
-  "main": "./dist/htmlminifier.cjs",
-  "module": "./src/htmlminifier.js",
   "name": "html-minifier-next",
   "peerDependencies": {
     "@swc/core": "^1.15.7"
@@ -84,19 +78,18 @@
     "url": "git+https://github.com/j9t/html-minifier-next.git"
   },
   "scripts": {
-    "build": "tsc && rollup -c",
-    "build:docs": "vite build --base /html-minifier-next/ --outDir build",
+    "build": "tsc",
+    "build:docs": "vite build --base /html-minifier-next/",
     "deploy": "npm run build && npm run build:docs",
     "lint": "eslint .",
-    "prebuild": "node --eval='require(`fs`).rmSync(`dist`,{recursive:true,force:true})'",
+    "prebuild": "node --input-type=module --eval \"import {rmSync} from 'fs';rmSync('dist',{recursive:true,force:true})\"",
     "prepack": "npm run build",
     "prepare": "git config core.hooksPath .githooks || true",
-    "serve": "npm run build && vite",
+    "serve": "vite",
     "test": "npm run test:types && node --test tests/*.spec.js",
-    "test:types": "tsc --project tsconfig.test.json",
+    "test:types": "tsc --noEmit && tsc --project tsconfig.test.json",
     "test:watch": "node --test --watch tests/*.spec.js"
   },
   "type": "module",
-  "types": "./dist/types/htmlminifier.d.ts",
-  "version": "6.2.11"
+  "version": "7.1.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;