html-minifier-next 1.4.0 → 1.4.2

package/README.md

@@ -57,7 +57,7 @@ Use `html-minifier-next --help` to check all available options:
 | --- | --- | --- |
 | `--input-dir <dir>` | Specify an input directory | `--input-dir=src` |
 | `--output-dir <dir>` | Specify an output directory | `--output-dir=dist` |
-| `--file-ext <extensions>` | Specify file extension(s) to process (overrides config file setting) | `--file-ext=html` or `--file-ext=html,htm,php` |
+| `--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 --output <file>` | Specify output file (single file mode) | `-o minified.html` |
 | `-c --config-file <file>` | Use a configuration file | `--config-file=html-minifier.json` |
 
@@ -157,59 +157,59 @@ Most of the options are disabled by default.
 | `caseSensitive` | Treat attributes in case-sensitive manner (useful for custom HTML elements) | `false` |
 | `collapseBooleanAttributes` | [Omit attribute values from boolean attributes](http://perfectionkills.com/experimenting-with-html-minifier#collapse_boolean_attributes) | `false` |
 | `customFragmentQuantifierLimit` | Set maximum quantifier limit for custom fragments to prevent ReDoS attacks | `200` |
-| `collapseInlineTagWhitespace` | Don’t leave any spaces between `display:inline;` elements when collapsing. Must be used in conjunction with `collapseWhitespace=true` | `false` |
-| `collapseWhitespace` | [Collapse white space that contributes to text nodes in a document tree](http://perfectionkills.com/experimenting-with-html-minifier#collapse_whitespace) | `false` |
-| `conservativeCollapse` | Always collapse to 1 space (never remove it entirely). Must be used in conjunction with `collapseWhitespace=true` | `false` |
-| `continueOnParseError` | [Handle parse errors](https://html.spec.whatwg.org/multipage/parsing.html#parse-errors) instead of aborting. | `false` |
-| `customAttrAssign` | Arrays of regex’es that allow to support custom attribute assign expressions (e.g. `'<div flex?="{{mode != cover}}"></div>'`) | `[]` |
-| `customAttrCollapse` | Regex that specifies custom attribute to strip newlines from (e.g. `/ng-class/`) | |
-| `customAttrSurround` | Arrays of regexes that allow to support custom attribute surround expressions (e.g. `<input {{#if value}}checked="checked"{{/if}}>`) | `[]` |
-| `customEventAttributes` | Arrays of regexes that allow to support custom event attributes for `minifyJS` (e.g. `ng-click`) | `[ /^on[a-z]{3,}$/ ]` |
+| `collapseInlineTagWhitespace` | Don’t leave any spaces between `display: inline;` elements when collapsing—use with `collapseWhitespace=true` | `false` |
+| `collapseWhitespace` | [Collapse whitespace that contributes to text nodes in a document tree](http://perfectionkills.com/experimenting-with-html-minifier#collapse_whitespace) | `false` |
+| `conservativeCollapse` | Always collapse to 1 space (never remove it entirely)—use with `collapseWhitespace=true` | `false` |
+| `continueOnParseError` | [Handle parse errors](https://html.spec.whatwg.org/multipage/parsing.html#parse-errors) instead of aborting | `false` |
+| `customAttrAssign` | Arrays of regexes that allow to support custom attribute assign expressions (e.g., `'<div flex?="{{mode != cover}}"></div>'`) | `[]` |
+| `customAttrCollapse` | Regex that specifies custom attribute to strip newlines from (e.g., `/ng-class/`) | |
+| `customAttrSurround` | Arrays of regexes that allow to support custom attribute surround expressions (e.g., `<input {{#if value}}checked="checked"{{/if}}>`) | `[]` |
+| `customEventAttributes` | Arrays of regexes that allow to support custom event attributes for `minifyJS` (e.g., `ng-click`) | `[ /^on[a-z]{3,}$/ ]` |
 | `decodeEntities` | Use direct Unicode characters whenever possible | `false` |
-| `html5` | Parse input according to HTML5 specifications | `true` |
+| `html5` | Parse input according to the HTML specification | `true` |
 | `ignoreCustomComments` | Array of regexes that allow to ignore certain comments, when matched | `[ /^!/, /^\s*#/ ]` |
-| `ignoreCustomFragments` | Array of regexes that allow to ignore certain fragments, when matched (e.g. `<?php ... ?>`, `{{ ... }}`, etc.) | `[ /<%[\s\S]*?%>/, /<\?[\s\S]*?\?>/ ]` |
+| `ignoreCustomFragments` | Array of regexes that allow to ignore certain fragments, when matched (e.g., `<?php … ?>`, `{{ … }}`, etc.) | `[ /<%[\s\S]*?%>/, /<\?[\s\S]*?\?>/ ]` |
 | `includeAutoGeneratedTags` | Insert elements generated by HTML parser | `true` |
 | `inlineCustomElements` | Array of names of custom elements which are inline | `[]` |
-| `keepClosingSlash` | Keep the trailing slash on singleton elements | `false` |
+| `keepClosingSlash` | Keep the trailing slash on void elements | `false` |
 | `maxInputLength` | Maximum input length to prevent ReDoS attacks (disabled by default) | `undefined` |
-| `maxLineLength` | Specify a maximum line length. Compressed output will be split by newlines at valid HTML split-points |
-| `minifyCSS` | Minify CSS in style elements and style attributes (uses [clean-css](https://github.com/jakubpawlowicz/clean-css)) | `false` (could be `true`, `Object`, `Function(text, type)`) |
-| `minifyJS` | Minify JavaScript in script elements and event attributes (uses [Terser](https://github.com/terser/terser)) | `false` (could be `true`, `Object`, `Function(text, inline)`) |
+| `maxLineLength` | Specify a maximum line length; compressed output will be split by newlines at valid HTML split-points | |
+| `minifyCSS` | Minify CSS in `style` elements and `style` attributes (uses [clean-css](https://github.com/jakubpawlowicz/clean-css)) | `false` (could be `true`, `Object`, `Function(text, type)`) |
+| `minifyJS` | Minify JavaScript in `script` elements and event attributes (uses [Terser](https://github.com/terser/terser)) | `false` (could be `true`, `Object`, `Function(text, inline)`) |
 | `minifyURLs` | Minify URLs in various attributes (uses [relateurl](https://github.com/stevenvachon/relateurl)) | `false` (could be `String`, `Object`, `Function(text)`) |
 | `noNewlinesBeforeTagClose` | Never add a newline before a tag that closes an element | `false` |
-| `preserveLineBreaks` | Always collapse to 1 line break (never remove it entirely) when whitespace between tags include a line break. Must be used in conjunction with `collapseWhitespace=true` | `false` |
+| `preserveLineBreaks` | Always collapse to 1 line break (never remove it entirely) when whitespace between tags includes a line break—use with `collapseWhitespace=true` | `false` |
 | `preventAttributesEscaping` | Prevents the escaping of the values of attributes | `false` |
 | `processConditionalComments` | Process contents of conditional comments through minifier | `false` |
-| `processScripts` | Array of strings corresponding to types of script elements to process through minifier (e.g. `text/ng-template`, `text/x-handlebars-template`, etc.) | `[]` |
-| `quoteCharacter` | Type of quote to use for attribute values (“'” or “"”) | |
+| `processScripts` | Array of strings corresponding to types of `script` elements to process through minifier (e.g., `text/ng-template`, `text/x-handlebars-template`, etc.) | `[]` |
+| `quoteCharacter` | Type of quote to use for attribute values (`'` or `"`) | |
 | `removeAttributeQuotes` | [Remove quotes around attributes when possible](http://perfectionkills.com/experimenting-with-html-minifier#remove_attribute_quotes) | `false` |
 | `removeComments` | [Strip HTML comments](http://perfectionkills.com/experimenting-with-html-minifier#remove_comments) | `false` |
 | `removeEmptyAttributes` | [Remove all attributes with whitespace-only values](http://perfectionkills.com/experimenting-with-html-minifier#remove_empty_or_blank_attributes) | `false` (could be `true`, `Function(attrName, tag)`) |
 | `removeEmptyElements` | [Remove all elements with empty contents](http://perfectionkills.com/experimenting-with-html-minifier#remove_empty_elements) | `false` |
 | `removeOptionalTags` | [Remove optional tags](http://perfectionkills.com/experimenting-with-html-minifier#remove_optional_tags) | `false` |
 | `removeRedundantAttributes` | [Remove attributes when value matches default.](http://perfectionkills.com/experimenting-with-html-minifier#remove_redundant_attributes) | `false` |
-| `removeScriptTypeAttributes` | Remove `type="text/javascript"` from `script` elements. Other `type` attribute values are left intact | `false` |
-| `removeStyleLinkTypeAttributes`| Remove `type="text/css"` from `style` and `link` elements. Other `type` attribute values are left intact | `false` |
-| `removeTagWhitespace` | Remove space between attributes whenever possible. **Note that this will result in invalid HTML!** | `false` |
-| `sortAttributes` | [Sort attributes by frequency](#sorting-attributes--style-classes) | `false` |
-| `sortClassName` | [Sort style classes by frequency](#sorting-attributes--style-classes) | `false` |
-| `trimCustomFragments` | Trim white space around `ignoreCustomFragments`. | `false` |
-| `useShortDoctype` | [Replaces the `doctype` with the short (HTML5) doctype](http://perfectionkills.com/experimenting-with-html-minifier#use_short_doctype) | `false` |
+| `removeScriptTypeAttributes` | Remove `type="text/javascript"` from `script` elements; other `type` attribute values are left intact | `false` |
+| `removeStyleLinkTypeAttributes`| Remove `type="text/css"` from `style` and `link` elements; other `type` attribute values are left intact | `false` |
+| `removeTagWhitespace` | Remove space between attributes whenever possible; **note that this will result in invalid HTML** | `false` |
+| `sortAttributes` | [Sort attributes by frequency](#sorting-attributes-and-style-classes) | `false` |
+| `sortClassName` | [Sort style classes by frequency](#sorting-attributes-and-style-classes) | `false` |
+| `trimCustomFragments` | Trim whitespace around `ignoreCustomFragments` | `false` |
+| `useShortDoctype` | [Replaces the doctype with the short (HTML) doctype](http://perfectionkills.com/experimenting-with-html-minifier#use_short_doctype) | `false` |
 
-### Sorting attributes / style classes
+### Sorting attributes and style classes
 
-Minifier options like `sortAttributes` and `sortClassName` won’t impact the plain-text size of the output. However, they form long repetitive chains of characters that should improve compression ratio of gzip used in HTTP compression.
+Minifier options like `sortAttributes` and `sortClassName` won’t impact the plain‑text size of the output. However, they form long, repetitive character chains that should improve the compression ratio of gzip used for HTTP.
 
 ## Special cases
 
 ### Ignoring chunks of markup
 
-If you have chunks of markup you would like preserved, you can wrap them `<!-- htmlmin:ignore -->`.
+If you have chunks of markup you would like preserved, you can wrap them with `<!-- htmlmin:ignore -->`.
 
 ### Minifying JSON-LD
 
-You can minify script elements with JSON-LD by setting the option `{ processScripts: ['application/ld+json'] }`. Note that this minification is very rudimentary, it is 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
 
@@ -219,9 +219,11 @@ SVG elements are automatically recognized, and when they are minified, both case
 
 HTML Minifier **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.
 
-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>`)
+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>`)
 
-HTML Minifier can’t know that original markup was only half of the tree; it does its best to try to parse it as a full tree and it loses information about tree being malformed or partial in the beginning. As a result, it can’t create a partial/malformed tree at the time of the output.
+HTML Minifier 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.
+
+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/).
 
 ## Security
 
@@ -237,8 +239,6 @@ This minifier includes protection against regular expression denial of service (
 
 **Important:** When using custom `ignoreCustomFragments`, ensure your regular expressions don’t contain unlimited quantifiers (`*`, `+`) without bounds, as these can lead to ReDoS vulnerabilities.
 
-(Further improvements are needed. Contributions welcome.)
-
 #### Custom fragment examples
 
 **Safe patterns** (recommended):

package/cli.js

@@ -97,48 +97,48 @@ function parseJSONRegExpArray(value) {
 const parseString = value => value;
 
 const mainOptions = {
-  caseSensitive: 'Treat attributes in case sensitive manner (useful for SVG; e.g. viewBox)',
+  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)', parseInt],
-  collapseInlineTagWhitespace: 'Collapse white space around inline tag',
-  collapseWhitespace: 'Collapse white space that contributes to text nodes in a document tree.',
-  conservativeCollapse: 'Always collapse to 1 space (never remove it entirely)',
+  collapseInlineTagWhitespace: 'Don’t leave any spaces between “display: inline;” elements when collapsing—use with “collapseWhitespace=true”',
+  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”',
   continueOnParseError: 'Handle parse errors instead of aborting',
-  customAttrAssign: ['Arrays of regex\'es that allow to support custom attribute assign expressions (e.g. \'<div flex?="{{mode != cover}}"></div>\')', parseJSONRegExpArray],
-  customAttrCollapse: ['Regex that specifies custom attribute to strip newlines from (e.g. /ng-class/)', parseRegExp],
-  customAttrSurround: ['Arrays of regex\'es that allow to support custom attribute surround expressions (e.g. <input {{#if value}}checked="checked"{{/if}}>)', parseJSONRegExpArray],
-  customEventAttributes: ['Arrays of regex\'es that allow to support custom event attributes for minifyJS (e.g. ng-click)', parseJSONRegExpArray],
+  customAttrAssign: ['Arrays of regexes that allow to support custom attribute assign expressions (e.g., “<div flex?="{{mode != cover}}"></div>”)', parseJSONRegExpArray],
+  customAttrCollapse: ['Regex that specifies custom attribute to strip newlines from (e.g., /ng-class/)', parseRegExp],
+  customAttrSurround: ['Arrays of regexes that allow to support custom attribute surround expressions (e.g., “<input {{#if value}}checked="checked"{{/if}}>”)', parseJSONRegExpArray],
+  customEventAttributes: ['Arrays of regexes that allow to support custom event attributes for minifyJS (e.g., “ng-click”)', parseJSONRegExpArray],
   decodeEntities: 'Use direct Unicode characters whenever possible',
-  html5: 'Parse input according to HTML5 specifications',
-  ignoreCustomComments: ['Array of regex\'es that allow to ignore certain comments, when matched', parseJSONRegExpArray],
-  ignoreCustomFragments: ['Array of regex\'es that allow to ignore certain fragments, when matched (e.g. <?php ... ?>, {{ ... }})', parseJSONRegExpArray],
-  includeAutoGeneratedTags: 'Insert tags generated by HTML parser',
+  html5: 'Parse input according to the HTML specification',
+  ignoreCustomComments: ['Array of regexes that allow to ignore certain comments, when matched', parseJSONRegExpArray],
+  ignoreCustomFragments: ['Array of regexes that allow to ignore certain fragments, when matched (e.g., “<?php … ?>”, “{{ … }}”)', parseJSONRegExpArray],
+  includeAutoGeneratedTags: 'Insert elements generated by HTML parser',
   inlineCustomElements: ['Array of names of custom elements which are inline', parseJSONArray],
-  keepClosingSlash: 'Keep the trailing slash on singleton elements',
+  keepClosingSlash: 'Keep the trailing slash on void elements',
   maxInputLength: ['Maximum input length to prevent ReDoS attacks', parseInt],
-  maxLineLength: ['Max line length', parseInt],
-  minifyCSS: ['Minify CSS in style elements and style attributes (uses clean-css)', parseJSON],
-  minifyJS: ['Minify Javascript in script elements and on* attributes', parseJSON],
+  maxLineLength: ['Specify a maximum line length; compressed output will be split by newlines at valid HTML split-points', parseInt],
+  minifyCSS: ['Minify CSS in “style” elements and “style” attributes (uses clean-css)', parseJSON],
+  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 include a line break.',
-  preventAttributesEscaping: 'Prevents the escaping of the values of attributes.',
+  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],
-  quoteCharacter: ['Type of quote to use for attribute values (\' or ")', parseString],
-  removeAttributeQuotes: 'Remove quotes around attributes when possible.',
+  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],
+  quoteCharacter: ['Type of quote to use for attribute values (“\'” or “\"”)', parseString],
+  removeAttributeQuotes: 'Remove quotes around attributes when possible',
   removeComments: 'Strip HTML comments',
   removeEmptyAttributes: 'Remove all attributes with whitespace-only values',
   removeEmptyElements: 'Remove all elements with empty contents',
   removeOptionalTags: 'Remove unrequired tags',
-  removeRedundantAttributes: 'Remove attributes when value matches default.',
-  removeScriptTypeAttributes: 'Removes the following attributes from script tags: text/javascript, text/ecmascript, text/jscript, application/javascript, application/x-javascript, application/ecmascript. Other type attribute values are left intact',
-  removeStyleLinkTypeAttributes: 'Remove type="text/css" from style and link tags. Other type attribute values are left intact.',
-  removeTagWhitespace: 'Remove space between attributes whenever possible',
+  removeRedundantAttributes: 'Remove attributes when value matches default',
+  removeScriptTypeAttributes: 'Remove “type="text/javascript"” from “script” elements; other “type” attribute values are left intact',
+  removeStyleLinkTypeAttributes: 'Remove “type="text/css"” from “style” and “link” elements; other “type” attribute values are left intact',
+  removeTagWhitespace: 'Remove space between attributes whenever possible; note that this will result in invalid HTML',
   sortAttributes: 'Sort attributes by frequency',
   sortClassName: 'Sort style classes by frequency',
-  trimCustomFragments: 'Trim white space around ignoreCustomFragments.',
-  useShortDoctype: 'Replaces the doctype with the short (HTML5) doctype'
+  trimCustomFragments: 'Trim whitespace around “ignoreCustomFragments”',
+  useShortDoctype: 'Replaces the doctype with the short (HTML) doctype'
 };
 
 // Configure command line flags

package/dist/htmlminifier.cjs

@@ -33,7 +33,7 @@ class CaseInsensitiveSet extends Set {
   }
 }
 
-// Regular Expressions for parsing tags and attributes
+// Regular expressions for parsing tags and attributes
 const singleAttrIdentifier = /([^\s"'<>/=]+)/;
 const singleAttrAssigns = [/=/];
 const singleAttrValues = [
@@ -64,10 +64,10 @@ let IS_REGEX_CAPTURING_BROKEN = false;
   IS_REGEX_CAPTURING_BROKEN = g === '';
 });
 
-// Empty Elements
+// Empty elements
 const empty = new CaseInsensitiveSet(['area', 'base', 'basefont', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'isindex', 'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
 
-// Inline Elements
+// Inline elements
 const inline = new CaseInsensitiveSet(['a', 'abbr', 'acronym', 'applet', 'b', 'basefont', 'bdo', 'big', 'br', 'button', 'cite', 'code', 'del', 'dfn', 'em', 'font', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'label', 'map', 'noscript', 'object', 'q', 's', 'samp', 'script', 'select', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'svg', 'textarea', 'tt', 'u', 'var']);
 
 // Elements that you can, intentionally, leave open
@@ -77,10 +77,10 @@ const closeSelf = new CaseInsensitiveSet(['colgroup', 'dd', 'dt', 'li', 'option'
 // Attributes that have their values filled in disabled='disabled'
 const fillAttrs = new CaseInsensitiveSet(['checked', 'compact', 'declare', 'defer', 'disabled', 'ismap', 'multiple', 'nohref', 'noresize', 'noshade', 'nowrap', 'readonly', 'selected']);
 
-// Special Elements (can contain anything)
+// Special elements (can contain anything)
 const special = new CaseInsensitiveSet(['script', 'style']);
 
-// HTML5 tags https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// HTML5 elements https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing Content https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
 const nonPhrasing = new CaseInsensitiveSet(['address', 'article', 'aside', 'base', 'blockquote', 'body', 'caption', 'col', 'colgroup', 'dd', 'details', 'dialog', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'legend', 'li', 'menuitem', 'meta', 'ol', 'optgroup', 'option', 'param', 'rp', 'rt', 'source', 'style', 'summary', 'tbody', 'td', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul']);
 
@@ -128,7 +128,7 @@ class HTMLParser {
     let last, prevTag, nextTag;
     while (html) {
       last = html;
-      // Make sure we're not in a script or style element
+      // Make sure we’re not in a `script` or `style` element
       if (!lastTag || !special.has(lastTag)) {
         let textEnd = html.indexOf('<');
         if (textEnd === 0) {
@@ -204,7 +204,7 @@ class HTMLParser {
           html = '';
         }
 
-        // next tag
+        // Next tag
         let nextTagMatch = parseStartTag(html);
         if (nextTagMatch) {
           nextTag = nextTagMatch.tagName;
@@ -317,9 +317,9 @@ class HTMLParser {
 
       const attrs = match.attrs.map(function (args) {
         let name, value, customOpen, customClose, customAssign, quote;
-        const ncp = 7; // number of captured parts, scalar
+        const ncp = 7; // Number of captured parts, scalar
 
-        // hackish work around FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778
+        // Hackish workaround for FF bug https://bugzilla.mozilla.org/show_bug.cgi?id=369778
         if (IS_REGEX_CAPTURING_BROKEN && args[0].indexOf('""') === -1) {
           if (args[3] === '') { delete args[3]; }
           if (args[4] === '') { delete args[4]; }
@@ -541,28 +541,28 @@ function collapseWhitespace(str, options, trimLeft, trimRight, collapseAll) {
   }
 
   if (collapseAll) {
-    // strip non space whitespace then compress spaces to one
+    // Strip non-space whitespace then compress spaces to one
     str = collapseWhitespaceAll(str);
   }
 
   return lineBreakBefore + str + lineBreakAfter;
 }
 
-// non-empty elements that will maintain whitespace around them
-const inlineHtmlElements = ['a', 'abbr', 'acronym', 'b', 'bdi', 'bdo', 'big', 'button', 'cite', 'code', 'del', 'dfn', 'em', 'font', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'mark', 'math', 'meter', 'nobr', 'object', 'output', 'progress', 'q', 'rp', 'rt', 'rtc', 'ruby', 's', 'samp', 'select', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'svg', 'textarea', 'time', 'tt', 'u', 'var', 'wbr'];
-// non-empty elements that will maintain whitespace within them
-const inlineTextTags = new Set(['a', 'abbr', 'acronym', 'b', 'big', 'del', 'em', 'font', 'i', 'ins', 'kbd', 'mark', 'nobr', 'rp', 's', 'samp', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'time', 'tt', 'u', 'var']);
-// self-closing elements that will maintain whitespace around them
-const selfClosingInlineTags = new Set(['comment', 'img', 'input', 'wbr']);
+// Non-empty elements that will maintain whitespace around them
+const inlineElementsToKeepWhitespaceAround = ['a', 'abbr', 'acronym', 'b', 'bdi', 'bdo', 'big', 'button', 'cite', 'code', 'del', 'dfn', 'em', 'font', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'mark', 'math', 'meter', 'nobr', 'object', 'output', 'progress', 'q', 'rp', 'rt', 'rtc', 'ruby', 's', 'samp', 'select', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'svg', 'textarea', 'time', 'tt', 'u', 'var', 'wbr'];
+// Non-empty elements that will maintain whitespace within them
+const inlineElementsToKeepWhitespaceWithin = new Set(['a', 'abbr', 'acronym', 'b', 'big', 'del', 'em', 'font', 'i', 'ins', 'kbd', 'mark', 'nobr', 'rp', 's', 'samp', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'time', 'tt', 'u', 'var']);
+// Elements that will always maintain whitespace around them
+const inlineElementsToKeepWhitespace = new Set(['comment', 'img', 'input', 'wbr']);
 
-function collapseWhitespaceSmart(str, prevTag, nextTag, options, inlineTags) {
-  let trimLeft = prevTag && !selfClosingInlineTags.has(prevTag);
+function collapseWhitespaceSmart(str, prevTag, nextTag, options, inlineElements, inlineTextSet) {
+  let trimLeft = prevTag && !inlineElementsToKeepWhitespace.has(prevTag);
   if (trimLeft && !options.collapseInlineTagWhitespace) {
-    trimLeft = prevTag.charAt(0) === '/' ? !inlineTags.has(prevTag.slice(1)) : !inlineTextTags.has(prevTag);
+    trimLeft = prevTag.charAt(0) === '/' ? !inlineElements.has(prevTag.slice(1)) : !inlineTextSet.has(prevTag);
   }
-  let trimRight = nextTag && !selfClosingInlineTags.has(nextTag);
+  let trimRight = nextTag && !inlineElementsToKeepWhitespace.has(nextTag);
   if (trimRight && !options.collapseInlineTagWhitespace) {
-    trimRight = nextTag.charAt(0) === '/' ? !inlineTextTags.has(nextTag.slice(1)) : !inlineTags.has(nextTag);
+    trimRight = nextTag.charAt(0) === '/' ? !inlineTextSet.has(nextTag.slice(1)) : !inlineElements.has(nextTag);
   }
   return collapseWhitespace(str, options, trimLeft, trimRight, prevTag && nextTag);
 }
@@ -749,7 +749,7 @@ function isSrcset(attrName, tag) {
   return attrName === 'srcset' && srcsetTags.has(tag);
 }
 
-async function cleanAttributeValue(tag, attrName, attrValue, options, attrs) {
+async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTMLSelf) {
   if (isEventAttribute(attrName, options)) {
     attrValue = trimWhitespace(attrValue).replace(/^javascript:\s*/i, '');
     return options.minifyJS(attrValue, true);
@@ -807,6 +807,13 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs) {
   } else if (isMediaQuery(tag, attrs, attrName)) {
     attrValue = trimWhitespace(attrValue);
     return options.minifyCSS(attrValue, 'media');
+  } else if (tag === 'iframe' && attrName === 'srcdoc') {
+    // Recursively minify HTML content within srcdoc attribute
+    // Fast-path: skip if nothing would change
+    if (!shouldMinifyInnerHTML(options)) {
+      return attrValue;
+    }
+    return minifyHTMLSelf(attrValue, options, true);
   }
   return attrValue;
 }
@@ -884,7 +891,7 @@ async function processScript(text, options, currentAttrs) {
 // Tag omission rules from https://html.spec.whatwg.org/multipage/syntax.html#optional-tags
 // with the following deviations:
 // - retain <body> if followed by <noscript>
-// - </rb>, </rt>, </rtc>, </rp> & </tfoot> follow https://www.w3.org/TR/html5/syntax.html#optional-tags
+// - </rb>, </rt>, </rtc>, </rp>, and </tfoot> follow https://www.w3.org/TR/html5/syntax.html#optional-tags
 // - retain all tags which are adjacent to non-standard HTML tags
 const optionalStartTags = new Set(['html', 'head', 'body', 'colgroup', 'tbody']);
 const optionalEndTags = new Set(['html', 'head', 'body', 'li', 'dt', 'dd', 'p', 'rb', 'rt', 'rtc', 'rp', 'optgroup', 'option', 'colgroup', 'caption', 'thead', 'tbody', 'tfoot', 'tr', 'td', 'th']);
@@ -1046,7 +1053,7 @@ async function normalizeAttr(attr, attrs, tag, options) {
   }
 
   if (attrValue) {
-    attrValue = await cleanAttributeValue(tag, attrName, attrValue, options, attrs);
+    attrValue = await cleanAttributeValue(tag, attrName, attrValue, options, attrs, minifyHTML);
   }
 
   if (options.removeEmptyAttributes &&
@@ -1094,7 +1101,7 @@ function buildAttr(normalized, hasUnarySlash, options, isLast, uidAttr) {
       emittedAttrValue += ' ';
     }
   } else if (isLast && !hasUnarySlash && !/\/$/.test(attrValue)) {
-    // make sure trailing slash is not interpreted as HTML self-closing tag
+    // Make sure trailing slash is not interpreted as HTML self-closing tag
     emittedAttrValue = attrValue;
   } else {
     emittedAttrValue = attrValue + ' ';
@@ -1121,6 +1128,17 @@ function identityAsync(value) {
   return Promise.resolve(value);
 }
 
+function shouldMinifyInnerHTML(options) {
+  return Boolean(
+    options.collapseWhitespace ||
+    options.removeComments ||
+    options.removeOptionalTags ||
+    options.minifyJS !== identity ||
+    options.minifyCSS !== identityAsync ||
+    options.minifyURLs !== identity
+  );
+}
+
 const processOptions = (inputOptions) => {
   const options = {
     name: function (name) {
@@ -1355,11 +1373,16 @@ async function minifyHTML(value, options, partialMarkup) {
   let uidIgnore;
   let uidAttr;
   let uidPattern;
-  let inlineTags = new Set([...inlineHtmlElements, ...(options.inlineCustomElements ?? [])]);
-
-  // temporarily replace ignored chunks with comments,
-  // so that we don't have to worry what's there.
-  // for all we care there might be
+  // Create inline tags/text sets with custom elements
+  const customElementsInput = options.inlineCustomElements ?? [];
+  const customElementsArr = Array.isArray(customElementsInput) ? customElementsInput : Array.from(customElementsInput);
+  const normalizedCustomElements = customElementsArr.map(name => options.name(name));
+  const inlineTextSet = new Set([...inlineElementsToKeepWhitespaceWithin, ...normalizedCustomElements]);
+  const inlineElements = new Set([...inlineElementsToKeepWhitespaceAround, ...normalizedCustomElements]);
+
+  // Temporarily replace ignored chunks with comments,
+  // so that we don’t have to worry what’s there.
+  // For all we care there might be
   // completely-horribly-broken-alien-non-html-emoj-cthulhu-filled content
   value = value.replace(/<!-- htmlmin:ignore -->([\s\S]*?)<!-- htmlmin:ignore -->/g, function (match, group1) {
     if (!uidIgnore) {
@@ -1480,20 +1503,20 @@ async function minifyHTML(value, options, partialMarkup) {
     buffer.length = Math.max(0, index);
   }
 
-  // look for trailing whitespaces, bypass any inline tags
+  // Look for trailing whitespaces, bypass any inline tags
   function trimTrailingWhitespace(index, nextTag) {
     for (let endTag = null; index >= 0 && _canTrimWhitespace(endTag); index--) {
       const str = buffer[index];
       const match = str.match(/^<\/([\w:-]+)>$/);
       if (match) {
         endTag = match[1];
-      } else if (/>$/.test(str) || (buffer[index] = collapseWhitespaceSmart(str, null, nextTag, options, inlineTags))) {
+      } else if (/>$/.test(str) || (buffer[index] = collapseWhitespaceSmart(str, null, nextTag, options, inlineElements, inlineTextSet))) {
         break;
       }
     }
   }
 
-  // look for trailing whitespaces from previously processed text
+  // Look for trailing whitespaces from previously processed text
   // which may not be trimmed due to a following comment or an empty
   // element which has now been removed
   function squashTrailingWhitespace(nextTag) {
@@ -1524,7 +1547,7 @@ async function minifyHTML(value, options, partialMarkup) {
       tag = options.name(tag);
       currentTag = tag;
       charsPrevTag = tag;
-      if (!inlineTextTags.has(tag)) {
+      if (!inlineTextSet.has(tag)) {
         currentChars = '';
       }
       hasChars = false;
@@ -1542,7 +1565,7 @@ async function minifyHTML(value, options, partialMarkup) {
           removeStartTag();
         }
         optionalStartTag = '';
-        // end-tag-followed-by-start-tag omission rules
+        // End-tag-followed-by-start-tag omission rules
         if (htmlTag && canRemovePrecedingTag(optionalEndTag, tag)) {
           removeEndTag();
           // <colgroup> cannot be omitted if preceding </colgroup> is omitted
@@ -1552,7 +1575,7 @@ async function minifyHTML(value, options, partialMarkup) {
         optionalEndTag = '';
       }
 
-      // set whitespace flags for nested tags (eg. <code> within a <pre>)
+      // Set whitespace flags for nested tags (eg. <code> within a <pre>)
       if (options.collapseWhitespace) {
         if (!stackNoTrimWhitespace.length) {
           squashTrailingWhitespace(tag);
@@ -1588,7 +1611,7 @@ async function minifyHTML(value, options, partialMarkup) {
         buffer.push(' ');
         buffer.push.apply(buffer, parts);
       } else if (optional && optionalStartTags.has(tag)) {
-        // start tag must never be omitted if it has any attributes
+        // Start tag must never be omitted if it has any attributes
         optionalStartTag = tag;
       }
 
@@ -1605,7 +1628,7 @@ async function minifyHTML(value, options, partialMarkup) {
       }
       tag = options.name(tag);
 
-      // check if current tag is in a whitespace stack
+      // Check if current tag is in a whitespace stack
       if (options.collapseWhitespace) {
         if (stackNoTrimWhitespace.length) {
           if (tag === stackNoTrimWhitespace[stackNoTrimWhitespace.length - 1]) {
@@ -1643,7 +1666,7 @@ async function minifyHTML(value, options, partialMarkup) {
       }
 
       if (options.removeEmptyElements && isElementEmpty && canRemoveElement(tag, attrs)) {
-        // remove last "element" from buffer
+        // Remove last “element” from buffer
         removeStartTag();
         optionalStartTag = '';
         optionalEndTag = '';
@@ -1654,7 +1677,7 @@ async function minifyHTML(value, options, partialMarkup) {
           buffer.push('</' + tag + '>');
         }
         charsPrevTag = '/' + tag;
-        if (!inlineTags.has(tag)) {
+        if (!inlineElements.has(tag)) {
           currentChars = '';
         } else if (isElementEmpty) {
           currentChars += '|';
@@ -1693,12 +1716,12 @@ async function minifyHTML(value, options, partialMarkup) {
                 }
                 trimTrailingWhitespace(tagIndex - 1, 'br');
               }
-            } else if (inlineTextTags.has(prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag)) {
+            } else if (inlineTextSet.has(prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag)) {
               text = collapseWhitespace(text, options, /(?:^|\s)$/.test(currentChars));
             }
           }
           if (prevTag || nextTag) {
-            text = collapseWhitespaceSmart(text, prevTag, nextTag, options, inlineTags);
+            text = collapseWhitespaceSmart(text, prevTag, nextTag, options, inlineElements, inlineTextSet);
           } else {
             text = collapseWhitespace(text, options, true, true);
           }
@@ -1768,7 +1791,7 @@ async function minifyHTML(value, options, partialMarkup) {
         text = prefix + text + suffix;
       }
       if (options.removeOptionalTags && text) {
-        // preceding comments suppress tag omissions
+        // Preceding comments suppress tag omissions
         optionalStartTag = '';
         optionalEndTag = '';
       }