html-minifier-next 1.2.0 → 1.3.2

package/README.md

@@ -1,11 +1,11 @@
-# HTML Minifier Next (HTMLMinifier)
+# HTML Minifier Next
 
 [![npm version](https://img.shields.io/npm/v/html-minifier-next.svg)](https://www.npmjs.com/package/html-minifier-next)
-<!-- [![Build Status](https://github.com/j9t/html-minifier-next/workflows/CI/badge.svg)](https://github.com/j9t/html-minifier-next/actions?workflow=CI) -->
+[![Build Status](https://github.com/j9t/html-minifier-next/workflows/CI/badge.svg)](https://github.com/j9t/html-minifier-next/actions?workflow=CI)
 
-(This project has been based on [Terser’s html-minifier-terser](https://github.com/terser/html-minifier-terser), which in turn had been based on [Juriy Zaytsev’s html-minifier](https://github.com/kangax/html-minifier). It was set up because as of 2025, both html-minifier-terser and html-minifier have been unmaintained for some time. As the project seems maintainable to me [[Jens](https://meiert.com/)]—even more so with community support—, it will be updated and documented further in this place. For the time being, the following documentation largely matches the original project.)
+HTML Minifier is a highly **configurable, well-tested, JavaScript-based HTML minifier**.
 
-HTMLMinifier is a highly **configurable, well-tested, JavaScript-based HTML minifier**.
+The project has been based on [Terser’s html-minifier-terser](https://github.com/terser/html-minifier-terser), which in turn had been based on [Juriy Zaytsev’s html-minifier](https://github.com/kangax/html-minifier). It was set up because as of 2025, both html-minifier-terser and html-minifier have been unmaintained for some time. As the project seems maintainable [to me, [Jens](https://meiert.com/)]—even more so with community support—, it will be updated and documented further in this place.
 
 ## Installation
 
@@ -25,14 +25,64 @@ npm i html-minifier-next
 
 **Note** that almost all options are disabled by default. Experiment and find what works best for you and your project.
 
-For command line usage please see `html-minifier-next --help` for a list of available options.
-
 **Sample command line:**
 
 ```bash
 html-minifier-next --collapse-whitespace --remove-comments --minify-js true --input-dir=. --output-dir=example
 ```
 
+**Process specific file extensions:**
+
+```bash
+# Process only HTML files (CLI method)
+html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist --file-ext=html
+
+# Process multiple file extensions (CLI method)
+html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist --file-ext=html,htm,php
+
+# Using configuration file with fileExt setting
+html-minifier-next --config-file=html-minifier.json --input-dir=src --output-dir=dist
+
+# Process all files (default behavior)
+html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist
+```
+
+### CLI Options
+
+Use `html-minifier-next --help` to check all available options:
+
+| Option | Description | Example |
+| --- | --- | --- |
+| `--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` |
+| `-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` |
+
+### Configuration Files
+
+You can also use a configuration file to specify options:
+
+**JSON configuration example:**
+
+```json
+{
+  "collapseWhitespace": true,
+  "removeComments": true,
+  "fileExt": "html,htm"
+}
+```
+
+**Using a configuration file:**
+
+```bash
+# Specify config file
+html-minifier-next --config-file=html-minifier.json --input-dir=src --output-dir=dist
+
+# CLI arguments override config file settings
+html-minifier-next --config-file=html-minifier.json --file-ext=xml --input-dir=src --output-dir=dist
+```
+
 ### Node.js
 
 ```js
@@ -41,7 +91,7 @@ const { minify } = require('html-minifier-next');
 const result = await minify('<p title="blah" id="moo">foo</p>', {
   removeAttributeQuotes: true,
 });
-result; // '<p title=blah id=moo>foo</p>'
+result; // “<p title=blah id=moo>foo</p>”
 ```
 
 See [the original blog post](http://perfectionkills.com/experimenting-with-html-minifier) for details of [how it works](http://perfectionkills.com/experimenting-with-html-minifier#how_it_works), [description of each option](http://perfectionkills.com/experimenting-with-html-minifier#options), [testing results](http://perfectionkills.com/experimenting-with-html-minifier#field_testing), and [conclusions](http://perfectionkills.com/experimenting-with-html-minifier#cost_and_benefits).
@@ -50,10 +100,10 @@ For lint-like capabilities take a look at [HTMLLint](https://github.com/kangax/h
 
 ## Minification comparison
 
-How does HTMLMinifier compare to other solutions, like [minimize](https://github.com/Swaagie/minimize) or [htmlcompressor.com](http://htmlcompressor.com/)?
+How does HTML Minifier compare to other solutions, like [minimize](https://github.com/Swaagie/minimize) or [htmlcompressor.com](http://htmlcompressor.com/)?
 
-| Site | Original size (KB) | HTMLMinifier | minimize | htmlcompressor.com |
-| --- | --- | --- | --- | --- |
+| Site | Original size (KB) | HTML Minifier | minimize | htmlcompressor.com |
+| --- | --- |---------------| --- | --- |
 | [A List Apart](https://alistapart.com/) | 64 | **54** | 59 | 57 |
 | [Amazon](https://www.amazon.com/) | 206 | **195** | 203 | 200 |
 | [BBC](https://www.bbc.co.uk/) | 767 | **703** | 761 | n/a |
@@ -63,7 +113,7 @@ How does HTMLMinifier compare to other solutions, like [minimize](https://github
 | [FAZ](https://www.faz.net/aktuell/) | 1767 | **1641** | 1679 | n/a |
 | [Frontend Dogma](https://frontenddogma.com/) | 119 | **114** | 128 | 118 |
 | [Google](https://www.google.com/) | 51 | **46** | 50 | 50 |
-| [HTMLMinifier](https://github.com/kangax/html-minifier) | 373 | **250** | 349 | n/a |
+| [HTML Minifier](https://github.com/kangax/html-minifier) | 373 | **250** | 349 | n/a |
 | [Mastodon](https://mastodon.social/explore) | 37 | **28** | 36 | 36 |
 | [NBC](https://www.nbc.com/) | 601 | **549** | 593 | n/a |
 | [New York Times](https://www.nytimes.com/) | 822 | **701** | 811 | n/a |
@@ -77,22 +127,23 @@ Most of the options are disabled by default.
 
 | Option | Description | Default |
 | --- | --- | --- |
-| `caseSensitive` | Treat attributes in case sensitive manner (useful for custom HTML tags) | `false` |
+| `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>'`) | `[ ]` |
+| `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}}>`) | `[ ]` |
+| `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` |
+| `fileExt` | File extensions to process | `[]` (process all files) |
 | `html5` | Parse input according to HTML5 specifications | `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]*?\?>/ ]` |
-| `includeAutoGeneratedTags` | Insert tags generated by HTML parser | `true` |
+| `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` |
 | `maxInputLength` | Maximum input length to prevent ReDoS attacks (disabled by default) | `undefined` |
@@ -104,7 +155,7 @@ Most of the options are disabled by default.
 | `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` |
 | `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.) | `[ ]` |
+| `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` |
@@ -112,8 +163,8 @@ Most of the options are disabled by default.
 | `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` tags. Other `type` attribute values are left intact | `false` |
-| `removeStyleLinkTypeAttributes`| Remove `type="text/css"` from `style` and `link` tags. Other `type` attribute values are left intact | `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` |
@@ -132,31 +183,19 @@ If you have chunks of markup you would like preserved, you can wrap them `<!-- h
 
 ### Minifying JSON-LD
 
-You can minify script tags 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 the option `{ processScripts: ['application/ld+json'] }`. Note that this minification is very rudimentary, it is mainly useful for removing newlines and excessive whitespace. 
 
-### Preserving SVG tags
+### Preserving SVG elements
 
-SVG tags 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.
+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
 
-HTMLMinifier **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)
-
-↓
+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.
 
-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>`)
 
-HTMLMinifier 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 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.
 
 ## Security
 
@@ -233,4 +272,4 @@ npm run serve
 
 ## Acknowledgements
 
-With many thanks to all the previous authors of HTML Minifier, especially [Juriy Zaytsev](https://github.com/kangax), and to everyone who helped make this new edition better, like [Daniel Ruf](https://github.com/DanielRuf).
+With many thanks to all the previous authors of HTML Minifier, especially [Juriy Zaytsev](https://github.com/kangax), and to everyone who helped make this new edition better, like [Daniel Ruf](https://github.com/DanielRuf).

package/cli.js

@@ -141,7 +141,7 @@ const mainOptions = {
   useShortDoctype: 'Replaces the doctype with the short (HTML5) doctype'
 };
 
-// configure commandline flags
+// Configure command line flags
 const mainOptionKeys = Object.keys(mainOptions);
 mainOptionKeys.forEach(function (key) {
   const option = mainOptions[key];
@@ -186,10 +186,18 @@ program.option('-c --config-file <file>', 'Use config file', function (configPat
       }
     }
   });
+
+  // Handle fileExt in config file
+  if ('fileExt' in config) {
+    // Support both string (`html,htm`) and array (`["html", "htm"]`) formats
+    if (Array.isArray(config.fileExt)) {
+      config.fileExt = config.fileExt.join(',');
+    }
+  }
 });
 program.option('--input-dir <dir>', 'Specify an input directory');
 program.option('--output-dir <dir>', 'Specify an output directory');
-program.option('--file-ext <text>', 'Specify an extension to be read, ex: html');
+program.option('--file-ext <text>', 'Specify file extension(s) to be read, e.g. “html” or “html,htm”');
 
 let content;
 program.arguments('[files...]').action(function (files) {
@@ -241,7 +249,28 @@ function processFile(inputFile, outputFile) {
   });
 }
 
+function parseFileExtensions(fileExt) {
+  if (!fileExt) {
+    return [];
+  }
+  return fileExt
+    .split(',')
+    .map(ext => ext.trim().replace(/^\.+/, '').toLowerCase())
+    .filter(ext => ext.length > 0);
+}
+
+function shouldProcessFile(filename, fileExtensions) {
+  if (fileExtensions.length === 0) {
+    return true; // No extensions specified, process all files
+  }
+
+  const fileExt = path.extname(filename).replace(/^\.+/, '').toLowerCase();
+  return fileExtensions.includes(fileExt);
+}
+
 function processDirectory(inputDir, outputDir, fileExt) {
+  const extensions = parseFileExtensions(fileExt);
+
   fs.readdir(inputDir, function (err, files) {
     if (err) {
       fatal('Cannot read directory ' + inputDir + '\n' + err.message);
@@ -256,7 +285,7 @@ function processDirectory(inputDir, outputDir, fileExt) {
           fatal('Cannot read ' + inputFile + '\n' + err.message);
         } else if (stat.isDirectory()) {
           processDirectory(inputFile, outputFile, fileExt);
-        } else if (!fileExt || path.extname(file) === '.' + fileExt) {
+        } else if (shouldProcessFile(file, extensions)) {
           mkdir(outputDir, function () {
             processFile(inputFile, outputFile);
           });
@@ -290,13 +319,16 @@ const writeMinify = async () => {
 
 const { inputDir, outputDir, fileExt } = programOptions;
 
+// Resolve file extensions: CLI argument takes priority over config file
+const resolvedFileExt = fileExt || config.fileExt;
+
 if (inputDir || outputDir) {
   if (!inputDir) {
     fatal('The option output-dir needs to be used with the option input-dir. If you are working with a single file, use -o.');
   } else if (!outputDir) {
     fatal('You need to specify where to write the output files with the option --output-dir');
   }
-  processDirectory(inputDir, outputDir, fileExt);
+  processDirectory(inputDir, outputDir, resolvedFileExt);
 } else if (content) { // Minifying one or more files specified on the CMD line
   writeMinify();
 } else { // Minifying input coming from STDIN
@@ -305,4 +337,4 @@ if (inputDir || outputDir) {
   process.stdin.on('data', function (data) {
     content += data;
   }).on('end', writeMinify);
-}
+}

package/package.json

@@ -22,14 +22,14 @@
     "@rollup/plugin-terser": "^0.4.4",
     "alpinejs": "^3.14.9",
     "commitlint-config-non-conventional": "^1.0.1",
-    "eslint": "^9.32.0",
+    "eslint": "^9.33.0",
     "husky": "^9.1.7",
     "is-ci": "^4.1.0",
     "jest": "^30.0.5",
     "lint-staged": "^16.1.5",
-    "rollup": "^4.45.1",
+    "rollup": "^4.46.2",
     "rollup-plugin-polyfill-node": "^0.13.0",
-    "vite": "^7.0.5"
+    "vite": "^7.1.2"
   },
   "exports": {
     ".": {
@@ -71,6 +71,11 @@
   "main": "./dist/htmlminifier.cjs",
   "module": "./src/htmlminifier.js",
   "name": "html-minifier-next",
+  "overrides": {
+    "glob": "^10.0.0",
+    "inflight": "npm:@nodelib/fs.stat@^3.0.0"
+  },
+  "overrides_comment": "@@ Remove when Jest fixes deprecated glob@7.2.3 and inflight dependencies",
   "repository": "https://github.com/j9t/html-minifier-next.git",
   "scripts": {
     "build": "rollup -c",
@@ -83,5 +88,5 @@
     "test:watch": "NODE_OPTIONS='--experimental-vm-modules --no-warnings' jest --watch"
   },
   "type": "module",
-  "version": "1.2.0"
+  "version": "1.3.2"
 }

package/src/htmlminifier.js

@@ -52,28 +52,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);
 }
@@ -395,7 +395,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']);
@@ -605,7 +605,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 + ' ';
@@ -866,14 +866,16 @@ async function minifyHTML(value, options, partialMarkup) {
   let uidIgnore;
   let uidAttr;
   let uidPattern;
-  // Create inline tags set with backward compatibility for inlineCustomTags
-  const customElements = options.inlineCustomElements ?? options.inlineCustomTags ?? [];
-  const normalizedCustomElements = customElements.map(name => options.name(name));
-  let inlineTags = new Set([...inlineHtmlElements, ...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
+  // 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) {
@@ -994,20 +996,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) {
@@ -1038,7 +1040,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;
@@ -1056,7 +1058,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
@@ -1066,7 +1068,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);
@@ -1102,7 +1104,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;
       }
 
@@ -1119,7 +1121,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]) {
@@ -1157,7 +1159,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 = '';
@@ -1168,7 +1170,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 += '|';
@@ -1207,12 +1209,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);
           }
@@ -1282,7 +1284,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 = '';
       }
@@ -1386,4 +1388,4 @@ export const minify = async function (value, options) {
   return result;
 };
 
-export default { minify };
+export default { minify };

package/src/htmlparser.js

@@ -131,7 +131,7 @@ export 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) {
@@ -207,7 +207,7 @@ export class HTMLParser {
           html = '';
         }
 
-        // next tag
+        // Next tag
         let nextTagMatch = parseStartTag(html);
         if (nextTagMatch) {
           nextTag = nextTagMatch.tagName;
@@ -320,9 +320,9 @@ export 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]; }
@@ -512,13 +512,13 @@ export const HTMLtoDOM = (html, doc) => {
     }
   }
 
-  // If we're working with a document, inject contents into
-  // the body element
+  // If we’re working with a document, inject contents into
+  // the `body` element
   let curParentNode = one.body;
 
   const parser = new HTMLParser(html, {
     start: function (tagName, attrs, unary) {
-      // If it's a pre-built element, then we can ignore
+      // If it’s a pre-built element, then we can ignore
       // its construction
       if (one[tagName]) {
         curParentNode = one[tagName];
@@ -552,7 +552,7 @@ export const HTMLtoDOM = (html, doc) => {
       curParentNode.appendChild(doc.createTextNode(text));
     },
     comment: function (/* text */) {
-      // create comment node
+      // Create comment node
     },
     ignore: function (/* text */) {
       // What to do here?
@@ -562,4 +562,4 @@ export const HTMLtoDOM = (html, doc) => {
   parser.parse();
 
   return doc;
-};
+};