html-minifier-next 4.7.1 → 4.8.0

package/README.md

@@ -159,7 +159,7 @@ Options can be used in config files (camelCase) or via CLI flags (kebab-case wit
 | `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` |
+| `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.) | `[]` |
@@ -168,6 +168,7 @@ Options can be used in config files (camelCase) or via CLI flags (kebab-case wit
 | `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)`) |
 | `removeEmptyElements`<br>`--remove-empty-elements` | [Remove all elements with empty contents](https://perfectionkills.com/experimenting-with-html-minifier#remove_empty_elements) | `false` |
+| `removeEmptyElementsExcept`<br>`--remove-empty-elements-except` | Array of elements to preserve when `removeEmptyElements` is enabled; accepts simple tag names (e.g., `["td"]`) or HTML-like markup with attributes (e.g., `["<span aria-hidden='true'>"]`); supports double quotes, single quotes, and unquoted attribute values | `[]` |
 | `removeOptionalTags`<br>`--remove-optional-tags` | [Remove optional tags](https://perfectionkills.com/experimenting-with-html-minifier#remove_optional_tags) | `false` |
 | `removeRedundantAttributes`<br>`--remove-redundant-attributes` | [Remove attributes when value matches default](https://meiert.com/blog/optional-html/#toc-attribute-values) | `false` |
 | `removeScriptTypeAttributes`<br>`--remove-script-type-attributes` | Remove `type="text/javascript"` from `script` elements; other `type` attribute values are left intact | `false` |
@@ -262,7 +263,7 @@ How does HTML Minifier Next compare to other minifiers? (All with the most aggre
 **Sample command line:**
 
 ```bash
