html-minifier-next 5.2.2 → 6.1.1

package/README.md

@@ -166,7 +166,6 @@ Options can be used in config files (camelCase) or via CLI flags (kebab-case wit
 | `partialMarkup`<br>`--partial-markup` | Treat input as a partial HTML fragment, preserving stray end tags (closing tags without opening tags) and preventing auto-closing of unclosed tags at end of input | `false` |
 | `preserveLineBreaks`<br>`--preserve-line-breaks` | Always collapse to one line break (never remove it entirely) when whitespace between tags includes a line break—use with `collapseWhitespace: true` | `false` |
 | `preventAttributesEscaping`<br>`--prevent-attributes-escaping` | Prevents the escaping of the values of attributes | `false` |
-| `processConditionalComments`<br>`--process-conditional-comments` | Process contents of conditional comments through minifier | `false` |
 | `processScripts`<br>`--process-scripts` | Array of strings corresponding to types of `script` elements to process through minifier (e.g., `text/ng-template`, `text/x-handlebars-template`, etc.) | `[]` |
 | `quoteCharacter`<br>`--quote-character` | Type of quote to use for attribute values (`'` or `"`) | Auto-detected (uses the quote requiring less escaping; defaults to `"` when equal) |
 | `removeAttributeQuotes`<br>`--remove-attribute-quotes` | [Remove quotes around attributes when possible](https://perfectionkills.com/experimenting-with-html-minifier/#remove_attribute_quotes) | `false` |

package/dist/htmlminifier.cjs

@@ -988,7 +988,6 @@ const presets = {
     collapseWhitespace: true,
     conservativeCollapse: true,
     preserveLineBreaks: true,
-    processConditionalComments: true,
     removeComments: true,
     removeScriptTypeAttributes: true,
     removeStyleLinkTypeAttributes: true,
@@ -1005,7 +1004,6 @@ const presets = {
     minifyJS: true,
     minifySVG: true,
     minifyURLs: true,
-    processConditionalComments: true,
     removeAttributeQuotes: true,
     removeComments: true,
     removeEmptyAttributes: true,
@@ -1045,7 +1043,6 @@ const RE_NBSP_LEADING_GROUP = /(^|\xA0+)[^\xA0]+/g;
 const RE_NBSP_LEAD_GROUP = /(\xA0+)[^\xA0]+/g;
 const RE_NBSP_TRAILING_GROUP = /[^\xA0]+(\xA0+)/g;
 const RE_NBSP_TRAILING_STRIP = /[^\xA0]+$/;
-const RE_CONDITIONAL_COMMENT = /^\[if\s[^\]]+]|\[endif]$/;
 const RE_EVENT_ATTR_DEFAULT = /^on[a-z]{3,}$/;
 const RE_CAN_REMOVE_ATTR_QUOTES = /^[^ \t\n\f\r"'`=<>]+$/;
 const RE_TRAILING_SEMICOLON = /;$/;
@@ -1610,14 +1607,6 @@ function unwrapCSS(text, type) {
   return matches ? matches[1] : text;
 }
 
-async function cleanConditionalComment(comment, options, minifyHTML) {
-  return options.processConditionalComments
-    ? await replaceAsync(comment, /^(\[if\s[^\]]+]>)([\s\S]*?)(<!\[endif])$/, async function (match, prefix, text, suffix) {
-      return prefix + await minifyHTML(text, options, true) + suffix;
-    })
-    : comment;
-}
-
 // Script processing
 
 function minifyJson(text, options) {
@@ -1904,7 +1893,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
         cont: !!options.continueOnMinifyError
       });
 
-      options.minifyJS = async function (text, inline) {
+      options.minifyJS = async function (text, inline, isModule) {
         const start = text.match(/^\s*<!--.*/);
         const code = start ? text.slice(start[0].length).replace(/\n\s*-->\s*$/, '') : text;
 
@@ -1924,7 +1913,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
 
           // 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;
+            + (inline ? '1' : '0') + '|' + (isModule ? 'm' : '') + '|' + useEngine + '|' + optsSig;
 
           const cached = jsMinifyCache.get(jsKey);
           if (cached) {
@@ -1940,7 +1929,8 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
                 parse: {
                   ...terserOptions.parse,
                   bare_returns: inline
-                }
+                },
+                ...(isModule ? { module: true } : {}) // Overrides user options: module detection takes precedence for `<script type=module>`
               };
               const terser = await getTerser();
               const result = await terser(code, terserCallOptions);
@@ -1951,7 +1941,8 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
               const result = await swc.minify(code, {
                 compress: true,
                 mangle: true,
-                ...swcOptions, // User options override defaults
+                ...swcOptions,
+                ...(isModule ? { module: true } : {}) // Overrides user options: module detection takes precedence for `<script type=module>`
               });
               return result.code.replace(RE_TRAILING_SEMICOLON, '');
             }
@@ -2094,10 +2085,6 @@ async function getDecodeHTMLStrict() {
 
 // Validators
 
-function isConditionalComment(text) {
-  return RE_CONDITIONAL_COMMENT.test(text);
-}
-
 function isIgnoredComment(text, options) {
   for (let i = 0, len = options.ignoreCustomComments.length; i < len; i++) {
     if (options.ignoreCustomComments[i].test(text)) {
@@ -3083,12 +3070,14 @@ function mergeConsecutiveScripts(html) {
         return match;
       }
 
-      // Check `type` compatibility (both must be same, or both default JS)
-      const type1 = a1.type || '';
-      const type2 = a2.type || '';
+      // Check `type` compatibility (both must be default JS)
+      const type1 = (a1.type || '').toLowerCase();
+      const type2 = (a2.type || '').toLowerCase();
 
-      if (DEFAULT_JS_TYPES.has(type1) && DEFAULT_JS_TYPES.has(type2)) ; else if (type1 === type2) ; else {
-        // Incompatible types
+      if (DEFAULT_JS_TYPES.has(type1) && DEFAULT_JS_TYPES.has(type2)) ; else {
+        // Non-JS types (modules, JSON, etc.) must not be merged:
+        // Module scripts have per-script lexical scope, and non-JS content (e.g., JSON)
+        // is not concatenable. Even identical non-JS types are incompatible.
         return match;
       }
 
@@ -3415,13 +3404,6 @@ function mergeConsecutiveScripts(html) {
  *
  *  Default: `false`
  *
- * @prop {boolean} [processConditionalComments]
- *  When true, conditional comments (for example `<!--[if IE]> … <![endif]-->`)
- *  will have their inner content processed by the minifier.
- *  Useful to minify HTML that appears inside conditional comments.
- *
- *  Default: `false`
- *
  * @prop {string[]} [processScripts]
  *  Array of `type` attribute values for `<script>` elements whose contents
  *  should be processed as HTML
@@ -3909,11 +3891,11 @@ async function minifyHTML(value, options, partialMarkup) {
 
         if (options.minifyJS) {
           options.minifyJS = (function (fn) {
-            return function (text, type) {
+            return function (text, inline, isModule) {
               return fn(text.replace(uidPattern, function (match, prefix, index) {
                 const chunks = ignoredCustomMarkupChunks[+index];
                 return chunks[1] + uidAttr + index + uidAttr + chunks[2];
-              }), type);
+              }), inline, isModule);
             };
           })(options.minifyJS);
         }
@@ -4236,6 +4218,9 @@ async function minifyHTML(value, options, partialMarkup) {
       const needsDecode = options.decodeEntities && text && !specialContentElements.has(currentTag) && text.indexOf('&') !== -1;
       const needsProcessScript = specialContentElements.has(currentTag) && (options.processScripts || hasJsonScriptType(currentAttrs));
       const needsMinifyJS = options.minifyJS !== identity && isExecutableScript(currentTag, currentAttrs);
+      const isModuleScript = needsMinifyJS && currentAttrs.some(
+        a => a.name.toLowerCase() === 'type' && (a.value ?? '').trim().toLowerCase() === 'module'
+      );
       const needsMinifyCSS = options.minifyCSS !== identity && isStyleElement(currentTag, currentAttrs);
 
       // Whitespace collapsing phase (sync); captures `prevTag`/`nextTag`/`prevAttrs`/`nextAttrs` from outer scope
@@ -4362,7 +4347,7 @@ async function minifyHTML(value, options, partialMarkup) {
           text = await processScript(text, options, currentAttrs, minifyHTML);
         }
         if (needsMinifyJS) {
-          text = await options.minifyJS(text);
+          text = await options.minifyJS(text, false, isModuleScript);
         }
         if (needsMinifyCSS) {
           text = await options.minifyCSS(text);
@@ -4457,16 +4442,9 @@ async function minifyHTML(value, options, partialMarkup) {
         buffer.push(comment);
       }
 
-      // Only conditional comments require async work (recursive minification)
-      if (isConditionalComment(text)) {
-        return cleanConditionalComment(text, options, minifyHTML).then(cleaned => {
-          commentFinalize(prefix + cleaned + suffix);
-        });
-      }
-
       if (options.removeComments) {
         if (isIgnoredComment(text, options)) {
-          text = '<!--' + text + '-->';
+          text = prefix + text + suffix;
         } else {
           text = '';
         }

package/dist/types/htmlminifier.d.ts

@@ -11,11 +11,11 @@ export default _default;
  */
 export type HTMLAttribute = {
     name: string;
-    value?: string;
-    quote?: string;
-    customAssign?: string;
-    customOpen?: string;
-    customClose?: string;
+    value?: string | undefined;
+    quote?: string | undefined;
+    customAssign?: string | undefined;
+    customOpen?: string | undefined;
+    customClose?: string | undefined;
 };
 /**
  * Options that control how HTML is minified. All of these are optional
@@ -28,14 +28,14 @@ export type MinifierOptions = {
      *
      * Default: Built-in `canCollapseWhitespace` function
      */
-    canCollapseWhitespace?: (tag: string, attrs: HTMLAttribute[], canCollapseWhitespace: (tag: string) => boolean) => boolean;
+    canCollapseWhitespace?: ((tag: string, attrs: HTMLAttribute[], canCollapseWhitespace: (tag: string) => boolean) => boolean) | undefined;
     /**
      * Predicate that determines whether leading/trailing whitespace around
      * the element may be trimmed.
      *
      * Default: Built-in `canTrimWhitespace` function
      */
-    canTrimWhitespace?: (tag: string | null, attrs: HTMLAttribute[] | undefined, canTrimWhitespace: (tag: string) => boolean) => boolean;
+    canTrimWhitespace?: ((tag: string | null, attrs: HTMLAttribute[] | undefined, canTrimWhitespace: (tag: string) => boolean) => boolean) | undefined;
     /**
      * The maximum number of entries for the CSS minification cache. Higher values
      * improve performance for inputs with repeated CSS (e.g., batch processing).
@@ -45,7 +45,7 @@ export type MinifierOptions = {
      *
      * Default: `500`
      */
-    cacheCSS?: number;
+    cacheCSS?: number | undefined;
     /**
      * The maximum number of entries for the JavaScript minification cache. Higher
      * values improve performance for inputs with repeated JavaScript.
@@ -55,7 +55,7 @@ export type MinifierOptions = {
      *
      * Default: `500`
      */
-    cacheJS?: number;
+    cacheJS?: number | undefined;
     /**
      * The maximum number of entries for the SVG minification cache. Higher
      * values improve performance for inputs with repeated SVG content.
@@ -65,7 +65,7 @@ export type MinifierOptions = {
      *
      * Default: `500`
      */
-    cacheSVG?: number;
+    cacheSVG?: number | undefined;
     /**
      * When true, tag and attribute names are treated as case-sensitive.
      * Useful for custom HTML tags.
@@ -73,7 +73,7 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    caseSensitive?: boolean;
+    caseSensitive?: boolean | undefined;
     /**
      * Collapse multiple whitespace characters within attribute values into a
      * single space. Also trims leading and trailing whitespace from attribute
@@ -82,7 +82,7 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    collapseAttributeWhitespace?: boolean;
+    collapseAttributeWhitespace?: boolean | undefined;
     /**
      * Collapse boolean attributes to their name only (for example
      * `disabled="disabled"` → `disabled`).
@@ -90,7 +90,7 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    collapseBooleanAttributes?: boolean;
+    collapseBooleanAttributes?: boolean | undefined;
     /**
      * When false (default) whitespace around `inline` tags is preserved in
      * more cases. When true, whitespace around inline tags may be collapsed.
@@ -98,7 +98,7 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    collapseInlineTagWhitespace?: boolean;
+    collapseInlineTagWhitespace?: boolean | undefined;
     /**
      * Collapse multiple whitespace characters into one where allowed. Also
      * controls trimming behaviour in several code paths.
@@ -106,7 +106,7 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    collapseWhitespace?: boolean;
+    collapseWhitespace?: boolean | undefined;
     /**
      * If true, be conservative when collapsing whitespace (preserve more
      * whitespace in edge cases). Affects collapse algorithms.
@@ -114,7 +114,7 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    conservativeCollapse?: boolean;
+    conservativeCollapse?: boolean | undefined;
     /**
      * When set to `false`, minification errors may throw.
      * By default, the minifier will attempt to recover from minification
@@ -122,14 +122,14 @@ export type MinifierOptions = {
      *
      * Default: `true`
      */
-    continueOnMinifyError?: boolean;
+    continueOnMinifyError?: boolean | undefined;
     /**
      * When true, the parser will attempt to continue on recoverable parse
      * errors. Otherwise, parsing errors may throw.
      *
      * Default: `false`
      */
-    continueOnParseError?: boolean;
+    continueOnParseError?: boolean | undefined;
     /**
      * Array of regexes used to recognise custom attribute assignment
      * operators (e.g. `'<div flex?="{{mode != cover}}"></div>'`).
@@ -137,40 +137,40 @@ export type MinifierOptions = {
      *
      * Default: `[]`
      */
-    customAttrAssign?: RegExp[];
+    customAttrAssign?: RegExp[] | undefined;
     /**
      * Regex matching attribute names whose values should be collapsed.
      * Basically used to remove newlines and excess spaces inside attribute values,
      * e.g. `/ng-class/`.
      */
-    customAttrCollapse?: RegExp;
+    customAttrCollapse?: RegExp | undefined;
     /**
      * 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}}>`).
      */
-    customAttrSurround?: [RegExp, RegExp][];
+    customAttrSurround?: [RegExp, RegExp][] | undefined;
     /**
      * Array of regexes used to detect event handler attributes for `minifyJS`
      * (e.g. `ng-click`). The default matches standard `on…` event attributes.
      *
      * Default: `[/^on[a-z]{3,}$/]`
      */
-    customEventAttributes?: RegExp[];
+    customEventAttributes?: RegExp[] | undefined;
     /**
      * Limits the quantifier used when building a safe regex for custom
      * fragments to avoid ReDoS. See source use for details.
      *
      * Default: `200`
      */
-    customFragmentQuantifierLimit?: number;
+    customFragmentQuantifierLimit?: number | undefined;
     /**
      * When true, decodes HTML entities in text and attributes before
      * processing, and re-encodes ambiguous ampersands when outputting.
      *
      * Default: `false`
      */
-    decodeEntities?: boolean;
+    decodeEntities?: boolean | undefined;
     /**
      * Comments matching any pattern in this array of regexes will be
      * preserved when `removeComments` is enabled. The default preserves
@@ -178,7 +178,7 @@ export type MinifierOptions = {
      *
      * Default: `[/^!/, /^\s*#/]`
      */
-    ignoreCustomComments?: RegExp[];
+    ignoreCustomComments?: RegExp[] | undefined;
     /**
      * Array of regexes used to identify fragments that should be
      * preserved (for example server templates). These fragments are temporarily
@@ -187,27 +187,27 @@ export type MinifierOptions = {
      *
      * Default: `[/<%[\s\S]*?%>/, /<\?[\s\S]*?\?>/]`
      */
-    ignoreCustomFragments?: RegExp[];
+    ignoreCustomFragments?: RegExp[] | undefined;
     /**
      * If false, tags marked as auto-generated by the parser will be omitted
      * from output. Useful to skip injected tags.
      *
      * Default: `false`
      */
-    includeAutoGeneratedTags?: boolean;
+    includeAutoGeneratedTags?: boolean | undefined;
     /**
      * Collection of custom element tag names that should be treated as inline
      * elements for white-space handling, alongside the built-in inline elements.
      *
      * Default: `[]`
      */
-    inlineCustomElements?: ArrayLike<string>;
+    inlineCustomElements?: ArrayLike<string> | undefined;
     /**
      * Preserve the trailing slash in self-closing tags when present.
      *
      * Default: `false`
      */
-    keepClosingSlash?: boolean;
+    keepClosingSlash?: boolean | undefined;
     /**
      * Logging function used by the minifier for warnings/errors/info.
      * You can directly provide `console.log`, but `message` may also be an `Error`
@@ -215,7 +215,7 @@ export type MinifierOptions = {
      *
      * Default: `() => {}` (no-op function)
      */
-    log?: (message: unknown) => void;
+    log?: ((message: unknown) => void) | undefined;
     /**
      * The maximum allowed input length. Used as a guard against ReDoS via
      * pathological inputs. If the input exceeds this length an error is
@@ -223,14 +223,14 @@ export type MinifierOptions = {
      *
      * Default: No limit
      */
-    maxInputLength?: number;
+    maxInputLength?: number | undefined;
     /**
      * Maximum line length for the output. When set the minifier will wrap
      * output to the given number of characters where possible.
      *
      * Default: No limit
      */
-    maxLineLength?: number;
+    maxLineLength?: number | undefined;
     /**
      * When true, consecutive inline `<script>` elements are merged into one.
      * Only merges compatible scripts (same `type`, matching `async`/`defer`/
@@ -238,7 +238,7 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    mergeScripts?: boolean;
+    mergeScripts?: boolean | undefined;
     /**
      * When true, enables CSS minification for inline `<style>` tags or
      * `style` attributes. If an object is provided, it is passed to
@@ -248,7 +248,7 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    minifyCSS?: boolean | Partial<import("lightningcss").TransformOptions<import("lightningcss").CustomAtRules>> | ((text: string, type?: string) => Promise<string> | string);
+    minifyCSS?: boolean | Partial<import("lightningcss").TransformOptions<import("lightningcss").CustomAtRules>> | ((text: string, type?: string) => Promise<string> | string) | undefined;
     /**
      * When true, enables JS minification for `<script>` contents and
      * event handler attributes. If an object is provided, it can include:
@@ -263,9 +263,9 @@ export type MinifierOptions = {
      * Default: `false`
      */
     minifyJS?: boolean | import("terser").MinifyOptions | {
-        engine?: "terser" | "swc";
         [key: string]: any;
-    } | ((text: string, inline?: boolean) => Promise<string> | string);
+        engine?: "terser" | "swc";
+    } | ((text: string, inline?: boolean) => Promise<string> | string) | undefined;
     /**
      * When true, enables URL rewriting/minification. If an object is provided,
      * the `site` property sets the base URL for computing relative paths.
@@ -275,9 +275,9 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    minifyURLs?: boolean | string | {
+    minifyURLs?: string | boolean | {
         site?: string;
-    } | ((text: string) => Promise<string> | string);
+    } | ((text: string) => Promise<string> | string) | undefined;
     /**
      * When true, enables SVG minification using [SVGO](https://github.com/svg/svgo).
      * Complete SVG subtrees are extracted and optimized as a block.
@@ -286,7 +286,7 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    minifySVG?: boolean | any;
+    minifySVG?: boolean | Object | undefined;
     /**
      * Function used to normalise tag/attribute names. By default, this lowercases
      * names, unless `caseSensitive` is enabled.
@@ -294,14 +294,14 @@ export type MinifierOptions = {
      * Default: `(name) => name.toLowerCase()`,
      * or `(name) => name` (no-op function) if `caseSensitive` is enabled.
      */
-    name?: (name: string) => string;
+    name?: ((name: string) => string) | undefined;
     /**
      * When wrapping lines, prevent inserting a newline directly before a
      * closing tag (useful to keep tags like `</a>` on the same line).
      *
      * Default: `false`
      */
-    noNewlinesBeforeTagClose?: boolean;
+    noNewlinesBeforeTagClose?: boolean | undefined;
     /**
      * When true, treat input as a partial HTML fragment rather than a complete
      * document. This preserves stray end tags (closing tags without corresponding
@@ -311,7 +311,7 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    partialMarkup?: boolean;
+    partialMarkup?: boolean | undefined;
     /**
      * Preserve a single line break at the start/end of text nodes when
      * collapsing/trimming whitespace.
@@ -319,22 +319,14 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    preserveLineBreaks?: boolean;
+    preserveLineBreaks?: boolean | undefined;
     /**
      * When true, attribute values will not be HTML-escaped (dangerous for
      * untrusted input). By default, attributes are escaped.
      *
      * Default: `false`
      */
-    preventAttributesEscaping?: boolean;
-    /**
-     * When true, conditional comments (for example `<!--[if IE]> … <![endif]-->`)
-     * will have their inner content processed by the minifier.
-     * Useful to minify HTML that appears inside conditional comments.
-     *
-     * Default: `false`
-     */
-    processConditionalComments?: boolean;
+    preventAttributesEscaping?: boolean | undefined;
     /**
      * Array of `type` attribute values for `<script>` elements whose contents
      * should be processed as HTML
@@ -344,21 +336,21 @@ export type MinifierOptions = {
      *
      * Default: `[]`
      */
-    processScripts?: string[];
+    processScripts?: string[] | undefined;
     /**
      * Preferred quote character for attribute values. If unspecified the
      * minifier picks the safest quote based on the attribute value.
      *
      * Default: Auto-detected
      */
-    quoteCharacter?: "\"" | "'";
+    quoteCharacter?: "\"" | "'" | undefined;
     /**
      * Remove quotes around attribute values where it is safe to do so.
      * See also: https://perfectionkills.com/experimenting-with-html-minifier/#remove_attribute_quotes
      *
      * Default: `false`
      */
-    removeAttributeQuotes?: boolean;
+    removeAttributeQuotes?: boolean | undefined;
     /**
      * Remove HTML comments. Comments that match `ignoreCustomComments` will
      * still be preserved.
@@ -366,7 +358,7 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    removeComments?: boolean;
+    removeComments?: boolean | undefined;
     /**
      * If true, removes attributes whose values are empty (some attributes
      * are excluded by name). Can also be a function to customise which empty
@@ -375,7 +367,7 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    removeEmptyAttributes?: boolean | ((attrName: string, tag: string) => boolean);
+    removeEmptyAttributes?: boolean | ((attrName: string, tag: string) => boolean) | undefined;
     /**
      * Remove elements that are empty and safe to remove (for example
      * `<script />` without `src`).
@@ -383,7 +375,7 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    removeEmptyElements?: boolean;
+    removeEmptyElements?: boolean | undefined;
     /**
      * Specifies empty elements to preserve when `removeEmptyElements` is enabled.
      * Has no effect unless `removeEmptyElements: true`.
@@ -409,7 +401,7 @@ export type MinifierOptions = {
      *
      * Default: `[]`
      */
-    removeEmptyElementsExcept?: string[];
+    removeEmptyElementsExcept?: string[] | undefined;
     /**
      * Drop optional start/end tags where the HTML specification permits it
      * (for example `</li>`, optional `<html>` etc.).
@@ -417,7 +409,7 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    removeOptionalTags?: boolean;
+    removeOptionalTags?: boolean | undefined;
     /**
      * Remove attributes that are redundant because they match the element’s
      * default values (for example `<button type="submit">`).
@@ -425,21 +417,21 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    removeRedundantAttributes?: boolean;
+    removeRedundantAttributes?: boolean | undefined;
     /**
      * Remove `type` attributes from `<script>` when they are unnecessary
      * (e.g. `type="text/javascript"`).
      *
      * Default: `false`
      */
-    removeScriptTypeAttributes?: boolean;
+    removeScriptTypeAttributes?: boolean | undefined;
     /**
      * Remove `type` attributes from `<style>` and `<link>` elements when
      * they are unnecessary (e.g. `type="text/css"`).
      *
      * Default: `false`
      */
-    removeStyleLinkTypeAttributes?: boolean;
+    removeStyleLinkTypeAttributes?: boolean | undefined;
     /**
      * **Note that this will result in invalid HTML!**
      *
@@ -449,7 +441,7 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    removeTagWhitespace?: boolean;
+    removeTagWhitespace?: boolean | undefined;
     /**
      * When true, enables sorting of attributes. If a function is provided it
      * will be used as a custom attribute sorter, which should mutate `attrs`
@@ -458,7 +450,7 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    sortAttributes?: boolean | ((tag: string, attrs: HTMLAttribute[]) => void);
+    sortAttributes?: boolean | ((tag: string, attrs: HTMLAttribute[]) => void) | undefined;
     /**
      * When true, enables sorting of class names inside `class` attributes.
      * If a function is provided, it will be used to transform/sort the class
@@ -467,7 +459,7 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    sortClassNames?: boolean | ((value: string) => string);
+    sortClassNames?: boolean | ((value: string) => string) | undefined;
     /**
      * When true, whitespace around ignored custom fragments may be trimmed
      * more aggressively. This affects how preserved fragments interact with
@@ -475,14 +467,14 @@ export type MinifierOptions = {
      *
      * Default: `false`
      */
-    trimCustomFragments?: boolean;
+    trimCustomFragments?: boolean | undefined;
     /**
      * Replace the HTML doctype with the short `<!doctype html>` form.
      * See also: https://perfectionkills.com/experimenting-with-html-minifier/#use_short_doctype
      *
      * Default: `false`
      */
-    useShortDoctype?: boolean;
+    useShortDoctype?: boolean | undefined;
 };
 import { presets } from './presets.js';
 import { getPreset } from './presets.js';

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

@@ -1 +1 @@
-{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"AAyrDO,8BAJI,MAAM,YACN,eAAe,GACb,OAAO,CAAC,MAAM,CAAC,CAwB3B;;;;;;;;;;;;UA99CS,MAAM;;;;;;;;;;;;;;;;;;mCAaA,MAAM,SAAS,aAAa,EAAE,yBAAyB,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO;;;;;;;+BAM3F,MAAM,GAAG,IAAI,SAAS,aAAa,EAAE,GAAG,SAAS,qBAAqB,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6JtG,OAAO,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2HA2BiF,MAAM,SAAS,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM;;;;;;;;;;;;;;;;iBASxG,QAAQ,GAAG,KAAK;gBAAgC,MAAM,WAAW,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM;;;;;;;;;;;eAa/H,MAAM;gBAAY,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM;;;;;;;;;;;;;;;;;mBAiBzE,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDA+DF,MAAM,OAAO,MAAM,KAAK,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCA2EpC,MAAM,SAAS,aAAa,EAAE,KAAK,IAAI;;;;;;;;;wCAQrC,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;wBAjnBK,cAAc;0BAAd,cAAc;+BAAd,cAAc"}

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

@@ -1,4 +1,3 @@
-export function isConditionalComment(text: any): boolean;
 export function isIgnoredComment(text: any, options: any): boolean;
 export function isEventAttribute(attrName: any, options: any): boolean;
 export function canRemoveAttributeQuotes(value: any): boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../src/lib/attributes.js"],"names":[],"mappings":"AAoCA,yDAEC;AAED,mEAOC;AAED,uEAWC;AAED,8DAGC;AAED,4EAOC;AAgCD,mGAuCC;AAED,mEAGC;AAED,qEAGC;AAED,kEAWC;AAED,sEAGC;AAED,8DAWC;AAED,2EAIC;AAmBD,qEAGC;AAgBD,wEAGC;AAED,sEAUC;AAED,2EAEC;AAED,2DAEC;AAED,8DAUC;AAED,uEAUC;AAED,oGASC;AAED,4DAOC;AAMD,iIA0KC;AAwBD,mGAYC;AA0CD,6GAuHC;AAllBD;;;;;;;GAOG;AACH,mEAHW,OAAO,SAuBjB"}
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../src/lib/attributes.js"],"names":[],"mappings":"AAmCA,mEAOC;AAED,uEAWC;AAED,8DAGC;AAED,4EAOC;AAgCD,mGAuCC;AAED,mEAGC;AAED,qEAGC;AAED,kEAWC;AAED,sEAGC;AAED,8DAWC;AAED,2EAIC;AAmBD,qEAGC;AAgBD,wEAGC;AAED,sEAUC;AAED,2EAEC;AAED,2DAEC;AAED,8DAUC;AAED,uEAUC;AAED,oGASC;AAED,4DAOC;AAMD,iIA0KC;AAwBD,mGAYC;AA0CD,6GAuHC;AAllBD;;;;;;;GAOG;AACH,mEAHW,OAAO,SAuBjB"}

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

@@ -5,7 +5,6 @@ export const RE_NBSP_LEADING_GROUP: RegExp;
 export const RE_NBSP_LEAD_GROUP: RegExp;
 export const RE_NBSP_TRAILING_GROUP: RegExp;
 export const RE_NBSP_TRAILING_STRIP: RegExp;
-export const RE_CONDITIONAL_COMMENT: RegExp;
 export const RE_EVENT_ATTR_DEFAULT: RegExp;
 export const RE_CAN_REMOVE_ATTR_QUOTES: RegExp;
 export const RE_TRAILING_SEMICOLON: RegExp;

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

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/lib/constants.js"],"names":[],"mappings":"AAEA,iCAAoC;AACpC,+BAAkC;AAClC,oCAA2C;AAC3C,2CAAmD;AACnD,wCAA8C;AAC9C,4CAAkD;AAClD,4CAA2C;AAC3C,4CAA0D;AAC1D,2CAA8C;AAC9C,+CAA0D;AAC1D,2CAAmC;AACnC,mCAA4C;AAC5C,wCAAwqB;AACxqB,kCAA0B;AAC1B,sCAAuC;AACvC,yCAA4C;AAC5C,qCAAuD;AAKvD,+DAAgb;AAGhb,+DAA6O;AAG7O,yDAAmF;AAGnF,8CAA8G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0C9G,qDAWG;AAEH,+CAEG;AAuBH,0CAUG;AA7BH,0CAAwhB;AAExhB,yCAAkD;AAMlD,yDAGG;AAIH,yCAAkD;AAuBlD,4CAAiF;AAEjF,0CAAoM;AAEpM,yCAA4F;AAE5F,8CAAkD;AAElD,yCAAiT;AAEjT,0CAA0F;AAE1F,6CAA8D;AAE9D,gDAAqD;AAErD,yCAAuD;AAEvD,+CAAyD;AAEzD,+CAAkE;AAElE,uCAA2C;AAE3C,2CAA2D;AAE3D,0CAAkD;AAElD,wCAA+D;AAE/D,2CAAkD;AAElD,uCAAmxC;AAInxC,sCAEsD;AAItD,iDAA4D"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/lib/constants.js"],"names":[],"mappings":"AAEA,iCAAoC;AACpC,+BAAkC;AAClC,oCAA2C;AAC3C,2CAAmD;AACnD,wCAA8C;AAC9C,4CAAkD;AAClD,4CAA2C;AAC3C,2CAA8C;AAC9C,+CAA0D;AAC1D,2CAAmC;AACnC,mCAA4C;AAC5C,wCAAwqB;AACxqB,kCAA0B;AAC1B,sCAAuC;AACvC,yCAA4C;AAC5C,qCAAuD;AAKvD,+DAAgb;AAGhb,+DAA6O;AAG7O,yDAAmF;AAGnF,8CAA8G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0C9G,qDAWG;AAEH,+CAEG;AAuBH,0CAUG;AA7BH,0CAAwhB;AAExhB,yCAAkD;AAMlD,yDAGG;AAIH,yCAAkD;AAuBlD,4CAAiF;AAEjF,0CAAoM;AAEpM,yCAA4F;AAE5F,8CAAkD;AAElD,yCAAiT;AAEjT,0CAA0F;AAE1F,6CAA8D;AAE9D,gDAAqD;AAErD,yCAAuD;AAEvD,+CAAyD;AAEzD,+CAAkE;AAElE,uCAA2C;AAE3C,2CAA2D;AAE3D,0CAAkD;AAElD,wCAA+D;AAE/D,2CAAkD;AAElD,uCAAmxC;AAInxC,sCAEsD;AAItD,iDAA4D"}

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

@@ -1,6 +1,5 @@
 export function wrapCSS(text: any, type: any): any;
 export function unwrapCSS(text: any, type: any): any;
-export function cleanConditionalComment(comment: any, options: any, minifyHTML: any): Promise<any>;
 export function minifyJson(text: any, options: any): any;
 export function hasJsonScriptType(attrs: any): boolean;
 export function processScript(text: any, options: any, currentAttrs: any, minifyHTML: any): Promise<any>;

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

@@ -1 +1 @@
-{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../../src/lib/content.js"],"names":[],"mappings":"AAYA,mDASC;AAED,qDAWC;AAED,mGAMC;AAID,yDAWC;AAED,uDAWC;AAED,yGAiBC"}
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../../src/lib/content.js"],"names":[],"mappings":"AAWA,mDASC;AAED,qDAWC;AAID,yDAWC;AAED,uDAWC;AAED,yGAiBC"}

package/dist/types/lib/option-definitions.d.ts

@@ -177,108 +177,102 @@ export namespace optionDefinitions {
         let type_29: string;
         export { type_29 as type };
     }
-    namespace processConditionalComments {
+    namespace processScripts {
         let description_30: string;
         export { description_30 as description };
         let type_30: string;
         export { type_30 as type };
     }
-    namespace processScripts {
+    namespace quoteCharacter {
         let description_31: string;
         export { description_31 as description };
         let type_31: string;
         export { type_31 as type };
     }
-    namespace quoteCharacter {
+    namespace removeAttributeQuotes {
         let description_32: string;
         export { description_32 as description };
         let type_32: string;
         export { type_32 as type };
     }
-    namespace removeAttributeQuotes {
+    namespace removeComments {
         let description_33: string;
         export { description_33 as description };
         let type_33: string;
         export { type_33 as type };
     }
-    namespace removeComments {
+    namespace removeEmptyAttributes {
         let description_34: string;
         export { description_34 as description };
         let type_34: string;
         export { type_34 as type };
     }
-    namespace removeEmptyAttributes {
+    namespace removeEmptyElements {
         let description_35: string;
         export { description_35 as description };
         let type_35: string;
         export { type_35 as type };
     }
-    namespace removeEmptyElements {
+    namespace removeEmptyElementsExcept {
         let description_36: string;
         export { description_36 as description };
         let type_36: string;
         export { type_36 as type };
     }
-    namespace removeEmptyElementsExcept {
+    namespace removeOptionalTags {
         let description_37: string;
         export { description_37 as description };
         let type_37: string;
         export { type_37 as type };
     }
-    namespace removeOptionalTags {
+    namespace removeRedundantAttributes {
         let description_38: string;
         export { description_38 as description };
         let type_38: string;
         export { type_38 as type };
     }
-    namespace removeRedundantAttributes {
+    namespace removeScriptTypeAttributes {
         let description_39: string;
         export { description_39 as description };
         let type_39: string;
         export { type_39 as type };
     }
-    namespace removeScriptTypeAttributes {
+    namespace removeStyleLinkTypeAttributes {
         let description_40: string;
         export { description_40 as description };
         let type_40: string;
         export { type_40 as type };
     }
-    namespace removeStyleLinkTypeAttributes {
+    namespace removeTagWhitespace {
         let description_41: string;
         export { description_41 as description };
         let type_41: string;
         export { type_41 as type };
     }
-    namespace removeTagWhitespace {
+    namespace sortAttributes {
         let description_42: string;
         export { description_42 as description };
         let type_42: string;
         export { type_42 as type };
     }
-    namespace sortAttributes {
+    namespace sortClassNames {
         let description_43: string;
         export { description_43 as description };
         let type_43: string;
         export { type_43 as type };
     }
-    namespace sortClassNames {
+    namespace trimCustomFragments {
         let description_44: string;
         export { description_44 as description };
         let type_44: string;
         export { type_44 as type };
     }
-    namespace trimCustomFragments {
+    namespace useShortDoctype {
         let description_45: string;
         export { description_45 as description };
         let type_45: string;
         export { type_45 as type };
     }
-    namespace useShortDoctype {
-        let description_46: string;
-        export { description_46 as description };
-        let type_46: string;
-        export { type_46 as type };
-    }
 }
 export namespace optionDefaults {
     let continueOnMinifyError_1: boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/lib/options.js"],"names":[],"mappings":"AAYA,6DAUC;AAID;;;;;;;;;;;GAWG;AACH,6CAXW,OAAO,CAAC,eAAe,CAAC,mGAEhC;IAAuB,eAAe;IACf,SAAS;IACT,MAAM;CAA2B,GAK9C,eAAe,CA+W3B"}
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/lib/options.js"],"names":[],"mappings":"AAYA,6DAUC;AAID;;;;;;;;;;;GAWG;AACH,6CAXW,OAAO,CAAC,eAAe,CAAC,mGAEhC;IAAuB,eAAe;IACf,SAAS;IACT,MAAM;CAA2B,GAK9C,eAAe,CAiX3B"}

package/dist/types/presets.d.ts

@@ -16,7 +16,6 @@ export namespace presets {
         let collapseWhitespace: boolean;
         let conservativeCollapse: boolean;
         let preserveLineBreaks: boolean;
-        let processConditionalComments: boolean;
         let removeComments: boolean;
         let removeScriptTypeAttributes: boolean;
         let removeStyleLinkTypeAttributes: boolean;
@@ -35,8 +34,6 @@ export namespace presets {
         export let minifyJS: boolean;
         export let minifySVG: boolean;
         export let minifyURLs: boolean;
-        let processConditionalComments_1: boolean;
-        export { processConditionalComments_1 as processConditionalComments };
         export let removeAttributeQuotes: boolean;
         let removeComments_1: boolean;
         export { removeComments_1 as removeComments };

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

@@ -1 +1 @@
-{"version":3,"file":"presets.d.ts","sourceRoot":"","sources":["../../src/presets.js"],"names":[],"mappings":"AA4CA;;;;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":"AA0CA;;;;GAIG;AACH,gCAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAMvB;AAED;;;GAGG;AACH,kCAFa,MAAM,EAAE,CAIpB"}

package/package.json

@@ -6,24 +6,24 @@
   "bugs": "https://github.com/j9t/html-minifier-next/issues",
   "dependencies": {
     "commander": "^14.0.2",
-    "entities": "^7.0.1",
+    "entities": "^8.0.0",
     "lightningcss": "^1.32.0",
     "svgo": "^4.0.1",
-    "terser": "^5.46.0"
+    "terser": "^5.46.1"
   },
   "description": "Super-configurable and well-tested web page minifier (enhanced successor of HTML Minifier)",
   "devDependencies": {
-    "@commitlint/cli": "^20.3.1",
+    "@commitlint/cli": "^20.5.0",
     "@eslint/js": "^10.0.1",
     "@rollup/plugin-commonjs": "^29.0.2",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
-    "@swc/core": "^1.15.11",
-    "eslint": "^10.0.0",
-    "rollup": "^4.59.0",
+    "@swc/core": "^1.15.21",
+    "eslint": "^10.1.0",
+    "rollup": "^4.60.0",
     "rollup-plugin-polyfill-node": "^0.13.0",
-    "typescript": "^5.9.3",
-    "vite": "^8.0.1"
+    "typescript": "^6.0.2",
+    "vite": "^8.0.5"
   },
   "exports": {
     ".": {
@@ -96,5 +96,5 @@
   },
   "type": "module",
   "types": "./dist/types/htmlminifier.d.ts",
-  "version": "5.2.2"
+  "version": "6.1.1"
 }

package/src/htmlminifier.js

@@ -32,7 +32,6 @@ import {
 } from './lib/whitespace.js';
 
 import {
-  isConditionalComment,
   isIgnoredComment,
   isExecutableScript,
   isStyleElement,
@@ -51,7 +50,6 @@ import {
 } from './lib/elements.js';
 
 import {
-  cleanConditionalComment,
   hasJsonScriptType,
   processScript
 } from './lib/content.js';
@@ -182,16 +180,16 @@ function mergeConsecutiveScripts(html) {
         return match;
       }
 
-      // Check `type` compatibility (both must be same, or both default JS)
-      const type1 = a1.type || '';
-      const type2 = a2.type || '';
+      // Check `type` compatibility (both must be default JS)
+      const type1 = (a1.type || '').toLowerCase();
+      const type2 = (a2.type || '').toLowerCase();
 
       if (DEFAULT_JS_TYPES.has(type1) && DEFAULT_JS_TYPES.has(type2)) {
         // Both are default JavaScript—compatible
-      } else if (type1 === type2) {
-        // Same explicit type—compatible
       } else {
-        // Incompatible types
+        // Non-JS types (modules, JSON, etc.) must not be merged:
+        // Module scripts have per-script lexical scope, and non-JS content (e.g., JSON)
+        // is not concatenable. Even identical non-JS types are incompatible.
         return match;
       }
 
@@ -518,13 +516,6 @@ function mergeConsecutiveScripts(html) {
  *
  *  Default: `false`
  *
- * @prop {boolean} [processConditionalComments]
- *  When true, conditional comments (for example `<!--[if IE]> … <![endif]-->`)
- *  will have their inner content processed by the minifier.
- *  Useful to minify HTML that appears inside conditional comments.
- *
- *  Default: `false`
- *
  * @prop {string[]} [processScripts]
  *  Array of `type` attribute values for `<script>` elements whose contents
  *  should be processed as HTML
@@ -1012,11 +1003,11 @@ async function minifyHTML(value, options, partialMarkup) {
 
         if (options.minifyJS) {
           options.minifyJS = (function (fn) {
-            return function (text, type) {
+            return function (text, inline, isModule) {
               return fn(text.replace(uidPattern, function (match, prefix, index) {
                 const chunks = ignoredCustomMarkupChunks[+index];
                 return chunks[1] + uidAttr + index + uidAttr + chunks[2];
-              }), type);
+              }), inline, isModule);
             };
           })(options.minifyJS);
         }
@@ -1339,6 +1330,9 @@ async function minifyHTML(value, options, partialMarkup) {
       const needsDecode = options.decodeEntities && text && !specialContentElements.has(currentTag) && text.indexOf('&') !== -1;
       const needsProcessScript = specialContentElements.has(currentTag) && (options.processScripts || hasJsonScriptType(currentAttrs));
       const needsMinifyJS = options.minifyJS !== identity && isExecutableScript(currentTag, currentAttrs);
+      const isModuleScript = needsMinifyJS && currentAttrs.some(
+        a => a.name.toLowerCase() === 'type' && (a.value ?? '').trim().toLowerCase() === 'module'
+      );
       const needsMinifyCSS = options.minifyCSS !== identity && isStyleElement(currentTag, currentAttrs);
 
       // Whitespace collapsing phase (sync); captures `prevTag`/`nextTag`/`prevAttrs`/`nextAttrs` from outer scope
@@ -1465,7 +1459,7 @@ async function minifyHTML(value, options, partialMarkup) {
           text = await processScript(text, options, currentAttrs, minifyHTML);
         }
         if (needsMinifyJS) {
-          text = await options.minifyJS(text);
+          text = await options.minifyJS(text, false, isModuleScript);
         }
         if (needsMinifyCSS) {
           text = await options.minifyCSS(text);
@@ -1560,16 +1554,9 @@ async function minifyHTML(value, options, partialMarkup) {
         buffer.push(comment);
       }
 
-      // Only conditional comments require async work (recursive minification)
-      if (isConditionalComment(text)) {
-        return cleanConditionalComment(text, options, minifyHTML).then(cleaned => {
-          commentFinalize(prefix + cleaned + suffix);
-        });
-      }
-
       if (options.removeComments) {
         if (isIgnoredComment(text, options)) {
-          text = '<!--' + text + '-->';
+          text = prefix + text + suffix;
         } else {
           text = '';
         }

package/src/lib/attributes.js

@@ -1,7 +1,6 @@
 // Imports
 
 import {
-  RE_CONDITIONAL_COMMENT,
   RE_EVENT_ATTR_DEFAULT,
   RE_CAN_REMOVE_ATTR_QUOTES,
   RE_AMP_ENTITY,
@@ -34,10 +33,6 @@ async function getDecodeHTMLStrict() {
 
 // Validators
 
-function isConditionalComment(text) {
-  return RE_CONDITIONAL_COMMENT.test(text);
-}
-
 function isIgnoredComment(text, options) {
   for (let i = 0, len = options.ignoreCustomComments.length; i < len; i++) {
     if (options.ignoreCustomComments[i].test(text)) {
@@ -674,7 +669,6 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
 
 export {
   // Validators
-  isConditionalComment,
   isIgnoredComment,
   isEventAttribute,
   canRemoveAttributeQuotes,

package/src/lib/constants.js

@@ -7,7 +7,6 @@ const RE_NBSP_LEADING_GROUP = /(^|\xA0+)[^\xA0]+/g;
 const RE_NBSP_LEAD_GROUP = /(\xA0+)[^\xA0]+/g;
 const RE_NBSP_TRAILING_GROUP = /[^\xA0]+(\xA0+)/g;
 const RE_NBSP_TRAILING_STRIP = /[^\xA0]+$/;
-const RE_CONDITIONAL_COMMENT = /^\[if\s[^\]]+]|\[endif]$/;
 const RE_EVENT_ATTR_DEFAULT = /^on[a-z]{3,}$/;
 const RE_CAN_REMOVE_ATTR_QUOTES = /^[^ \t\n\f\r"'`=<>]+$/;
 const RE_TRAILING_SEMICOLON = /;$/;
@@ -184,7 +183,6 @@ export {
   RE_NBSP_LEAD_GROUP,
   RE_NBSP_TRAILING_GROUP,
   RE_NBSP_TRAILING_STRIP,
-  RE_CONDITIONAL_COMMENT,
   RE_EVENT_ATTR_DEFAULT,
   RE_CAN_REMOVE_ATTR_QUOTES,
   RE_TRAILING_SEMICOLON,

package/src/lib/content.js

@@ -3,7 +3,6 @@
 import {
   jsonScriptTypes
 } from './constants.js';
-import { replaceAsync } from './utils.js';
 import { trimWhitespace } from './whitespace.js';
 
 // CSS processing
@@ -34,14 +33,6 @@ function unwrapCSS(text, type) {
   return matches ? matches[1] : text;
 }
 
-async function cleanConditionalComment(comment, options, minifyHTML) {
-  return options.processConditionalComments
-    ? await replaceAsync(comment, /^(\[if\s[^\]]+]>)([\s\S]*?)(<!\[endif])$/, async function (match, prefix, text, suffix) {
-      return prefix + await minifyHTML(text, options, true) + suffix;
-    })
-    : comment;
-}
-
 // Script processing
 
 function minifyJson(text, options) {
@@ -95,7 +86,6 @@ export {
   // CSS
   wrapCSS,
   unwrapCSS,
-  cleanConditionalComment,
 
   // Scripts
   minifyJson,

package/src/lib/option-definitions.js

@@ -121,10 +121,6 @@ const optionDefinitions = {
     description: 'Prevents the escaping of the values of attributes',
     type: 'boolean'
   },
-  processConditionalComments: {
-    description: 'Process contents of conditional comments through minifier',
-    type: 'boolean'
-  },
   processScripts: {
     description: 'Array of strings corresponding to types of `script` elements to process through minifier (e.g., `text/ng-template`, `text/x-handlebars-template`, etc.)',
     type: 'jsonArray'

package/src/lib/options.js

@@ -228,7 +228,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
         cont: !!options.continueOnMinifyError
       });
 
-      options.minifyJS = async function (text, inline) {
+      options.minifyJS = async function (text, inline, isModule) {
         const start = text.match(/^\s*<!--.*/);
         const code = start ? text.slice(start[0].length).replace(/\n\s*-->\s*$/, '') : text;
 
@@ -248,7 +248,7 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
 
           // 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;
+            + (inline ? '1' : '0') + '|' + (isModule ? 'm' : '') + '|' + useEngine + '|' + optsSig;
 
           const cached = jsMinifyCache.get(jsKey);
           if (cached) {
@@ -264,7 +264,8 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
                 parse: {
                   ...terserOptions.parse,
                   bare_returns: inline
-                }
+                },
+                ...(isModule ? { module: true } : {}) // Overrides user options: module detection takes precedence for `<script type=module>`
               };
               const terser = await getTerser();
               const result = await terser(code, terserCallOptions);
@@ -275,7 +276,8 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getS
               const result = await swc.minify(code, {
                 compress: true,
                 mangle: true,
-                ...swcOptions, // User options override defaults
+                ...swcOptions,
+                ...(isModule ? { module: true } : {}) // Overrides user options: module detection takes precedence for `<script type=module>`
               });
               return result.code.replace(RE_TRAILING_SEMICOLON, '');
             }

package/src/presets.js

@@ -13,7 +13,6 @@ export const presets = {
     collapseWhitespace: true,
     conservativeCollapse: true,
     preserveLineBreaks: true,
-    processConditionalComments: true,
     removeComments: true,
     removeScriptTypeAttributes: true,
     removeStyleLinkTypeAttributes: true,
@@ -30,7 +29,6 @@ export const presets = {
     minifyJS: true,
     minifySVG: true,
     minifyURLs: true,
-    processConditionalComments: true,
     removeAttributeQuotes: true,
     removeComments: true,
     removeEmptyAttributes: true,