html-minifier-next 4.3.1 → 4.5.0

package/README.md

@@ -33,6 +33,7 @@ Use `html-minifier-next --help` to check all available options:
 | `--file-ext <extensions>` | Specify file extension(s) to process (overrides config file setting) | `--file-ext=html`, `--file-ext=html,htm,php`, `--file-ext="html, htm, php"` |
 | `-o <file>`, `--output <file>` | Specify output file (reads from file arguments or STDIN) | File to file: `html-minifier-next input.html -o output.html`<br>Pipe to file: `cat input.html \| html-minifier-next -o output.html`<br>File to STDOUT: `html-minifier-next input.html` |
 | `-c <file>`, `--config-file <file>` | Use a configuration file | `--config-file=html-minifier.json` |
+| `--preset <name>` | Use a preset configuration (conservative, comprehensive) | `--preset=conservative` |
 | `-v`, `--verbose` | Show detailed processing information (active options, file statistics) | `html-minifier-next --input-dir=src --output-dir=dist --verbose --collapse-whitespace` |
 | `-d`, `--dry` | Dry run: Process and report statistics without writing output | `html-minifier-next input.html --dry --collapse-whitespace` |
 | `-V`, `--version` | Output the version number | `html-minifier-next --version` |
@@ -71,6 +72,29 @@ html-minifier-next --config-file=html-minifier.json --input-dir=src --output-dir
 html-minifier-next --config-file=html-minifier.json --file-ext=xml --input-dir=src --output-dir=dist
 ```
 
+### Presets
+
+HTML Minifier Next provides presets for common use cases. Presets are pre-configured option sets that can be used as a starting point:
+
+* `conservative`: Safe minification suitable for most projects. Includes whitespace collapsing, comment removal, and doctype normalization.
+* `comprehensive`: Aggressive minification for maximum file size reduction. Includes all conservative options plus attribute quote removal, optional tag removal, and more.
+
+**Using presets:**
+
+```bash
+# Via CLI flag
+html-minifier-next --preset conservative input.html
+
+# Via config file
+html-minifier-next --config-file=config.json input.html
+# where config.json contains: { "preset": "conservative" }
+
+# Override preset options
+html-minifier-next --preset conservative --remove-empty-attributes input.html
+```
+
+**Priority order:** Presets are applied first, then config file options, then CLI flags. This allows you to start with a preset and customize as needed.
+
 ### Node.js
 
 ESM with Node.js ≥16.14:
@@ -134,11 +158,12 @@ Options can be used in config files (camelCase) or via CLI flags (kebab-case wit
 | `minifyJS`<br>`--minify-js` | Minify JavaScript in `script` elements and event attributes (uses [Terser](https://github.com/terser/terser)) | `false` (could be `true`, `Object`, `Function(text, inline)`) |
 | `minifyURLs`<br>`--minify-urls` | Minify URLs in various attributes (uses [relateurl](https://github.com/stevenvachon/relateurl)) | `false` (could be `String`, `Object`, `Function(text)`, `async Function(text)`) |
 | `noNewlinesBeforeTagClose`<br>`--no-newlines-before-tag-close` | Never add a newline before a tag that closes an element | `false` |
+| `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 1 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 `"`) | |
+| `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` |
 | `removeComments`<br>`--remove-comments` | [Strip HTML comments](https://perfectionkills.com/experimenting-with-html-minifier#remove_comments) | `false` |
 | `removeEmptyAttributes`<br>`--remove-empty-attributes` | [Remove all attributes with whitespace-only values](https://perfectionkills.com/experimenting-with-html-minifier#remove_empty_or_blank_attributes) | `false` (could be `true`, `Function(attrName, tag)`) |
@@ -155,7 +180,7 @@ Options can be used in config files (camelCase) or via CLI flags (kebab-case wit
 
 ### Sorting attributes and style classes
 
-Minifier options like `sortAttributes` and `sortClassName` won't impact the plain‑text size of the output. However, using these options for more consistent ordering improves the compression ratio for gzip and Brotli used over HTTP.
+Minifier options like `sortAttributes` and `sortClassName` won’t impact the plain‑text size of the output. However, using these options for more consistent ordering improves the compression ratio for gzip and Brotli used over HTTP.
 
 ### CSS minification with Lightning CSS
 
@@ -288,21 +313,21 @@ If you have chunks of markup you would like preserved, you can wrap them with `<
 
 ### Minifying JSON-LD
 
-You can minify `script` elements with JSON-LD by setting `{ processScripts: ['application/ld+json'] }`. Note that this minification is rudimentary; it’s mainly useful for removing newlines and excessive whitespace. 
+You can minify `script` elements with JSON-LD by setting `{ processScripts: ['application/ld+json'] }`. Note that this minification is rudimentary; it’s mainly useful for removing newlines and excessive whitespace.
 
 ### Preserving SVG elements
 
 SVG elements are automatically recognized, and when they are minified, both case-sensitivity and closing-slashes are preserved, regardless of the minification settings used for the rest of the file.
 
-### Working with invalid markup
+### Working with invalid or partial markup
 
-HTML Minifier Next **can’t work with invalid or partial chunks of markup**. This is because it parses markup into a tree structure, then modifies it (removing anything that was specified for removal, ignoring anything that was specified to be ignored, etc.), then it creates a markup out of that tree and returns it.
+By default, HTML Minifier Next parses markup into a complete tree structure, then modifies it (removing anything that was specified for removal, ignoring anything that was specified to be ignored, etc.), then creates markup from that tree and returns it.
 
 _Input markup (e.g., `<p id="">foo`) → Internal representation of markup in a form of tree (e.g., `{ tag: "p", attr: "id", children: ["foo"] }`) → Transformation of internal representation (e.g., removal of `id` attribute) → Output of resulting markup (e.g., `<p>foo</p>`)_
 
-HMN can’t know that the original markup represented only part of the tree. It parses a complete tree and, in doing so, loses information about the input being malformed or partial. As a result, it can’t emit a partial or malformed tree.
+For partial HTML fragments (such as template includes, SSI fragments, or closing tags without opening tags), use the `partialMarkup: true` option. This preserves stray end tags (closing tags without corresponding opening tags) and prevents auto-closing of unclosed tags at the end of input. Note that normal HTML auto-closing rules still apply during parsing—for example, a closing parent tag will still auto-close its unclosed child elements.
 
-To validate HTML markup, use [the W3C validator](https://validator.w3.org/) or one of [several validator packages](https://meiert.com/blog/html-validator-packages/).
+To validate complete HTML markup, use [the W3C validator](https://validator.w3.org/) or one of [several validator packages](https://meiert.com/blog/html-validator-packages/).
 
 ## Security
 

package/cli.js

@@ -32,6 +32,7 @@ import { createRequire } from 'module';
 import { camelCase, paramCase } from 'change-case';
 import { Command } from 'commander';
 import { minify } from './src/htmlminifier.js';
+import { getPreset, getPresetNames } from './src/presets.js';
 
 const require = createRequire(import.meta.url);
 const pkg = require('./package.json');
@@ -140,7 +141,8 @@ const mainOptions = {
   minifyJS: ['Minify JavaScript in “script” elements and event attributes (uses Terser)', parseJSON],
   minifyURLs: ['Minify URLs in various attributes (uses relateurl)', parseJSON],
   noNewlinesBeforeTagClose: 'Never add a newline before a tag that closes an element',
-  preserveLineBreaks: 'Always collapse to 1 line break (never remove it entirely) when whitespace between tags includes a line break—use with “collapseWhitespace=true”',
+  partialMarkup: 'Treat input as a partial HTML fragment, preserving stray end tags and unclosed tags',
+  preserveLineBreaks: 'Always collapse to 1 line break (never remove it entirely) when whitespace between tags includes a line break—use with "collapseWhitespace=true"',
   preventAttributesEscaping: 'Prevents the escaping of the values of attributes',
   processConditionalComments: 'Process contents of conditional comments through minifier',
   processScripts: ['Array of strings corresponding to types of “script” elements to process through minifier (e.g., “text/ng-template”, “text/x-handlebars-template”, etc.)', parseJSONArray],
@@ -249,9 +251,10 @@ function normalizeConfig(config) {
 
 let config = {};
 program.option('-c --config-file <file>', 'Use config file');
+program.option('--preset <name>', `Use a preset configuration (${getPresetNames().join(', ')})`);
 program.option('--input-dir <dir>', 'Specify an input directory');
 program.option('--output-dir <dir>', 'Specify an output directory');
-program.option('--file-ext <extensions>', 'Specify file extension(s) to process (comma-separated), e.g., “html” or “html,htm,php”');
+program.option('--file-ext <extensions>', 'Specify file extension(s) to process (comma-separated), e.g., "html" or "html,htm,php"');
 
 (async () => {
   let content;
@@ -270,19 +273,40 @@ program.option('--file-ext <extensions>', 'Specify file extension(s) to process
   function createOptions() {
     const options = {};
 
+    // Priority order: preset < config < CLI
+    // 1. Apply preset if specified (CLI `--preset` takes priority over config.preset)
+    const presetName = programOptions.preset || config.preset;
+    if (presetName) {
+      const preset = getPreset(presetName);
+      if (!preset) {
+        fatal(`Unknown preset "${presetName}". Available presets: ${getPresetNames().join(', ')}`);
+      }
+      Object.assign(options, preset);
+    }
+
+    // 2. Apply config file options (overrides preset)
     mainOptionKeys.forEach(function (key) {
-      const param = programOptions[key === 'minifyURLs' ? 'minifyUrls' : camelCase(key)];
+      if (key in config) {
+        options[key] = config[key];
+      }
+    });
 
+    // 3. Apply CLI options (overrides config and preset)
+    mainOptionKeys.forEach(function (key) {
+      const param = programOptions[key === 'minifyURLs' ? 'minifyUrls' : camelCase(key)];
       if (typeof param !== 'undefined') {
         options[key] = param;
-      } else if (key in config) {
-        options[key] = config[key];
       }
     });
+
     return options;
   }
 
   function getActiveOptionsDisplay(minifierOptions) {
+    const presetName = programOptions.preset || config.preset;
+    if (presetName) {
+      console.error(`Using preset: ${presetName}`);
+    }
     const activeOptions = Object.entries(minifierOptions)
       .filter(([k]) => program.getOptionValueSource(k === 'minifyURLs' ? 'minifyUrls' : camelCase(k)) === 'cli')
       .map(([k, v]) => (typeof v === 'boolean' ? (v ? k : `no-${k}`) : k));

package/dist/htmlminifier.cjs

@@ -453,6 +453,11 @@ class HTMLParser {
         // Remove the open elements from the stack
         stack.length = pos;
         lastTag = pos && stack[pos - 1].tag;
+      } else if (handler.partialMarkup && tagName) {
+        // In partial markup mode, preserve stray end tags
+        if (handler.end) {
+          handler.end(tagName, [], false);
+        }
       } else if (tagName.toLowerCase() === 'br') {
         if (handler.start) {
           await handler.start(tagName, [], true, '');
@@ -536,6 +541,74 @@ class TokenChain {
   }
 }
 
+/**
+ * Preset configurations for HTML Minifier Next
+ *
+ * Presets provide curated option sets for common use cases:
+ * - conservative: Safe minification suitable for most projects
+ * - comprehensive: Aggressive minification for maximum file size reduction
+ */
+
+const presets = {
+  conservative: {
+    collapseBooleanAttributes: true,
+    collapseWhitespace: true,
+    conservativeCollapse: true,
+    continueOnParseError: true,
+    decodeEntities: true,
+    minifyURLs: true,
+    noNewlinesBeforeTagClose: true,
+    preserveLineBreaks: true,
+    removeComments: true,
+    removeScriptTypeAttributes: true,
+    removeStyleLinkTypeAttributes: true,
+    useShortDoctype: true
+  },
+  comprehensive: {
+    caseSensitive: true,
+    collapseBooleanAttributes: true,
+    collapseInlineTagWhitespace: true,
+    collapseWhitespace: true,
+    conservativeCollapse: true,
+    continueOnParseError: true,
+    decodeEntities: true,
+    minifyCSS: true,
+    minifyJS: true,
+    minifyURLs: true,
+    noNewlinesBeforeTagClose: true,
+    processConditionalComments: true,
+    removeAttributeQuotes: true,
+    removeComments: true,
+    removeEmptyAttributes: true,
+    removeOptionalTags: true,
+    removeRedundantAttributes: true,
+    removeScriptTypeAttributes: true,
+    removeStyleLinkTypeAttributes: true,
+    sortAttributes: true,
+    sortClassName: true,
+    useShortDoctype: true
+  }
+};
+
+/**
+ * Get preset configuration by name
+ * @param {string} name - Preset name ('conservative' or 'comprehensive')
+ * @returns {object|null} Preset options object or null if not found
+ */
+function getPreset(name) {
+  if (!name) return null;
+  const normalizedName = name.toLowerCase();
+  return presets[normalizedName] || null;
+}
+
+/**
+ * Get list of available preset names
+ * @returns {string[]} Array of preset names
+ */
+function getPresetNames() {
+  return Object.keys(presets);
+}
+
 const trimWhitespace = str => str && str.replace(/^[ \n\r\t\f]+/, '').replace(/[ \n\r\t\f]+$/, '');
 
 function collapseWhitespaceAll(str) {
@@ -1642,7 +1715,7 @@ async function minifyHTML(value, options, partialMarkup) {
   }
 
   const parser = new HTMLParser(value, {
-    partialMarkup,
+    partialMarkup: partialMarkup ?? options.partialMarkup,
     continueOnParseError: options.continueOnParseError,
     customAttrAssign: options.customAttrAssign,
     customAttrSurround: options.customAttrSurround,
@@ -2014,7 +2087,7 @@ const minify = async function (value, options) {
   return result;
 };
 
-var htmlminifier = { minify };
+var htmlminifier = { minify, presets, getPreset, getPresetNames };
 
 /**
  * @typedef {Object} HTMLAttribute
@@ -2226,6 +2299,15 @@ var htmlminifier = { minify };
  *
  *  Default: `false`
  *
+ * @prop {boolean} [partialMarkup]
+ *  When true, treat input as a partial HTML fragment rather than a complete
+ *  document. This preserves stray end tags (closing tags without corresponding
+ *  opening tags) and prevents auto-closing of unclosed tags at the end of input.
+ *  Useful for minifying template fragments, SSI includes, or other partial HTML
+ *  that will be combined with other fragments.
+ *
+ *  Default: `false`
+ *
  * @prop {boolean} [preserveLineBreaks]
  *  Preserve a single line break at the start/end of text nodes when
  *  collapsing/trimming whitespace.
@@ -2355,4 +2437,7 @@ var htmlminifier = { minify };
  */
 
 exports.default = htmlminifier;
+exports.getPreset = getPreset;
+exports.getPresetNames = getPresetNames;
 exports.minify = minify;
+exports.presets = presets;

package/dist/htmlminifier.esm.bundle.js

@@ -39506,6 +39506,11 @@ class HTMLParser {
         // Remove the open elements from the stack
         stack.length = pos;
         lastTag = pos && stack[pos - 1].tag;
+      } else if (handler.partialMarkup && tagName) {
+        // In partial markup mode, preserve stray end tags
+        if (handler.end) {
+          handler.end(tagName, [], false);
+        }
       } else if (tagName.toLowerCase() === 'br') {
         if (handler.start) {
           await handler.start(tagName, [], true, '');
@@ -39589,6 +39594,74 @@ class TokenChain {
   }
 }
 
+/**
+ * Preset configurations for HTML Minifier Next
+ *
+ * Presets provide curated option sets for common use cases:
+ * - conservative: Safe minification suitable for most projects
+ * - comprehensive: Aggressive minification for maximum file size reduction
+ */
+
+const presets = {
+  conservative: {
+    collapseBooleanAttributes: true,
+    collapseWhitespace: true,
+    conservativeCollapse: true,
+    continueOnParseError: true,
+    decodeEntities: true,
+    minifyURLs: true,
+    noNewlinesBeforeTagClose: true,
+    preserveLineBreaks: true,
+    removeComments: true,
+    removeScriptTypeAttributes: true,
+    removeStyleLinkTypeAttributes: true,
+    useShortDoctype: true
+  },
+  comprehensive: {
+    caseSensitive: true,
+    collapseBooleanAttributes: true,
+    collapseInlineTagWhitespace: true,
+    collapseWhitespace: true,
+    conservativeCollapse: true,
+    continueOnParseError: true,
+    decodeEntities: true,
+    minifyCSS: true,
+    minifyJS: true,
+    minifyURLs: true,
+    noNewlinesBeforeTagClose: true,
+    processConditionalComments: true,
+    removeAttributeQuotes: true,
+    removeComments: true,
+    removeEmptyAttributes: true,
+    removeOptionalTags: true,
+    removeRedundantAttributes: true,
+    removeScriptTypeAttributes: true,
+    removeStyleLinkTypeAttributes: true,
+    sortAttributes: true,
+    sortClassName: true,
+    useShortDoctype: true
+  }
+};
+
+/**
+ * Get preset configuration by name
+ * @param {string} name - Preset name ('conservative' or 'comprehensive')
+ * @returns {object|null} Preset options object or null if not found
+ */
+function getPreset(name) {
+  if (!name) return null;
+  const normalizedName = name.toLowerCase();
+  return presets[normalizedName] || null;
+}
+
+/**
+ * Get list of available preset names
+ * @returns {string[]} Array of preset names
+ */
+function getPresetNames() {
+  return Object.keys(presets);
+}
+
 const trimWhitespace = str => str && str.replace(/^[ \n\r\t\f]+/, '').replace(/[ \n\r\t\f]+$/, '');
 
 function collapseWhitespaceAll(str) {
@@ -40695,7 +40768,7 @@ async function minifyHTML(value, options, partialMarkup) {
   }
 
   const parser = new HTMLParser(value, {
-    partialMarkup,
+    partialMarkup: partialMarkup ?? options.partialMarkup,
     continueOnParseError: options.continueOnParseError,
     customAttrAssign: options.customAttrAssign,
     customAttrSurround: options.customAttrSurround,
@@ -41067,7 +41140,7 @@ const minify = async function (value, options) {
   return result;
 };
 
-var htmlminifier = { minify };
+var htmlminifier = { minify, presets, getPreset, getPresetNames };
 
 /**
  * @typedef {Object} HTMLAttribute
@@ -41279,6 +41352,15 @@ var htmlminifier = { minify };
  *
  *  Default: `false`
  *
+ * @prop {boolean} [partialMarkup]
+ *  When true, treat input as a partial HTML fragment rather than a complete
+ *  document. This preserves stray end tags (closing tags without corresponding
+ *  opening tags) and prevents auto-closing of unclosed tags at the end of input.
+ *  Useful for minifying template fragments, SSI includes, or other partial HTML
+ *  that will be combined with other fragments.
+ *
+ *  Default: `false`
+ *
  * @prop {boolean} [preserveLineBreaks]
  *  Preserve a single line break at the start/end of text nodes when
  *  collapsing/trimming whitespace.
@@ -41407,4 +41489,4 @@ var htmlminifier = { minify };
  *  Default: `false`
  */
 
-export { htmlminifier as default, minify };
+export { htmlminifier as default, getPreset, getPresetNames, minify, presets };

package/dist/types/htmlminifier.d.ts

@@ -1,6 +1,9 @@
 export function minify(value: string, options?: MinifierOptions): Promise<string>;
 declare namespace _default {
     export { minify };
+    export { presets };
+    export { getPreset };
+    export { getPresetNames };
 }
 export default _default;
 /**
@@ -241,6 +244,16 @@ export type MinifierOptions = {
      * Default: `false`
      */
     noNewlinesBeforeTagClose?: boolean;
+    /**
+     * When true, treat input as a partial HTML fragment rather than a complete
+     * document. This preserves stray end tags (closing tags without corresponding
+     * opening tags) and prevents auto-closing of unclosed tags at the end of input.
+     * Useful for minifying template fragments, SSI includes, or other partial HTML
+     * that will be combined with other fragments.
+     *
+     * Default: `false`
+     */
+    partialMarkup?: boolean;
     /**
      * Preserve a single line break at the start/end of text nodes when
      * collapsing/trimming whitespace.
@@ -387,4 +400,8 @@ export type MinifierOptions = {
      */
     useShortDoctype?: boolean;
 };
+import { presets } from './presets.js';
+import { getPreset } from './presets.js';
+import { getPresetNames } from './presets.js';
+export { presets, getPreset, getPresetNames };
 //# sourceMappingURL=htmlminifier.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"AAs8CO,8BAJI,MAAM,YACN,eAAe,GACb,OAAO,CAAC,MAAM,CAAC,CAQ3B;;;;;;;;;UAQS,MAAM;YACN,MAAM;YACN,MAAM;mBACN,MAAM;iBACN,MAAM;kBACN,MAAM;;;;;;;;;;;;;4BAQN,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE,qBAAqB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO;;;;;;;wBAMjG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,SAAS,EAAE,iBAAiB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO;;;;;;;;oBAMhH,OAAO;;;;;;;;gCAOP,OAAO;;;;;;;;kCAOP,OAAO;;;;;;;;yBAOP,OAAO;;;;;;;;2BAOP,OAAO;;;;;;;;4BAOP,OAAO;;;;;;;2BAOP,OAAO;;;;;;;;uBAMP,MAAM,EAAE;;;;;;yBAOR,MAAM;;;;;;yBAKN,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE;;;;;;;4BAKlB,MAAM,EAAE;;;;;;;oCAMR,MAAM;;;;;;;qBAMN,OAAO;;;;;;;YAMP,OAAO;;;;;;;;2BAMP,MAAM,EAAE;;;;;;;;;4BAOR,MAAM,EAAE;;;;;;;+BAQR,OAAO;;;;;;;2BAMP,SAAS,CAAC,MAAM,CAAC;;;;;;uBAMjB,OAAO;;;;;;;;UAKP,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI;;;;;;;;qBAO1B,MAAM;;;;;;;oBAON,MAAM;;;;;;;;;;gBAMN,OAAO,GAAG,OAAO,CAAC,OAAO,cAAc,EAAE,gBAAgB,CAAC,OAAO,cAAc,EAAE,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;;;eAS9J,OAAO,GAAG,OAAO,QAAQ,EAAE,aAAa,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;;;iBASzG,OAAO,GAAG,MAAM,GAAG,OAAO,WAAW,EAAE,OAAO,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;WAS7F,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM;;;;;;;+BAOxB,OAAO;;;;;;;;yBAMP,OAAO;;;;;;;gCAOP,OAAO;;;;;;;;iCAMP,OAAO;;;;;;;;;;qBAOP,MAAM,EAAE;;;;;;;qBASR,IAAI,GAAG,GAAG;;;;;;;4BAMV,OAAO;;;;;;;;qBAMP,OAAO;;;;;;;;;4BAOP,OAAO,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;;;;;;;;0BAQtD,OAAO;;;;;;;;yBAOP,OAAO;;;;;;;;gCAOP,OAAO;;;;;;;iCAOP,OAAO;;;;;;;oCAMP,OAAO;;;;;;;;;;0BAMP,OAAO;;;;;;;;;qBASP,OAAO,GAAG,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,IAAI,CAAC;;;;;;;;;oBAQzD,OAAO,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;;;;;;;;0BAQrC,OAAO;;;;;;;sBAOP,OAAO"}
+{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"AAu8CO,8BAJI,MAAM,YACN,eAAe,GACb,OAAO,CAAC,MAAM,CAAC,CAQ3B;;;;;;;;;;;;UAUS,MAAM;YACN,MAAM;YACN,MAAM;mBACN,MAAM;iBACN,MAAM;kBACN,MAAM;;;;;;;;;;;;;4BAQN,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE,qBAAqB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO;;;;;;;wBAMjG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,SAAS,EAAE,iBAAiB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO;;;;;;;;oBAMhH,OAAO;;;;;;;;gCAOP,OAAO;;;;;;;;kCAOP,OAAO;;;;;;;;yBAOP,OAAO;;;;;;;;2BAOP,OAAO;;;;;;;;4BAOP,OAAO;;;;;;;2BAOP,OAAO;;;;;;;;uBAMP,MAAM,EAAE;;;;;;yBAOR,MAAM;;;;;;yBAKN,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE;;;;;;;4BAKlB,MAAM,EAAE;;;;;;;oCAMR,MAAM;;;;;;;qBAMN,OAAO;;;;;;;YAMP,OAAO;;;;;;;;2BAMP,MAAM,EAAE;;;;;;;;;4BAOR,MAAM,EAAE;;;;;;;+BAQR,OAAO;;;;;;;2BAMP,SAAS,CAAC,MAAM,CAAC;;;;;;uBAMjB,OAAO;;;;;;;;UAKP,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI;;;;;;;;qBAO1B,MAAM;;;;;;;oBAON,MAAM;;;;;;;;;;gBAMN,OAAO,GAAG,OAAO,CAAC,OAAO,cAAc,EAAE,gBAAgB,CAAC,OAAO,cAAc,EAAE,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;;;eAS9J,OAAO,GAAG,OAAO,QAAQ,EAAE,aAAa,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;;;iBASzG,OAAO,GAAG,MAAM,GAAG,OAAO,WAAW,EAAE,OAAO,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;;;;;;;;WAS7F,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM;;;;;;;+BAOxB,OAAO;;;;;;;;;;oBAMP,OAAO;;;;;;;;yBASP,OAAO;;;;;;;gCAOP,OAAO;;;;;;;;iCAMP,OAAO;;;;;;;;;;qBAOP,MAAM,EAAE;;;;;;;qBASR,IAAI,GAAG,GAAG;;;;;;;4BAMV,OAAO;;;;;;;;qBAMP,OAAO;;;;;;;;;4BAOP,OAAO,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;;;;;;;;0BAQtD,OAAO;;;;;;;;yBAOP,OAAO;;;;;;;;gCAOP,OAAO;;;;;;;iCAOP,OAAO;;;;;;;oCAMP,OAAO;;;;;;;;;;0BAMP,OAAO;;;;;;;;;qBASP,OAAO,GAAG,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,IAAI,CAAC;;;;;;;;;oBAQzD,OAAO,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;;;;;;;;0BAQrC,OAAO;;;;;;;sBAOP,OAAO;;wBAhyDkC,cAAc;0BAAd,cAAc;+BAAd,cAAc"}

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

@@ -1 +1 @@
-{"version":3,"file":"htmlparser.d.ts","sourceRoot":"","sources":["../../src/htmlparser.js"],"names":[],"mappings":"AAgDA,4BAAoE;AAyDpE;IACE,qCAGC;IAFC,UAAgB;IAChB,aAAsB;IAGxB,uBA2VC;CACF"}
+{"version":3,"file":"htmlparser.d.ts","sourceRoot":"","sources":["../../src/htmlparser.js"],"names":[],"mappings":"AAgDA,4BAAoE;AAyDpE;IACE,qCAGC;IAFC,UAAgB;IAChB,aAAsB;IAGxB,uBAgWC;CACF"}

package/dist/types/presets.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Get preset configuration by name
+ * @param {string} name - Preset name ('conservative' or 'comprehensive')
+ * @returns {object|null} Preset options object or null if not found
+ */
+export function getPreset(name: string): object | null;
+/**
+ * Get list of available preset names
+ * @returns {string[]} Array of preset names
+ */
+export function getPresetNames(): string[];
+export namespace presets {
+    namespace conservative {
+        let collapseBooleanAttributes: boolean;
+        let collapseWhitespace: boolean;
+        let conservativeCollapse: boolean;
+        let continueOnParseError: boolean;
+        let decodeEntities: boolean;
+        let minifyURLs: boolean;
+        let noNewlinesBeforeTagClose: boolean;
+        let preserveLineBreaks: boolean;
+        let removeComments: boolean;
+        let removeScriptTypeAttributes: boolean;
+        let removeStyleLinkTypeAttributes: boolean;
+        let useShortDoctype: boolean;
+    }
+    namespace comprehensive {
+        export let caseSensitive: boolean;
+        let collapseBooleanAttributes_1: boolean;
+        export { collapseBooleanAttributes_1 as collapseBooleanAttributes };
+        export let collapseInlineTagWhitespace: boolean;
+        let collapseWhitespace_1: boolean;
+        export { collapseWhitespace_1 as collapseWhitespace };
+        let conservativeCollapse_1: boolean;
+        export { conservativeCollapse_1 as conservativeCollapse };
+        let continueOnParseError_1: boolean;
+        export { continueOnParseError_1 as continueOnParseError };
+        let decodeEntities_1: boolean;
+        export { decodeEntities_1 as decodeEntities };
+        export let minifyCSS: boolean;
+        export let minifyJS: boolean;
+        let minifyURLs_1: boolean;
+        export { minifyURLs_1 as minifyURLs };
+        let noNewlinesBeforeTagClose_1: boolean;
+        export { noNewlinesBeforeTagClose_1 as noNewlinesBeforeTagClose };
+        export let processConditionalComments: boolean;
+        export let removeAttributeQuotes: boolean;
+        let removeComments_1: boolean;
+        export { removeComments_1 as removeComments };
+        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 };
+        export let sortAttributes: boolean;
+        export let sortClassName: boolean;
+        let useShortDoctype_1: boolean;
+        export { useShortDoctype_1 as useShortDoctype };
+    }
+}
+//# sourceMappingURL=presets.d.ts.map

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

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

package/package.json

@@ -84,5 +84,5 @@
     "test:watch": "node --test --watch tests/*.spec.js"
   },
   "type": "module",
-  "version": "4.3.1"
+  "version": "4.5.0"
 }

package/src/htmlminifier.js

@@ -5,6 +5,7 @@ import { minify as terser } from 'terser';
 import { HTMLParser, endTag } from './htmlparser.js';
 import TokenChain from './tokenchain.js';
 import { replaceAsync } from './utils.js';
+import { presets, getPreset, getPresetNames } from './presets.js';
 
 const trimWhitespace = str => str && str.replace(/^[ \n\r\t\f]+/, '').replace(/[ \n\r\t\f]+$/, '');
 
@@ -1112,7 +1113,7 @@ async function minifyHTML(value, options, partialMarkup) {
   }
 
   const parser = new HTMLParser(value, {
-    partialMarkup,
+    partialMarkup: partialMarkup ?? options.partialMarkup,
     continueOnParseError: options.continueOnParseError,
     customAttrAssign: options.customAttrAssign,
     customAttrSurround: options.customAttrSurround,
@@ -1484,7 +1485,9 @@ export const minify = async function (value, options) {
   return result;
 };
 
-export default { minify };
+export { presets, getPreset, getPresetNames };
+
+export default { minify, presets, getPreset, getPresetNames };
 
 /**
  * @typedef {Object} HTMLAttribute
@@ -1696,6 +1699,15 @@ export default { minify };
  *
  *  Default: `false`
  *
+ * @prop {boolean} [partialMarkup]
+ *  When true, treat input as a partial HTML fragment rather than a complete
+ *  document. This preserves stray end tags (closing tags without corresponding
+ *  opening tags) and prevents auto-closing of unclosed tags at the end of input.
+ *  Useful for minifying template fragments, SSI includes, or other partial HTML
+ *  that will be combined with other fragments.
+ *
+ *  Default: `false`
+ *
  * @prop {boolean} [preserveLineBreaks]
  *  Preserve a single line break at the start/end of text nodes when
  *  collapsing/trimming whitespace.

package/src/htmlparser.js

@@ -443,6 +443,11 @@ export class HTMLParser {
         // Remove the open elements from the stack
         stack.length = pos;
         lastTag = pos && stack[pos - 1].tag;
+      } else if (handler.partialMarkup && tagName) {
+        // In partial markup mode, preserve stray end tags
+        if (handler.end) {
+          handler.end(tagName, [], false);
+        }
       } else if (tagName.toLowerCase() === 'br') {
         if (handler.start) {
           await handler.start(tagName, [], true, '');

package/src/presets.js

@@ -0,0 +1,67 @@
+/**
+ * Preset configurations for HTML Minifier Next
+ *
+ * Presets provide curated option sets for common use cases:
+ * - conservative: Safe minification suitable for most projects
+ * - comprehensive: Aggressive minification for maximum file size reduction
+ */
+
+export const presets = {
+  conservative: {
+    collapseBooleanAttributes: true,
+    collapseWhitespace: true,
+    conservativeCollapse: true,
+    continueOnParseError: true,
+    decodeEntities: true,
+    minifyURLs: true,
+    noNewlinesBeforeTagClose: true,
+    preserveLineBreaks: true,
+    removeComments: true,
+    removeScriptTypeAttributes: true,
+    removeStyleLinkTypeAttributes: true,
+    useShortDoctype: true
+  },
+  comprehensive: {
+    caseSensitive: true,
+    collapseBooleanAttributes: true,
+    collapseInlineTagWhitespace: true,
+    collapseWhitespace: true,
+    conservativeCollapse: true,
+    continueOnParseError: true,
+    decodeEntities: true,
+    minifyCSS: true,
+    minifyJS: true,
+    minifyURLs: true,
+    noNewlinesBeforeTagClose: true,
+    processConditionalComments: true,
+    removeAttributeQuotes: true,
+    removeComments: true,
+    removeEmptyAttributes: true,
+    removeOptionalTags: true,
+    removeRedundantAttributes: true,
+    removeScriptTypeAttributes: true,
+    removeStyleLinkTypeAttributes: true,
+    sortAttributes: true,
+    sortClassName: true,
+    useShortDoctype: true
+  }
+};
+
+/**
+ * Get preset configuration by name
+ * @param {string} name - Preset name ('conservative' or 'comprehensive')
+ * @returns {object|null} Preset options object or null if not found
+ */
+export function getPreset(name) {
+  if (!name) return null;
+  const normalizedName = name.toLowerCase();
+  return presets[normalizedName] || null;
+}
+
+/**
+ * Get list of available preset names
+ * @returns {string[]} Array of preset names
+ */
+export function getPresetNames() {
+  return Object.keys(presets);
+}