html-minifier-next 6.1.4 → 6.2.0

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` |

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

@@ -611,10 +611,23 @@ class HTMLParser {
                       continue;
                     }
                   }
-                  // Note: Unquoted attribute values are intentionally not handled here.
+                  // Note: Unquoted attribute values are intentionally not handled here
                   // Per HTML spec, unquoted values cannot contain spaces or special chars,
-                  // making a 20 KB+ unquoted value practically impossible. If encountered,
-                  // it’s malformed HTML and using the truncated regex match is acceptable.
+                  // making a 20 KB+ unquoted value practically impossible; if encountered,
+                  // it’s malformed HTML and using the truncated regex match is acceptable
+                }
+              } else {
+                // If attr has no value assign but `=` follows in `fullHtml`,
+                // the value would be cut off—reset to trigger manual extraction below
+                const numCustomParts = handler.customAttrSurround
+                  ? handler.customAttrSurround.length * NCP
+                  : 0;
+                const baseIndex = 1 + numCustomParts;
+                if (attr[baseIndex + 1] === undefined) {
+                  const posAfterName = currentPos + attrEnd;
+                  if (/^\s*=/.test(fullHtml.slice(posAfterName, posAfterName + 50))) {
+                    attr = null;
+                  }
                 }
               }
             }

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

@@ -1 +1 @@
-{"version":3,"file":"htmlparser.d.ts","sourceRoot":"","sources":["../../src/htmlparser.js"],"names":[],"mappings":"AAqDA,4BAAkE;AA0GlE;IACE,qCAGC;IAFC,UAAgB;IAChB,aAAsB;IAGxB,uBAmmBC;CACF"}
+{"version":3,"file":"htmlparser.d.ts","sourceRoot":"","sources":["../../src/htmlparser.js"],"names":[],"mappings":"AAqDA,4BAAkE;AA0GlE;IACE,qCAGC;IAFC,UAAgB;IAChB,aAAsB;IAGxB,uBAgnBC;CACF"}

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

@@ -96,5 +96,5 @@
   },
   "type": "module",
   "types": "./dist/types/htmlminifier.d.ts",
-  "version": "6.1.4"
+  "version": "6.2.0"
 }

package/src/htmlparser.js

@@ -510,10 +510,23 @@ export class HTMLParser {
                       continue;
                     }
                   }
-                  // Note: Unquoted attribute values are intentionally not handled here.
+                  // Note: Unquoted attribute values are intentionally not handled here
                   // Per HTML spec, unquoted values cannot contain spaces or special chars,
-                  // making a 20 KB+ unquoted value practically impossible. If encountered,
-                  // it’s malformed HTML and using the truncated regex match is acceptable.
+                  // making a 20 KB+ unquoted value practically impossible; if encountered,
+                  // it’s malformed HTML and using the truncated regex match is acceptable
+                }
+              } else {
+                // If attr has no value assign but `=` follows in `fullHtml`,
+                // the value would be cut off—reset to trigger manual extraction below
+                const numCustomParts = handler.customAttrSurround
+                  ? handler.customAttrSurround.length * NCP
+                  : 0;
+                const baseIndex = 1 + numCustomParts;
+                if (attr[baseIndex + 1] === undefined) {
+                  const posAfterName = currentPos + attrEnd;
+                  if (/^\s*=/.test(fullHtml.slice(posAfterName, posAfterName + 50))) {
+                    attr = null;
+                  }
                 }
               }
             }

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: {