html-minifier-next 6.1.5 → 6.2.1

package/README.md

@@ -129,7 +129,7 @@ html-minifier-next --preset conservative --remove-empty-attributes input.html
 
 Most of the options are disabled by default. Experiment and find what works best for you and your project.
 
-Options can be used in config files (camelCase) or via CLI flags (kebab-case with `--` prefix). Options that default to `true` use `--no-` prefix in CLI to disable them.
+Options can be used in config files (camelCase) or via CLI flags (kebab-case with `--` prefix). Boolean options generally support both `--option-name` to enable and `--no-option-name` to disable, so you can override a preset or config file from the command line. (Exception: Options whose name already starts with `no-`, such as `noNewlinesBeforeTagClose`, only expose the `--no-…` CLI flag.)
 
 | Option (config/CLI) | Description | Default |
 | --- | --- | --- |
@@ -142,7 +142,7 @@ Options can be used in config files (camelCase) or via CLI flags (kebab-case wit
 | `collapseInlineTagWhitespace`<br>`--collapse-inline-tag-whitespace` | Collapse whitespace more aggressively between inline elements—use with `collapseWhitespace: true` | `false` |
 | `collapseWhitespace`<br>`--collapse-whitespace` | [Collapse whitespace that contributes to text nodes in a document tree](https://perfectionkills.com/experimenting-with-html-minifier/#collapse_whitespace) | `false` |
 | `conservativeCollapse`<br>`--conservative-collapse` | Always collapse to one space (never remove it entirely)—use with `collapseWhitespace: true` | `false` |
-| `continueOnMinifyError`<br>`--no-continue-on-minify-error` | Continue on minification errors; when `false`, minification errors throw and abort processing | `true` |
+| `continueOnMinifyError`<br>`--continue-on-minify-error`<br>`--no-continue-on-minify-error` | Continue on minification errors; when `false`, minification errors throw and abort processing | `true` |
 | `continueOnParseError`<br>`--continue-on-parse-error` | [Handle parse errors](https://html.spec.whatwg.org/multipage/parsing.html#parse-errors) instead of aborting | `false` |
 | `customAttrAssign`<br>`--custom-attr-assign` | Array of regexes that allow to support custom attribute assign expressions (e.g., `<div flex?="{{mode != cover}}"></div>`) | `[]` |
 | `customAttrCollapse`<br>`--custom-attr-collapse` | Regex that specifies custom attribute to strip newlines from (e.g., `/ng-class/`) | `undefined` |
@@ -603,7 +603,7 @@ Parameters:
 
 ## Acknowledgements
 
-With many thanks to all the previous authors of HTML Minifier, especially [Juriy “kangax” Zaytsev](https://github.com/kangax), and to everyone who helped make this new edition better, particularly [Daniel Ruf](https://github.com/DanielRuf) and [Jonas Geiler](https://github.com/jonasgeiler).
+With many thanks to the previous authors of and contributors to HTML Minifier, especially [Juriy “kangax” Zaytsev](https://github.com/kangax), and to everyone who helped make this new edition better, particularly [Daniel Ruf](https://github.com/DanielRuf), [Jonas Geiler](https://github.com/jonasgeiler), and [Chris Morgan](https://github.com/chris-morgan)!
 
 ***
 

package/cli.js

@@ -34,12 +34,22 @@ import { pathToFileURL } from 'url';
 import os from 'os';
 import readline from 'readline';
 import { createRequire } from 'module';
-import { Command } from 'commander';
+import { Command, Option } from 'commander';
 
 // Simple case conversion for CLI option names (ASCII-only, no Unicode needed)
 const paramCase = (str) => str.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
 const camelCase = (str) => paramCase(str).replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 
+// Commander derives its internal option key by applying paramCase then camelCase to the flag name,
+// stripping a leading `no-` first for negated flags (e.g., `--no-foo-bar` → `fooBar`);
+// because option definition keys may differ from the result of that round-trip (e.g.,
+// `minifyURLs` → Commander key `minifyUrls`, `noNewlinesBeforeTagClose` → `newlinesBeforeTagClose`),
+// `commanderOptionKey` uses the same paramCase + camelCase path to compute the key Commander will use
+const commanderOptionKey = (key) => {
+  const pc = paramCase(key);
+  return pc.startsWith('no-') ? camelCase(pc.slice(3)) : camelCase(pc);
+};
+
 // Lazy-load HMN to reduce CLI cold-start overhead
 import { getPreset, getPresetNames } from './src/presets.js';
 import { parseRegExp } from './src/lib/utils.js';
@@ -140,20 +150,31 @@ const typeParsers = {
 // Configure command-line flags from shared option definitions
 const mainOptionKeys = Object.keys(optionDefinitions);
 mainOptionKeys.forEach(function (key) {
-  const { description, type } = optionDefinitions[key];
+  const { description, descriptionAffirmative, type } = optionDefinitions[key];
+  const flag = paramCase(key);
   if (type === 'invertedBoolean') {
-    program.option('--no-' + paramCase(key), description);
+    // The positive form (to re-enable after a preset/config disables it) is hidden from
+    // help—the footer note covers the convention; the negative form is the primary use case
+    program.addOption(new Option('--' + flag, descriptionAffirmative ?? 'Enable --' + flag).hideHelp());
+    program.option('--no-' + flag, description);
   } else if (type === 'boolean') {
-    program.option('--' + paramCase(key), description);
+    program.option('--' + flag, description);
+    // The negation form is hidden from help—the footer note covers the convention;
+    // skip options whose flag already starts with `no-` (currently only
+    // `noNewlinesBeforeTagClose`), as `--no-no-X` is not usable
+    if (!flag.startsWith('no-')) {
+      program.addOption(new Option('--no-' + flag, 'Disable --' + flag).hideHelp());
+    }
   } else {
-    const flag = '--' + paramCase(key) + (type === 'json' ? ' [value]' : ' <value>');
+    const cliFlag = '--' + flag + (type === 'json' ? ' [value]' : ' <value>');
     const parser = type === 'int' ? typeParsers.int(key) : typeParsers[type];
-    program.option(flag, description, parser);
+    program.option(cliFlag, description, parser);
   }
 });
 program.option('-o --output <file>', 'Specify output file (reads from file arguments or STDIN; outputs to STDOUT if not specified)');
 program.option('-v --verbose', 'Show detailed processing information');
 program.option('-d --dry', 'Dry run: Process and report statistics without writing output');
+program.addHelpText('after', '\nBoolean options support a `--no-<flag>` form to disable them, overriding a preset or config file (e.g., `--preset=comprehensive --no-collapse-whitespace`).');
 
 // Lazy import wrapper for HMN
 let minifyFnPromise;
@@ -398,9 +419,14 @@ program.helpOption('-h, --help', 'Display help for command');
 
     // 3. Apply CLI options (overrides config and preset)
     mainOptionKeys.forEach(function (key) {
-      const param = programOptions[camelCase(key)];
-      if (typeof param !== 'undefined') {
-        options[key] = param;
+      const { type } = optionDefinitions[key];
+      const ck = commanderOptionKey(key);
+      if (program.getOptionValueSource(ck) === 'cli') {
+        const val = programOptions[ck];
+        // For boolean options whose param-case name starts with `no-`, Commander treats
+        // the flag as a negation and stores the inverted value under the stripped key;
+        // invert back so the option definition key gets the intended value
+        options[key] = (type === 'boolean' && paramCase(key).startsWith('no-')) ? !val : val;
       }
     });
 
@@ -413,7 +439,7 @@ program.helpOption('-h, --help', 'Display help for command');
       console.error(`Using preset: ${presetName}`);
     }
     const activeOptions = Object.entries(minifierOptions)
-      .filter(([k]) => program.getOptionValueSource(camelCase(k)) === 'cli')
+      .filter(([k]) => program.getOptionValueSource(commanderOptionKey(k)) === 'cli')
       .map(([k, v]) => (typeof v === 'boolean' ? (v ? k : `no-${k}`) : k));
     if (activeOptions.length > 0) {
       console.error('CLI options: ' + activeOptions.join(', '));

package/dist/htmlminifier.cjs

@@ -1429,15 +1429,15 @@ function collapseWhitespaceSmart(str, prevTag, nextTag, prevAttrs, nextAttrs, op
 
 // Collapse/trim whitespace for given tag
 
-const noCollapseWsTags = new Set(['script', 'style', 'pre', 'textarea']);
-const noTrimWsTags = new Set(['pre', 'textarea']);
+const noCollapseWhitespaceTags = new Set(['script', 'style', 'pre', 'textarea']);
+const noTrimWhitespaceTags = new Set(['pre', 'textarea']);
 
 function canCollapseWhitespace(tag) {
-  return !noCollapseWsTags.has(tag);
+  return !noCollapseWhitespaceTags.has(tag);
 }
 
 function canTrimWhitespace(tag) {
-  return !noTrimWsTags.has(tag);
+  return !noTrimWhitespaceTags.has(tag);
 }
 
 /**
@@ -2366,12 +2366,18 @@ function hasAttrName(name, attrs) {
 
 // Cleaners
 
+const collapseAttributeWhitespaceExempt = new Set(['pattern', 'placeholder', 'title']);
+// `value` whitespace matters only on form-submission and machine-readable elements
+const valueWhitespaceExemptElements = new Set(['button', 'data', 'input', 'option', 'param']);
+
 // Returns the cleaned attribute value directly (sync) or as a Promise (async);
 // callers must handle both cases—use `isThenable()` to distinguish
 function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTMLSelf) {
+  const isEventAttr = isEventAttribute(attrName, options);
+
   // Apply early whitespace normalization if enabled
   // Preserves special spaces (no-break space, hair space, etc.) for consistency with `collapseWhitespace`
-  if (options.collapseAttributeWhitespace) {
+  if (options.collapseAttributeWhitespace && !collapseAttributeWhitespaceExempt.has(attrName) && !(attrName === 'value' && valueWhitespaceExemptElements.has(tag)) && !isEventAttr) {
     // Fast path: Only process if whitespace exists (avoids regex overhead on clean values)
     if (RE_ATTR_WS_CHECK.test(attrValue)) {
       // Two-pass approach (faster than single-pass with callback)
@@ -2381,7 +2387,7 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTM
     }
   }
 
-  if (isEventAttribute(attrName, options)) {
+  if (isEventAttr) {
     attrValue = trimWhitespace(attrValue).replace(/^javascript:\s*/i, '');
     const result = options.minifyJS(attrValue, true);
     if (isThenable(result)) {

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

@@ -1 +1 @@
-{"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"}
+{"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;AAUD,iIA4KC;AAwBD,mGAYC;AA0CD,6GAuHC;AAxlBD;;;;;;;GAOG;AACH,mEAHW,OAAO,SAuBjB"}

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

@@ -36,6 +36,7 @@ export namespace optionDefinitions {
     namespace continueOnMinifyError {
         let description_6: string;
         export { description_6 as description };
+        export let descriptionAffirmative: string;
         let type_6: string;
         export { type_6 as type };
     }

package/package.json

@@ -18,11 +18,11 @@
     "@rollup/plugin-commonjs": "^29.0.2",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
-    "@swc/core": "^1.15.21",
+    "@swc/core": "^1.15.30",
     "eslint": "^10.2.0",
-    "rollup": "^4.60.0",
+    "rollup": "^4.60.2",
     "rollup-plugin-polyfill-node": "^0.13.0",
-    "typescript": "^6.0.2",
+    "typescript": "^6.0.3",
     "vite": "^8.0.8"
   },
   "exports": {
@@ -96,5 +96,5 @@
   },
   "type": "module",
   "types": "./dist/types/htmlminifier.d.ts",
-  "version": "6.1.5"
+  "version": "6.2.1"
 }

package/src/lib/attributes.js

@@ -294,12 +294,18 @@ function hasAttrName(name, attrs) {
 
 // Cleaners
 
+const collapseAttributeWhitespaceExempt = new Set(['pattern', 'placeholder', 'title']);
+// `value` whitespace matters only on form-submission and machine-readable elements
+const valueWhitespaceExemptElements = new Set(['button', 'data', 'input', 'option', 'param']);
+
 // Returns the cleaned attribute value directly (sync) or as a Promise (async);
 // callers must handle both cases—use `isThenable()` to distinguish
 function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTMLSelf) {
+  const isEventAttr = isEventAttribute(attrName, options);
+
   // Apply early whitespace normalization if enabled
   // Preserves special spaces (no-break space, hair space, etc.) for consistency with `collapseWhitespace`
-  if (options.collapseAttributeWhitespace) {
+  if (options.collapseAttributeWhitespace && !collapseAttributeWhitespaceExempt.has(attrName) && !(attrName === 'value' && valueWhitespaceExemptElements.has(tag)) && !isEventAttr) {
     // Fast path: Only process if whitespace exists (avoids regex overhead on clean values)
     if (RE_ATTR_WS_CHECK.test(attrValue)) {
       // Two-pass approach (faster than single-pass with callback)
@@ -309,7 +315,7 @@ function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTM
     }
   }
 
-  if (isEventAttribute(attrName, options)) {
+  if (isEventAttr) {
     attrValue = trimWhitespace(attrValue).replace(/^javascript:\s*/i, '');
     const result = options.minifyJS(attrValue, true);
     if (isThenable(result)) {

package/src/lib/option-definitions.js

@@ -27,6 +27,7 @@ const optionDefinitions = {
   },
   continueOnMinifyError: {
     description: 'Abort on minification errors',
+    descriptionAffirmative: 'Continue on minification errors',
     type: 'invertedBoolean'
   },
   continueOnParseError: {

package/src/lib/whitespace.js

@@ -211,15 +211,15 @@ function collapseWhitespaceSmart(str, prevTag, nextTag, prevAttrs, nextAttrs, op
 
 // Collapse/trim whitespace for given tag
 
-const noCollapseWsTags = new Set(['script', 'style', 'pre', 'textarea']);
-const noTrimWsTags = new Set(['pre', 'textarea']);
+const noCollapseWhitespaceTags = new Set(['script', 'style', 'pre', 'textarea']);
+const noTrimWhitespaceTags = new Set(['pre', 'textarea']);
 
 function canCollapseWhitespace(tag) {
-  return !noCollapseWsTags.has(tag);
+  return !noCollapseWhitespaceTags.has(tag);
 }
 
 function canTrimWhitespace(tag) {
-  return !noTrimWsTags.has(tag);
+  return !noTrimWhitespaceTags.has(tag);
 }
 
 // Exports