-html-minifier-next --collapse-whitespace --remove-comments --minify-js true --input-dir=. --output-dir=example
+html-minifier-next --collapse-whitespace --remove-comments --minify-js --input-dir=. --output-dir=example
 ```
 
 **Process specific files and directories:**

package/cli.js

@@ -119,9 +119,9 @@ const mainOptions = {
   caseSensitive: 'Treat attributes in case-sensitive manner (useful for custom HTML elements)',
   collapseBooleanAttributes: 'Omit attribute values from boolean attributes',
   customFragmentQuantifierLimit: ['Set maximum quantifier limit for custom fragments to prevent ReDoS attacks (default: 200)', parseValidInt('customFragmentQuantifierLimit')],
-  collapseInlineTagWhitespace: 'Don’t leave any spaces between “display: inline;” elements when collapsing—use with “collapseWhitespace=true”',
+  collapseInlineTagWhitespace: 'Don’t leave any spaces between “display: inline;” elements when collapsing—use with “--collapse-whitespace”',
   collapseWhitespace: 'Collapse whitespace that contributes to text nodes in a document tree',
-  conservativeCollapse: 'Always collapse to 1 space (never remove it entirely)—use with “collapseWhitespace=true”',
+  conservativeCollapse: 'Always collapse to 1 space (never remove it entirely)—use with “--collapse-whitespace”',
   continueOnMinifyError: 'Abort on minification errors',
   continueOnParseError: 'Handle parse errors instead of aborting',
   customAttrAssign: ['Arrays of regexes that allow to support custom attribute assign expressions (e.g., “<div flex?="{{mode != cover}}"></div>”)', parseJSONRegExpArray],
@@ -142,7 +142,7 @@ const mainOptions = {
   minifyURLs: ['Minify URLs in various attributes (uses relateurl)', parseJSON],
   noNewlinesBeforeTagClose: 'Never add a newline before a tag that closes an element',
   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"',
+  preserveLineBreaks: 'Always collapse to one line break (never remove it entirely) when whitespace between tags includes a line break—use with “--collapse-whitespace”',
   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],
@@ -151,6 +151,7 @@ const mainOptions = {
   removeComments: 'Strip HTML comments',
   removeEmptyAttributes: 'Remove all attributes with whitespace-only values',
   removeEmptyElements: 'Remove all elements with empty contents',
+  removeEmptyElementsExcept: ['Array of elements to preserve when “--remove-empty-elements” is enabled (e.g., “td”, “["td", "<span aria-hidden=\'true\'>"]”)', parseJSONArray],
   removeOptionalTags: 'Remove unrequired tags',
   removeRedundantAttributes: 'Remove attributes when value matches default',
   removeScriptTypeAttributes: 'Remove “type="text/javascript"” from “script” elements; other “type” attribute values are left intact',

package/dist/htmlminifier.cjs

@@ -1117,9 +1117,9 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
     }))).join(', ');
   } else if (isMetaViewport(tag, attrs) && attrName === 'content') {
     attrValue = attrValue.replace(/\s+/g, '').replace(/[0-9]+\.[0-9]+/g, function (numString) {
-      // "0.90000" -> "0.9"
-      // "1.0" -> "1"
-      // "1.0001" -> "1.0001" (unchanged)
+      // “0.90000” → “0.9”
+      // “1.0” → “1”
+      // “1.0001” → “1.0001” (unchanged)
       return (+numString).toString();
     });
   } else if (isContentSecurityPolicy(tag, attrs) && attrName.toLowerCase() === 'content') {
@@ -1390,6 +1390,107 @@ function canRemoveElement(tag, attrs) {
   return true;
 }
 
+function parseElementSpec(str, options) {
+  if (typeof str !== 'string') {
+    return null;
+  }
+
+  const trimmed = str.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  // Simple tag name: “td”
+  if (!/[<>]/.test(trimmed)) {
+    return { tag: options.name(trimmed), attrs: null };
+  }
+
+  // HTML-like markup: “<span aria-hidden='true'>” or “<td></td>”
+  // Extract opening tag using regex
+  const match = trimmed.match(/^<([a-zA-Z][\w:-]*)((?:\s+[^>]*)?)>/);
+  if (!match) {
+    return null;
+  }
+
+  const tag = options.name(match[1]);
+  const attrString = match[2];
+
+  if (!attrString.trim()) {
+    return { tag, attrs: null };
+  }
+
+  // Parse attributes from string
+  const attrs = {};
+  const attrRegex = /([a-zA-Z][\w:-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>/]+)))?/g;
+  let attrMatch;
+
+  while ((attrMatch = attrRegex.exec(attrString))) {
+    const attrName = options.name(attrMatch[1]);
+    const attrValue = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4];
+    // Boolean attributes have no value (undefined)
+    attrs[attrName] = attrValue;
+  }
+
+  return {
+    tag,
+    attrs: Object.keys(attrs).length > 0 ? attrs : null
+  };
+}
+
+function parseRemoveEmptyElementsExcept(input, options) {
+  if (!Array.isArray(input)) {
+    return [];
+  }
+
+  return input.map(item => {
+    if (typeof item === 'string') {
+      const spec = parseElementSpec(item, options);
+      if (!spec && options.log) {
+        options.log('Warning: Unable to parse “removeEmptyElementsExcept” specification: "' + item + '"');
+      }
+      return spec;
+    }
+    if (options.log) {
+      options.log('Warning: “removeEmptyElementsExcept” specification must be a string, received: ' + typeof item);
+    }
+    return null;
+  }).filter(Boolean);
+}
+
+function shouldPreserveEmptyElement(tag, attrs, preserveList) {
+  for (const spec of preserveList) {
+    // Tag name must match
+    if (spec.tag !== tag) {
+      continue;
+    }
+
+    // If no attributes specified in spec, tag match is enough
+    if (!spec.attrs) {
+      return true;
+    }
+
+    // Check if all specified attributes match
+    const allAttrsMatch = Object.entries(spec.attrs).every(([name, value]) => {
+      const attr = attrs.find(a => a.name === name);
+      if (!attr) {
+        return false; // Attribute not present
+      }
+      // Boolean attribute in spec (undefined value) matches if attribute is present
+      if (value === undefined) {
+        return true;
+      }
+      // Valued attribute must match exactly
+      return attr.value === value;
+    });
+
+    if (allAttrsMatch) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 function canCollapseWhitespace(tag) {
   return !/^(?:script|style|pre|textarea)$/.test(tag);
 }
@@ -1839,6 +1940,17 @@ async function minifyHTML(value, options, partialMarkup) {
   const inlineTextSet = new Set([...inlineElementsToKeepWhitespaceWithin, ...normalizedCustomElements]);
   const inlineElements = new Set([...inlineElementsToKeepWhitespaceAround, ...normalizedCustomElements]);
 
+  // Parse `removeEmptyElementsExcept` option
+  let removeEmptyElementsExcept;
+  if (options.removeEmptyElementsExcept && !Array.isArray(options.removeEmptyElementsExcept)) {
+    if (options.log) {
+      options.log('Warning: "removeEmptyElementsExcept" option must be an array, received: ' + typeof options.removeEmptyElementsExcept);
+    }
+    removeEmptyElementsExcept = [];
+  } else {
+    removeEmptyElementsExcept = parseRemoveEmptyElementsExcept(options.removeEmptyElementsExcept, options) || [];
+  }
+
   // Temporarily replace ignored chunks with comments,
   // so that we don’t have to worry what’s there.
   // For all we care there might be
@@ -1866,7 +1978,7 @@ async function minifyHTML(value, options, partialMarkup) {
     // Warn about potential ReDoS if custom fragments use unlimited quantifiers
     for (let i = 0; i < customFragments.length; i++) {
       if (/[*+]/.test(customFragments[i])) {
-        options.log('Warning: Custom fragment contains unlimited quantifiers (* or +) which may cause ReDoS vulnerability');
+        options.log('Warning: Custom fragment contains unlimited quantifiers (“*” or “+”) which may cause ReDoS vulnerability');
         break;
       }
     }
@@ -2109,10 +2221,32 @@ async function minifyHTML(value, options, partialMarkup) {
       }
 
       if (options.removeEmptyElements && isElementEmpty && canRemoveElement(tag, attrs)) {
-        // Remove last “element” from buffer
-        removeStartTag();
-        optionalStartTag = '';
-        optionalEndTag = '';
+        let preserve = false;
+        if (removeEmptyElementsExcept.length) {
+          // Normalize attribute names for comparison with specs
+          const normalizedAttrs = attrs.map(attr => ({ ...attr, name: options.name(attr.name) }));
+          preserve = shouldPreserveEmptyElement(tag, normalizedAttrs, removeEmptyElementsExcept);
+        }
+
+        if (!preserve) {
+          // Remove last “element” from buffer
+          removeStartTag();
+          optionalStartTag = '';
+          optionalEndTag = '';
+        } else {
+          // Preserve the element - add closing tag
+          if (autoGenerated && !options.includeAutoGeneratedTags) {
+            optionalEndTag = '';
+          } else {
+            buffer.push('</' + tag + '>');
+          }
+          charsPrevTag = '/' + tag;
+          if (!inlineElements.has(tag)) {
+            currentChars = '';
+          } else if (isElementEmpty) {
+            currentChars += '|';
+          }
+        }
       } else {
         if (autoGenerated && !options.includeAutoGeneratedTags) {
           optionalEndTag = '';
@@ -2393,7 +2527,7 @@ var htmlminifier = { minify, presets, getPreset, getPresetNames };
  *
  * @prop {boolean} [collapseBooleanAttributes]
  *  Collapse boolean attributes to their name only (for example
- *  `disabled="disabled"` -> `disabled`).
+ *  `disabled="disabled"` → `disabled`).
  *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#collapse_boolean_attributes
  *
  *  Default: `false`
@@ -2637,6 +2771,31 @@ var htmlminifier = { minify, presets, getPreset, getPresetNames };
  *
  *  Default: `false`
  *
+ * @prop {string[]} [removeEmptyElementsExcept]
+ *  Specifies empty elements to preserve when `removeEmptyElements` is enabled.
+ *  Has no effect unless `removeEmptyElements: true`.
+ *
+ *  Accepts tag names or HTML-like element specifications:
+ *
+ *  * Tag name only: `["td", "span"]`—preserves all empty elements of these types
+ *  * With valued attributes: `["<span aria-hidden='true'>"]`—preserves only when attribute values match
+ *  * With boolean attributes: `["<input disabled>"]`—preserves only when boolean attribute is present
+ *  * Mixed: `["<button type='button' disabled>"]`—all specified attributes must match
+ *
+ *  Attribute matching:
+ *
+ *  * All specified attributes must be present and match (valued attributes must have exact values)
+ *  * Additional attributes on the element are allowed
+ *  * Attribute name matching respects the `caseSensitive` option
+ *  * Supports double quotes, single quotes, and unquoted attribute values in specifications
+ *
+ *  Limitations:
+ *
+ *  * Self-closing syntax (e.g., `["<span/>"]`) is not supported; use `["span"]` instead
+ *  * Definitions containing `>` within quoted attribute values (e.g., `["<span title='a>b'>"]`) are not supported
+ *
+ *  Default: `[]`
+ *
  * @prop {boolean} [removeOptionalTags]
  *  Drop optional start/end tags where the HTML specification permits it
  *  (for example `</li>`, optional `<html>` etc.).
@@ -2664,7 +2823,7 @@ var htmlminifier = { minify, presets, getPreset, getPresetNames };
  *  Default: `false`
  *
  * @prop {boolean} [removeTagWhitespace]
- *  **Note that this will currently result in invalid HTML!**
+ *  **Note that this will result in invalid HTML!**
  *
  *  When true, extra whitespace between tag name and attributes (or before
  *  the closing bracket) will be removed where possible. Affects output spacing

package/dist/htmlminifier.esm.bundle.js

@@ -40170,9 +40170,9 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
     }))).join(', ');
   } else if (isMetaViewport(tag, attrs) && attrName === 'content') {
     attrValue = attrValue.replace(/\s+/g, '').replace(/[0-9]+\.[0-9]+/g, function (numString) {
-      // "0.90000" -> "0.9"
-      // "1.0" -> "1"
-      // "1.0001" -> "1.0001" (unchanged)
+      // “0.90000” → “0.9”
+      // “1.0” → “1”
+      // “1.0001” → “1.0001” (unchanged)
       return (+numString).toString();
     });
   } else if (isContentSecurityPolicy(tag, attrs) && attrName.toLowerCase() === 'content') {
@@ -40443,6 +40443,107 @@ function canRemoveElement(tag, attrs) {
   return true;
 }
 
+function parseElementSpec(str, options) {
+  if (typeof str !== 'string') {
+    return null;
+  }
+
+  const trimmed = str.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  // Simple tag name: “td”
+  if (!/[<>]/.test(trimmed)) {
+    return { tag: options.name(trimmed), attrs: null };
+  }
+
+  // HTML-like markup: “<span aria-hidden='true'>” or “<td></td>”
+  // Extract opening tag using regex
+  const match = trimmed.match(/^<([a-zA-Z][\w:-]*)((?:\s+[^>]*)?)>/);
+  if (!match) {
+    return null;
+  }
+
+  const tag = options.name(match[1]);
+  const attrString = match[2];
+
+  if (!attrString.trim()) {
+    return { tag, attrs: null };
+  }
+
+  // Parse attributes from string
+  const attrs = {};
+  const attrRegex = /([a-zA-Z][\w:-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>/]+)))?/g;
+  let attrMatch;
+
+  while ((attrMatch = attrRegex.exec(attrString))) {
+    const attrName = options.name(attrMatch[1]);
+    const attrValue = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4];
+    // Boolean attributes have no value (undefined)
+    attrs[attrName] = attrValue;
+  }
+
+  return {
+    tag,
+    attrs: Object.keys(attrs).length > 0 ? attrs : null
+  };
+}
+
+function parseRemoveEmptyElementsExcept(input, options) {
+  if (!Array.isArray(input)) {
+    return [];
+  }
+
+  return input.map(item => {
+    if (typeof item === 'string') {
+      const spec = parseElementSpec(item, options);
+      if (!spec && options.log) {
+        options.log('Warning: Unable to parse “removeEmptyElementsExcept” specification: "' + item + '"');
+      }
+      return spec;
+    }
+    if (options.log) {
+      options.log('Warning: “removeEmptyElementsExcept” specification must be a string, received: ' + typeof item);
+    }
+    return null;
+  }).filter(Boolean);
+}
+
+function shouldPreserveEmptyElement(tag, attrs, preserveList) {
+  for (const spec of preserveList) {
+    // Tag name must match
+    if (spec.tag !== tag) {
+      continue;
+    }
+
+    // If no attributes specified in spec, tag match is enough
+    if (!spec.attrs) {
+      return true;
+    }
+
+    // Check if all specified attributes match
+    const allAttrsMatch = Object.entries(spec.attrs).every(([name, value]) => {
+      const attr = attrs.find(a => a.name === name);
+      if (!attr) {
+        return false; // Attribute not present
+      }
+      // Boolean attribute in spec (undefined value) matches if attribute is present
+      if (value === undefined) {
+        return true;
+      }
+      // Valued attribute must match exactly
+      return attr.value === value;
+    });
+
+    if (allAttrsMatch) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 function canCollapseWhitespace(tag) {
   return !/^(?:script|style|pre|textarea)$/.test(tag);
 }
@@ -40892,6 +40993,17 @@ async function minifyHTML(value, options, partialMarkup) {
   const inlineTextSet = new Set([...inlineElementsToKeepWhitespaceWithin, ...normalizedCustomElements]);
   const inlineElements = new Set([...inlineElementsToKeepWhitespaceAround, ...normalizedCustomElements]);
 
+  // Parse `removeEmptyElementsExcept` option
+  let removeEmptyElementsExcept;
+  if (options.removeEmptyElementsExcept && !Array.isArray(options.removeEmptyElementsExcept)) {
+    if (options.log) {
+      options.log('Warning: "removeEmptyElementsExcept" option must be an array, received: ' + typeof options.removeEmptyElementsExcept);
+    }
+    removeEmptyElementsExcept = [];
+  } else {
+    removeEmptyElementsExcept = parseRemoveEmptyElementsExcept(options.removeEmptyElementsExcept, options) || [];
+  }
+
   // Temporarily replace ignored chunks with comments,
   // so that we don’t have to worry what’s there.
   // For all we care there might be
@@ -40919,7 +41031,7 @@ async function minifyHTML(value, options, partialMarkup) {
     // Warn about potential ReDoS if custom fragments use unlimited quantifiers
     for (let i = 0; i < customFragments.length; i++) {
       if (/[*+]/.test(customFragments[i])) {
-        options.log('Warning: Custom fragment contains unlimited quantifiers (* or +) which may cause ReDoS vulnerability');
+        options.log('Warning: Custom fragment contains unlimited quantifiers (“*” or “+”) which may cause ReDoS vulnerability');
         break;
       }
     }
@@ -41162,10 +41274,32 @@ async function minifyHTML(value, options, partialMarkup) {
       }
 
       if (options.removeEmptyElements && isElementEmpty && canRemoveElement(tag, attrs)) {
-        // Remove last “element” from buffer
-        removeStartTag();
-        optionalStartTag = '';
-        optionalEndTag = '';
+        let preserve = false;
+        if (removeEmptyElementsExcept.length) {
+          // Normalize attribute names for comparison with specs
+          const normalizedAttrs = attrs.map(attr => ({ ...attr, name: options.name(attr.name) }));
+          preserve = shouldPreserveEmptyElement(tag, normalizedAttrs, removeEmptyElementsExcept);
+        }
+
+        if (!preserve) {
+          // Remove last “element” from buffer
+          removeStartTag();
+          optionalStartTag = '';
+          optionalEndTag = '';
+        } else {
+          // Preserve the element - add closing tag
+          if (autoGenerated && !options.includeAutoGeneratedTags) {
+            optionalEndTag = '';
+          } else {
+            buffer.push('</' + tag + '>');
+          }
+          charsPrevTag = '/' + tag;
+          if (!inlineElements.has(tag)) {
+            currentChars = '';
+          } else if (isElementEmpty) {
+            currentChars += '|';
+          }
+        }
       } else {
         if (autoGenerated && !options.includeAutoGeneratedTags) {
           optionalEndTag = '';
@@ -41446,7 +41580,7 @@ var htmlminifier = { minify, presets, getPreset, getPresetNames };
  *
  * @prop {boolean} [collapseBooleanAttributes]
  *  Collapse boolean attributes to their name only (for example
- *  `disabled="disabled"` -> `disabled`).
+ *  `disabled="disabled"` → `disabled`).
  *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#collapse_boolean_attributes
  *
  *  Default: `false`
@@ -41690,6 +41824,31 @@ var htmlminifier = { minify, presets, getPreset, getPresetNames };
  *
  *  Default: `false`
  *
+ * @prop {string[]} [removeEmptyElementsExcept]
+ *  Specifies empty elements to preserve when `removeEmptyElements` is enabled.
+ *  Has no effect unless `removeEmptyElements: true`.
+ *
+ *  Accepts tag names or HTML-like element specifications:
+ *
+ *  * Tag name only: `["td", "span"]`—preserves all empty elements of these types
+ *  * With valued attributes: `["<span aria-hidden='true'>"]`—preserves only when attribute values match
+ *  * With boolean attributes: `["<input disabled>"]`—preserves only when boolean attribute is present
+ *  * Mixed: `["<button type='button' disabled>"]`—all specified attributes must match
+ *
+ *  Attribute matching:
+ *
+ *  * All specified attributes must be present and match (valued attributes must have exact values)
+ *  * Additional attributes on the element are allowed
+ *  * Attribute name matching respects the `caseSensitive` option
+ *  * Supports double quotes, single quotes, and unquoted attribute values in specifications
+ *
+ *  Limitations:
+ *
+ *  * Self-closing syntax (e.g., `["<span/>"]`) is not supported; use `["span"]` instead
+ *  * Definitions containing `>` within quoted attribute values (e.g., `["<span title='a>b'>"]`) are not supported
+ *
+ *  Default: `[]`
+ *
  * @prop {boolean} [removeOptionalTags]
  *  Drop optional start/end tags where the HTML specification permits it
  *  (for example `</li>`, optional `<html>` etc.).
@@ -41717,7 +41876,7 @@ var htmlminifier = { minify, presets, getPreset, getPresetNames };
  *  Default: `false`
  *
  * @prop {boolean} [removeTagWhitespace]
- *  **Note that this will currently result in invalid HTML!**
+ *  **Note that this will result in invalid HTML!**
  *
  *  When true, extra whitespace between tag name and attributes (or before
  *  the closing bracket) will be removed where possible. Affects output spacing

package/dist/types/htmlminifier.d.ts

@@ -46,7 +46,7 @@ export type MinifierOptions = {
     caseSensitive?: boolean;
     /**
      * Collapse boolean attributes to their name only (for example
-     * `disabled="disabled"` -> `disabled`).
+     * `disabled="disabled"` → `disabled`).
      * See also: https://perfectionkills.com/experimenting-with-html-minifier/#collapse_boolean_attributes
      *
      * Default: `false`
@@ -326,6 +326,32 @@ export type MinifierOptions = {
      * Default: `false`
      */
     removeEmptyElements?: boolean;
+    /**
+     * Specifies empty elements to preserve when `removeEmptyElements` is enabled.
+     * Has no effect unless `removeEmptyElements: true`.
+     *
+     * Accepts tag names or HTML-like element specifications:
+     *
+     * * Tag name only: `["td", "span"]`—preserves all empty elements of these types
+     * * With valued attributes: `["<span aria-hidden='true'>"]`—preserves only when attribute values match
+     * * With boolean attributes: `["<input disabled>"]`—preserves only when boolean attribute is present
+     * * Mixed: `["<button type='button' disabled>"]`—all specified attributes must match
+     *
+     * Attribute matching:
+     *
+     * * All specified attributes must be present and match (valued attributes must have exact values)
+     * * Additional attributes on the element are allowed
+     * * Attribute name matching respects the `caseSensitive` option
+     * * Supports double quotes, single quotes, and unquoted attribute values in specifications
+     *
+     * Limitations:
+     *
+     * * Self-closing syntax (e.g., `["<span/>"]`) is not supported; use `["span"]` instead
+     * * Definitions containing `>` within quoted attribute values (e.g., `["<span title='a>b'>"]`) are not supported
+     *
+     * Default: `[]`
+     */
+    removeEmptyElementsExcept?: string[];
     /**
      * Drop optional start/end tags where the HTML specification permits it
      * (for example `</li>`, optional `<html>` etc.).
@@ -357,7 +383,7 @@ export type MinifierOptions = {
      */
     removeStyleLinkTypeAttributes?: boolean;
     /**
-     * **Note that this will currently result in invalid HTML!**
+     * **Note that this will result in invalid HTML!**
      *
      * When true, extra whitespace between tag name and attributes (or before
      * the closing bracket) will be removed where possible. Affects output spacing

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

@@ -1 +1 @@
-{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"AAknDO,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;;wBA38DkC,cAAc;0BAAd,cAAc;+BAAd,cAAc"}
+{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"AAwvDO,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;;;;;;;;;;;;;;;;;;;;;;;;;;gCAOP,MAAM,EAAE;;;;;;;;yBAyBR,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;;wBA1mEkC,cAAc;0BAAd,cAAc;+BAAd,cAAc"}

package/package.json

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

package/src/htmlminifier.js

@@ -420,9 +420,9 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
     }))).join(', ');
   } else if (isMetaViewport(tag, attrs) && attrName === 'content') {
     attrValue = attrValue.replace(/\s+/g, '').replace(/[0-9]+\.[0-9]+/g, function (numString) {
-      // "0.90000" -> "0.9"
-      // "1.0" -> "1"
-      // "1.0001" -> "1.0001" (unchanged)
+      // “0.90000” → “0.9”
+      // “1.0” → “1”
+      // “1.0001” → “1.0001” (unchanged)
       return (+numString).toString();
     });
   } else if (isContentSecurityPolicy(tag, attrs) && attrName.toLowerCase() === 'content') {
@@ -693,6 +693,107 @@ function canRemoveElement(tag, attrs) {
   return true;
 }
 
+function parseElementSpec(str, options) {
+  if (typeof str !== 'string') {
+    return null;
+  }
+
+  const trimmed = str.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  // Simple tag name: “td”
+  if (!/[<>]/.test(trimmed)) {
+    return { tag: options.name(trimmed), attrs: null };
+  }
+
+  // HTML-like markup: “<span aria-hidden='true'>” or “<td></td>”
+  // Extract opening tag using regex
+  const match = trimmed.match(/^<([a-zA-Z][\w:-]*)((?:\s+[^>]*)?)>/);
+  if (!match) {
+    return null;
+  }
+
+  const tag = options.name(match[1]);
+  const attrString = match[2];
+
+  if (!attrString.trim()) {
+    return { tag, attrs: null };
+  }
+
+  // Parse attributes from string
+  const attrs = {};
+  const attrRegex = /([a-zA-Z][\w:-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>/]+)))?/g;
+  let attrMatch;
+
+  while ((attrMatch = attrRegex.exec(attrString))) {
+    const attrName = options.name(attrMatch[1]);
+    const attrValue = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4];
+    // Boolean attributes have no value (undefined)
+    attrs[attrName] = attrValue;
+  }
+
+  return {
+    tag,
+    attrs: Object.keys(attrs).length > 0 ? attrs : null
+  };
+}
+
+function parseRemoveEmptyElementsExcept(input, options) {
+  if (!Array.isArray(input)) {
+    return [];
+  }
+
+  return input.map(item => {
+    if (typeof item === 'string') {
+      const spec = parseElementSpec(item, options);
+      if (!spec && options.log) {
+        options.log('Warning: Unable to parse “removeEmptyElementsExcept” specification: "' + item + '"');
+      }
+      return spec;
+    }
+    if (options.log) {
+      options.log('Warning: “removeEmptyElementsExcept” specification must be a string, received: ' + typeof item);
+    }
+    return null;
+  }).filter(Boolean);
+}
+
+function shouldPreserveEmptyElement(tag, attrs, preserveList) {
+  for (const spec of preserveList) {
+    // Tag name must match
+    if (spec.tag !== tag) {
+      continue;
+    }
+
+    // If no attributes specified in spec, tag match is enough
+    if (!spec.attrs) {
+      return true;
+    }
+
+    // Check if all specified attributes match
+    const allAttrsMatch = Object.entries(spec.attrs).every(([name, value]) => {
+      const attr = attrs.find(a => a.name === name);
+      if (!attr) {
+        return false; // Attribute not present
+      }
+      // Boolean attribute in spec (undefined value) matches if attribute is present
+      if (value === undefined) {
+        return true;
+      }
+      // Valued attribute must match exactly
+      return attr.value === value;
+    });
+
+    if (allAttrsMatch) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 function canCollapseWhitespace(tag) {
   return !/^(?:script|style|pre|textarea)$/.test(tag);
 }
@@ -1142,6 +1243,17 @@ async function minifyHTML(value, options, partialMarkup) {
   const inlineTextSet = new Set([...inlineElementsToKeepWhitespaceWithin, ...normalizedCustomElements]);
   const inlineElements = new Set([...inlineElementsToKeepWhitespaceAround, ...normalizedCustomElements]);
 
+  // Parse `removeEmptyElementsExcept` option
+  let removeEmptyElementsExcept;
+  if (options.removeEmptyElementsExcept && !Array.isArray(options.removeEmptyElementsExcept)) {
+    if (options.log) {
+      options.log('Warning: "removeEmptyElementsExcept" option must be an array, received: ' + typeof options.removeEmptyElementsExcept);
+    }
+    removeEmptyElementsExcept = [];
+  } else {
+    removeEmptyElementsExcept = parseRemoveEmptyElementsExcept(options.removeEmptyElementsExcept, options) || [];
+  }
+
   // Temporarily replace ignored chunks with comments,
   // so that we don’t have to worry what’s there.
   // For all we care there might be
@@ -1169,7 +1281,7 @@ async function minifyHTML(value, options, partialMarkup) {
     // Warn about potential ReDoS if custom fragments use unlimited quantifiers
     for (let i = 0; i < customFragments.length; i++) {
       if (/[*+]/.test(customFragments[i])) {
-        options.log('Warning: Custom fragment contains unlimited quantifiers (* or +) which may cause ReDoS vulnerability');
+        options.log('Warning: Custom fragment contains unlimited quantifiers (“*” or “+”) which may cause ReDoS vulnerability');
         break;
       }
     }
@@ -1412,10 +1524,32 @@ async function minifyHTML(value, options, partialMarkup) {
       }
 
       if (options.removeEmptyElements && isElementEmpty && canRemoveElement(tag, attrs)) {
-        // Remove last “element” from buffer
-        removeStartTag();
-        optionalStartTag = '';
-        optionalEndTag = '';
+        let preserve = false;
+        if (removeEmptyElementsExcept.length) {
+          // Normalize attribute names for comparison with specs
+          const normalizedAttrs = attrs.map(attr => ({ ...attr, name: options.name(attr.name) }));
+          preserve = shouldPreserveEmptyElement(tag, normalizedAttrs, removeEmptyElementsExcept);
+        }
+
+        if (!preserve) {
+          // Remove last “element” from buffer
+          removeStartTag();
+          optionalStartTag = '';
+          optionalEndTag = '';
+        } else {
+          // Preserve the element - add closing tag
+          if (autoGenerated && !options.includeAutoGeneratedTags) {
+            optionalEndTag = '';
+          } else {
+            buffer.push('</' + tag + '>');
+          }
+          charsPrevTag = '/' + tag;
+          if (!inlineElements.has(tag)) {
+            currentChars = '';
+          } else if (isElementEmpty) {
+            currentChars += '|';
+          }
+        }
       } else {
         if (autoGenerated && !options.includeAutoGeneratedTags) {
           optionalEndTag = '';
@@ -1698,7 +1832,7 @@ export default { minify, presets, getPreset, getPresetNames };
  *
  * @prop {boolean} [collapseBooleanAttributes]
  *  Collapse boolean attributes to their name only (for example
- *  `disabled="disabled"` -> `disabled`).
+ *  `disabled="disabled"` → `disabled`).
  *  See also: https://perfectionkills.com/experimenting-with-html-minifier/#collapse_boolean_attributes
  *
  *  Default: `false`
@@ -1942,6 +2076,31 @@ export default { minify, presets, getPreset, getPresetNames };
  *
  *  Default: `false`
  *
+ * @prop {string[]} [removeEmptyElementsExcept]
+ *  Specifies empty elements to preserve when `removeEmptyElements` is enabled.
+ *  Has no effect unless `removeEmptyElements: true`.
+ *
+ *  Accepts tag names or HTML-like element specifications:
+ *
+ *  * Tag name only: `["td", "span"]`—preserves all empty elements of these types
+ *  * With valued attributes: `["<span aria-hidden='true'>"]`—preserves only when attribute values match
+ *  * With boolean attributes: `["<input disabled>"]`—preserves only when boolean attribute is present
+ *  * Mixed: `["<button type='button' disabled>"]`—all specified attributes must match
+ *
+ *  Attribute matching:
+ *
+ *  * All specified attributes must be present and match (valued attributes must have exact values)
+ *  * Additional attributes on the element are allowed
+ *  * Attribute name matching respects the `caseSensitive` option
+ *  * Supports double quotes, single quotes, and unquoted attribute values in specifications
+ *
+ *  Limitations:
+ *
+ *  * Self-closing syntax (e.g., `["<span/>"]`) is not supported; use `["span"]` instead
+ *  * Definitions containing `>` within quoted attribute values (e.g., `["<span title='a>b'>"]`) are not supported
+ *
+ *  Default: `[]`
+ *
  * @prop {boolean} [removeOptionalTags]
  *  Drop optional start/end tags where the HTML specification permits it
  *  (for example `</li>`, optional `<html>` etc.).
@@ -1969,7 +2128,7 @@ export default { minify, presets, getPreset, getPresetNames };
  *  Default: `false`
  *
  * @prop {boolean} [removeTagWhitespace]
- *  **Note that this will currently result in invalid HTML!**
+ *  **Note that this will result in invalid HTML!**
  *
  *  When true, extra whitespace between tag name and attributes (or before
  *  the closing bracket) will be removed where possible. Affects output spacing