html-minifier-next 4.14.0 → 4.14.3

package/README.md

@@ -14,6 +14,12 @@ From npm for use as a command line app:
 npm i -g html-minifier-next
 ```
 
+Or use directly with npx (no installation required):
+
+```shell
+npx html-minifier-next --help
+```
+
 From npm for programmatic use:
 
 ```shell
@@ -67,7 +73,7 @@ module.exports = {
 
 **Using a configuration file:**
 
-```bash
+```shell
 # Specify config file
 html-minifier-next --config-file=html-minifier.json --input-dir=src --output-dir=dist
 
@@ -116,7 +122,7 @@ To review the specific options set, [presets.js](https://github.com/j9t/html-min
 
 **Using presets:**
 
-```bash
+```shell
 # Via CLI flag
 html-minifier-next --preset conservative input.html
 
@@ -237,7 +243,7 @@ You can choose between different JS minifiers using the `engine` field:
 ```js
 const result = await minify(html, {
   minifyJS: {
-    engine: 'swc', // Use swc for faster minification
+    engine: 'swc', // Use SWC for faster minification
     // SWC-specific options here
   }
 });
@@ -248,12 +254,14 @@ const result = await minify(html, {
 * `terser` (default): The standard JavaScript minifier with excellent compression
 * [`swc`](https://swc.rs/): Rust-based minifier that’s significantly faster than Terser (requires separate installation)
 
-**To use swc**, install it as a dependency:
+**To use SWC**, install it as a dependency:
 
-```bash
+```shell
 npm i @swc/core
 ```
 
+(Build-only users may want to install it as a dev dependency: `npm i -D @swc/core`.)
+
 **Important:** Inline event handlers (e.g., `onclick="return false"`) always use Terser regardless of the `engine` setting, as SWC doesn’t support bare return statements. This is handled automatically—you don’t need to do anything special.
 
 You can pass engine-specific configuration options:
@@ -297,31 +305,33 @@ How does HTML Minifier Next compare to other minifiers? (All with the most aggre
 | --- | --- | --- | --- | --- | --- | --- | --- | --- |
 | [A List Apart](https://alistapart.com/) | 59 | **50** | **50** | 51 | 52 | 51 | 54 | 52 |
 | [Apple](https://www.apple.com/) | 266 | **207** | **207** | 236 | 239 | 240 | 242 | 243 |
-| [BBC](https://www.bbc.co.uk/) | 701 | **636** | 646 | 658 | 659 | 660 | 695 | n/a |
-| [CERN](https://home.cern/) | 152 | 85 | **84** | 91 | 91 | 91 | 93 | 96 |
-| [CSS-Tricks](https://css-tricks.com/) | 162 | 121 | **120** | 127 | 143 | 143 | 148 | 145 |
-| [ECMAScript](https://tc39.es/ecma262/) | 7250 | **6352** | **6352** | 6573 | 6455 | 6578 | 6626 | n/a |
+| [BBC](https://www.bbc.co.uk/) | 727 | **661** | 671 | 683 | 683 | 685 | 721 | n/a |
+| [CERN](https://home.cern/) | 152 | **83** | 84 | 91 | 91 | 91 | 93 | 96 |
+| [CSS-Tricks](https://css-tricks.com/) | 162 | 122 | **120** | 127 | 143 | 143 | 148 | 145 |
+| [ECMAScript](https://tc39.es/ecma262/) | 7250 | **6354** | **6354** | 6573 | 6455 | 6578 | 6626 | n/a |
 | [EDRi](https://edri.org/) | 80 | **59** | 60 | 70 | 70 | 71 | 75 | 73 |
-| [EFF](https://www.eff.org/) | 55 | **45** | 46 | 49 | 48 | 48 | 50 | 50 |
+| [EFF](https://www.eff.org/) | 55 | **45** | 47 | 49 | 48 | 48 | 50 | 50 |
 | [European Alternatives](https://european-alternatives.eu/) | 48 | **30** | **30** | 32 | 32 | 32 | 32 | 32 |
-| [FAZ](https://www.faz.net/aktuell/) | 1603 | 1494 | 1499 | **1437** | 1526 | 1538 | 1549 | n/a |
+| [FAZ](https://www.faz.net/aktuell/) | 1591 | 1486 | 1491 | **1427** | 1515 | 1526 | 1538 | n/a |
 | [French Tech](https://lafrenchtech.gouv.fr/) | 152 | **122** | **122** | 126 | 125 | 125 | 132 | 127 |
-| [Frontend Dogma](https://frontenddogma.com/) | 224 | **214** | 216 | 237 | 222 | 224 | 243 | 223 |
+| [Frontend Dogma](https://frontenddogma.com/) | 224 | **214** | 216 | 237 | 222 | 224 | 243 | 224 |
 | [Google](https://www.google.com/) | 18 | **16** | 17 | 17 | 17 | 17 | 18 | 18 |
-| [Ground News](https://ground.news/) | 1713 | **1476** | 1477 | 1577 | 1602 | 1607 | 1699 | n/a |
+| [Ground News](https://ground.news/) | 2358 | **2076** | 2077 | 2173 | 2198 | 2202 | 2345 | n/a |
 | [HTML Living Standard](https://html.spec.whatwg.org/multipage/) | 149 | **147** | **147** | 153 | **147** | 149 | 155 | 149 |
 | [Igalia](https://www.igalia.com/) | 50 | **34** | **34** | 36 | 36 | 36 | 37 | 37 |
+| [Leanpub](https://leanpub.com/) | 222 | 192 | **191** | 207 | 207 | 207 | 217 | 219 |
 | [Mastodon](https://mastodon.social/explore) | 37 | **28** | **28** | 32 | 35 | 35 | 36 | 36 |
 | [MDN](https://developer.mozilla.org/en-US/) | 109 | **62** | **62** | 64 | 65 | 65 | 68 | 68 |
-| [Middle East Eye](https://www.middleeasteye.net/) | 222 | **195** | **195** | 202 | 200 | 200 | 202 | 203 |
+| [Middle East Eye](https://www.middleeasteye.net/) | 222 | **196** | **196** | 202 | 200 | 200 | 202 | 203 |
 | [Nielsen Norman Group](https://www.nngroup.com/) | 86 | 74 | 74 | **55** | 74 | 75 | 77 | 76 |
-| [SitePoint](https://www.sitepoint.com/) | 501 | **370** | **370** | 442 | 475 | 480 | 498 | n/a |
+| [SitePoint](https://www.sitepoint.com/) | 491 | **360** | **360** | 431 | 465 | 470 | 488 | n/a |
 | [TetraLogical](https://tetralogical.com/) | 44 | 38 | 38 | **35** | 38 | 39 | 39 | 39 |
 | [TPGi](https://www.tpgi.com/) | 175 | **159** | 161 | 160 | 164 | 166 | 172 | 172 |
+| [United Nations](https://www.un.org/en/) | 152 | **113** | 114 | 121 | 125 | 125 | 131 | 124 |
 | [W3C](https://www.w3.org/) | 50 | **36** | **36** | 39 | 38 | 38 | 41 | 39 |
-| **Average processing time** |  | 256 ms (24/24) | 352 ms (24/24) | 167 ms (24/24) | 54 ms (24/24) | **15 ms (24/24)** | 339 ms (24/24) | 3288 ms (19/24) |
+| **Average processing time** |  | 259 ms (26/26) | 375 ms (26/26) | 164 ms (26/26) | 54 ms (26/26) | **16 ms (26/26)** | 327 ms (26/26) | 1497 ms (21/26) |
 
-(Last updated: Dec 20, 2025)
+(Last updated: Dec 21, 2025)
 <!-- End auto-generated -->
 
 ## Examples
@@ -330,13 +340,19 @@ How does HTML Minifier Next compare to other minifiers? (All with the most aggre
 
 **Sample command line:**
 
-```bash
+```shell
 html-minifier-next --collapse-whitespace --remove-comments --minify-js --input-dir=. --output-dir=example
 ```
 
+Another example, using npx:
+
+```shell
+npx html-minifier-next --input-dir=test --file-ext html --preset comprehensive --output-dir example
+```
+
 **Process specific files and directories:**
 
-```bash
+```shell
 # Process only HTML files
 html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist --file-ext=html
 
@@ -354,7 +370,7 @@ html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist
 
 **Exclude directories from processing:**
 
-```bash
+```shell
 # Ignore a single directory
 html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist --ignore-dir=libs
 
@@ -367,7 +383,7 @@ html-minifier-next --collapse-whitespace --input-dir=src --output-dir=dist --ign
 
 **Dry run mode (preview outcome without writing files):**
 
-```bash
+```shell
 # Preview with output file
 html-minifier-next input.html -o output.html --dry --collapse-whitespace
 
@@ -382,7 +398,7 @@ html-minifier-next --input-dir=src --output-dir=dist --dry --collapse-whitespace
 
 **Verbose mode (show detailed processing information):**
 
-```bash
+```shell
 # Show processing details while minifying
 html-minifier-next --input-dir=src --output-dir=dist --verbose --collapse-whitespace
 # Output: Options: collapseWhitespace, html5, includeAutoGeneratedTags

package/dist/htmlminifier.cjs

@@ -928,10 +928,13 @@ const tagDefaults = {
     colorspace: 'limited-srgb',
     type: 'text'
   },
+  link: { media: 'all' },
   marquee: {
     behavior: 'scroll',
     direction: 'left'
   },
+  meta: { media: 'all' },
+  source: { media: 'all' },
   style: { media: 'all' },
   textarea: { wrap: 'soft' },
   track: { kind: 'subtitles' }
@@ -1132,10 +1135,24 @@ function collapseWhitespaceSmart(str, prevTag, nextTag, options, inlineElements,
   if (trimLeft && !options.collapseInlineTagWhitespace) {
     trimLeft = prevTag.charAt(0) === '/' ? !inlineElements.has(prevTag.slice(1)) : !inlineTextSet.has(prevTag);
   }
+  // When `collapseInlineTagWhitespace` is enabled, still preserve whitespace around inline text elements
+  if (trimLeft && options.collapseInlineTagWhitespace) {
+    const tagName = prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag;
+    if (inlineElementsToKeepWhitespaceWithin.has(tagName)) {
+      trimLeft = false;
+    }
+  }
   let trimRight = nextTag && !inlineElementsToKeepWhitespace.has(nextTag);
   if (trimRight && !options.collapseInlineTagWhitespace) {
     trimRight = nextTag.charAt(0) === '/' ? !inlineTextSet.has(nextTag.slice(1)) : !inlineElements.has(nextTag);
   }
+  // When `collapseInlineTagWhitespace` is enabled, still preserve whitespace around inline text elements
+  if (trimRight && options.collapseInlineTagWhitespace) {
+    const tagName = nextTag.charAt(0) === '/' ? nextTag.slice(1) : nextTag;
+    if (inlineElementsToKeepWhitespaceWithin.has(tagName)) {
+      trimRight = false;
+    }
+  }
   return collapseWhitespace(str, options, trimLeft, trimRight, prevTag && nextTag);
 }
 
@@ -1782,6 +1799,11 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
       }
       try {
         attrValue = await options.minifyCSS(attrValue, 'inline');
+        // After minification, check if CSS consists entirely of invalid properties (no values)
+        // E.g., `color:` or `margin:;padding:` should be treated as empty
+        if (attrValue && /^(?:[a-z-]+:\s*;?\s*)+$/i.test(attrValue)) {
+          attrValue = '';
+        }
       } catch (err) {
         if (!options.continueOnMinifyError) {
           throw err;
@@ -1830,6 +1852,11 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
     attrValue = trimWhitespace(attrValue.replace(/\s*;\s*/g, ';'));
   } else if (isMediaQuery(tag, attrs, attrName)) {
     attrValue = trimWhitespace(attrValue);
+    // Only minify actual media queries (those with features in parentheses)
+    // Skip simple media types like `all`, `screen`, `print` which are already minimal
+    if (!/[()]/.test(attrValue)) {
+      return attrValue;
+    }
     try {
       return await options.minifyCSS(attrValue, 'media');
     } catch (err) {

package/dist/htmlminifier.esm.bundle.js

@@ -3540,10 +3540,13 @@ const tagDefaults = {
     colorspace: 'limited-srgb',
     type: 'text'
   },
+  link: { media: 'all' },
   marquee: {
     behavior: 'scroll',
     direction: 'left'
   },
+  meta: { media: 'all' },
+  source: { media: 'all' },
   style: { media: 'all' },
   textarea: { wrap: 'soft' },
   track: { kind: 'subtitles' }
@@ -3744,10 +3747,24 @@ function collapseWhitespaceSmart(str, prevTag, nextTag, options, inlineElements,
   if (trimLeft && !options.collapseInlineTagWhitespace) {
     trimLeft = prevTag.charAt(0) === '/' ? !inlineElements.has(prevTag.slice(1)) : !inlineTextSet.has(prevTag);
   }
+  // When `collapseInlineTagWhitespace` is enabled, still preserve whitespace around inline text elements
+  if (trimLeft && options.collapseInlineTagWhitespace) {
+    const tagName = prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag;
+    if (inlineElementsToKeepWhitespaceWithin.has(tagName)) {
+      trimLeft = false;
+    }
+  }
   let trimRight = nextTag && !inlineElementsToKeepWhitespace.has(nextTag);
   if (trimRight && !options.collapseInlineTagWhitespace) {
     trimRight = nextTag.charAt(0) === '/' ? !inlineTextSet.has(nextTag.slice(1)) : !inlineElements.has(nextTag);
   }
+  // When `collapseInlineTagWhitespace` is enabled, still preserve whitespace around inline text elements
+  if (trimRight && options.collapseInlineTagWhitespace) {
+    const tagName = nextTag.charAt(0) === '/' ? nextTag.slice(1) : nextTag;
+    if (inlineElementsToKeepWhitespaceWithin.has(tagName)) {
+      trimRight = false;
+    }
+  }
   return collapseWhitespace(str, options, trimLeft, trimRight, prevTag && nextTag);
 }
 
@@ -6924,6 +6941,11 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
       }
       try {
         attrValue = await options.minifyCSS(attrValue, 'inline');
+        // After minification, check if CSS consists entirely of invalid properties (no values)
+        // E.g., `color:` or `margin:;padding:` should be treated as empty
+        if (attrValue && /^(?:[a-z-]+:\s*;?\s*)+$/i.test(attrValue)) {
+          attrValue = '';
+        }
       } catch (err) {
         if (!options.continueOnMinifyError) {
           throw err;
@@ -6972,6 +6994,11 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
     attrValue = trimWhitespace(attrValue.replace(/\s*;\s*/g, ';'));
   } else if (isMediaQuery(tag, attrs, attrName)) {
     attrValue = trimWhitespace(attrValue);
+    // Only minify actual media queries (those with features in parentheses)
+    // Skip simple media types like `all`, `screen`, `print` which are already minimal
+    if (!/[()]/.test(attrValue)) {
+      return attrValue;
+    }
     try {
       return await options.minifyCSS(attrValue, 'media');
     } catch (err) {

package/dist/types/lib/attributes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../src/lib/attributes.js"],"names":[],"mappings":"AAsBA,yDAEC;AAED,mEAOC;AAED,uEAWC;AAED,8DAGC;AAED,4EAOC;AAED,mGAqBC;AAED,mEAGC;AAED,qEAGC;AAED,kEAWC;AAED,sEAGC;AAED,4DAWC;AAED,2EAEC;AAED,qEAaC;AAED,wEAUC;AAED,sEAUC;AAED,2EAEC;AAED,2DAEC;AAED,8DAUC;AAED,uEAUC;AAED,oGASC;AAED,4DAOC;AAID,0IAqHC;AAsBD;;;;GAsCC;AAED,6GA4EC"}
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../src/lib/attributes.js"],"names":[],"mappings":"AAsBA,yDAEC;AAED,mEAOC;AAED,uEAWC;AAED,8DAGC;AAED,4EAOC;AAED,mGAqBC;AAED,mEAGC;AAED,qEAGC;AAED,kEAWC;AAED,sEAGC;AAED,4DAWC;AAED,2EAEC;AAED,qEAaC;AAED,wEAUC;AAED,sEAUC;AAED,2EAEC;AAED,2DAEC;AAED,8DAUC;AAED,uEAUC;AAED,oGASC;AAED,4DAOC;AAID,0IA+HC;AAsBD;;;;GAsCC;AAED,6GA4EC"}

package/dist/types/lib/constants.d.ts

@@ -41,12 +41,24 @@ export namespace tagDefaults {
         let type_1: string;
         export { type_1 as type };
     }
+    namespace link {
+        let media: string;
+    }
     namespace marquee {
         let behavior: string;
         let direction: string;
     }
+    namespace meta {
+        let media_1: string;
+        export { media_1 as media };
+    }
+    namespace source {
+        let media_2: string;
+        export { media_2 as media };
+    }
     namespace style {
-        let media: string;
+        let media_3: string;
+        export { media_3 as media };
     }
     namespace textarea {
         let wrap: string;

package/dist/types/lib/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/lib/constants.js"],"names":[],"mappings":"AAEA,iCAAoC;AACpC,+BAAkC;AAClC,oCAA2C;AAC3C,2CAAmD;AACnD,wCAA8C;AAC9C,4CAAkD;AAClD,4CAA2C;AAC3C,4CAA0D;AAC1D,2CAA8C;AAC9C,+CAA0D;AAC1D,2CAAmC;AACnC,mCAA4C;AAK5C,+DAAgb;AAGhb,+DAA6O;AAG7O,yDAAmF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCnF,qDAQG;AAEH,+CAEG;AAcH,0CAUG;AApBH,0CAAwhB;AAExhB,yCAAkD;AAIlD,qCAA8C;AAuB9C,4CAAiF;AAEjF,0CAAoM;AAEpM,qCAAwF;AAExF,0CAA8C;AAE9C,qCAA6S;AAE7S,sCAAsF;AAEtF,6CAA8D;AAE9D,gDAAqD;AAErD,oCAAkD;AAElD,2CAAqD;AAErD,2CAA8D;AAE9D,mCAAuC;AAEvC,uCAAuD;AAEvD,sCAA8C;AAE9C,oCAA2D;AAE3D,uCAA8C;AAE9C,mCAA+wC;AAI/wC,sCAEsD;AAItD,6CAAwD"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/lib/constants.js"],"names":[],"mappings":"AAEA,iCAAoC;AACpC,+BAAkC;AAClC,oCAA2C;AAC3C,2CAAmD;AACnD,wCAA8C;AAC9C,4CAAkD;AAClD,4CAA2C;AAC3C,4CAA0D;AAC1D,2CAA8C;AAC9C,+CAA0D;AAC1D,2CAAmC;AACnC,mCAA4C;AAK5C,+DAAgb;AAGhb,+DAA6O;AAG7O,yDAAmF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CnF,qDAQG;AAEH,+CAEG;AAcH,0CAUG;AApBH,0CAAwhB;AAExhB,yCAAkD;AAIlD,qCAA8C;AAuB9C,4CAAiF;AAEjF,0CAAoM;AAEpM,qCAAwF;AAExF,0CAA8C;AAE9C,qCAA6S;AAE7S,sCAAsF;AAEtF,6CAA8D;AAE9D,gDAAqD;AAErD,oCAAkD;AAElD,2CAAqD;AAErD,2CAA8D;AAE9D,mCAAuC;AAEvC,uCAAuD;AAEvD,sCAA8C;AAE9C,oCAA2D;AAE3D,uCAA8C;AAE9C,mCAA+wC;AAI/wC,sCAEsD;AAItD,6CAAwD"}

package/dist/types/lib/whitespace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"whitespace.d.ts","sourceRoot":"","sources":["../../../src/lib/whitespace.js"],"names":[],"mappings":"AAeA,8CAOC;AAID,qDAgBC;AAID,iHAyDC;AAID,0IAUC;AAID,yDAEC;AAED,qDAEC"}
+{"version":3,"file":"whitespace.d.ts","sourceRoot":"","sources":["../../../src/lib/whitespace.js"],"names":[],"mappings":"AAgBA,8CAOC;AAID,qDAgBC;AAID,iHAyDC;AAID,0IAwBC;AAID,yDAEC;AAED,qDAEC"}

package/package.json

@@ -93,5 +93,5 @@
     "test:watch": "node --test --watch tests/*.spec.js"
   },
   "type": "module",
-  "version": "4.14.0"
+  "version": "4.14.3"
 }

package/src/lib/attributes.js

@@ -272,6 +272,11 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
       }
       try {
         attrValue = await options.minifyCSS(attrValue, 'inline');
+        // After minification, check if CSS consists entirely of invalid properties (no values)
+        // E.g., `color:` or `margin:;padding:` should be treated as empty
+        if (attrValue && /^(?:[a-z-]+:\s*;?\s*)+$/i.test(attrValue)) {
+          attrValue = '';
+        }
       } catch (err) {
         if (!options.continueOnMinifyError) {
           throw err;
@@ -320,6 +325,11 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
     attrValue = trimWhitespace(attrValue.replace(/\s*;\s*/g, ';'));
   } else if (isMediaQuery(tag, attrs, attrName)) {
     attrValue = trimWhitespace(attrValue);
+    // Only minify actual media queries (those with features in parentheses)
+    // Skip simple media types like `all`, `screen`, `print` which are already minimal
+    if (!/[()]/.test(attrValue)) {
+      return attrValue;
+    }
     try {
       return await options.minifyCSS(attrValue, 'media');
     } catch (err) {

package/src/lib/constants.js

@@ -48,10 +48,13 @@ const tagDefaults = {
     colorspace: 'limited-srgb',
     type: 'text'
   },
+  link: { media: 'all' },
   marquee: {
     behavior: 'scroll',
     direction: 'left'
   },
+  meta: { media: 'all' },
+  source: { media: 'all' },
   style: { media: 'all' },
   textarea: { wrap: 'soft' },
   track: { kind: 'subtitles' }

package/src/lib/whitespace.js

@@ -8,7 +8,8 @@ import {
   RE_NBSP_LEAD_GROUP,
   RE_NBSP_TRAILING_GROUP,
   RE_NBSP_TRAILING_STRIP,
-  inlineElementsToKeepWhitespace
+  inlineElementsToKeepWhitespace,
+  inlineElementsToKeepWhitespaceWithin
 } from './constants.js';
 
 // Trim whitespace
@@ -110,10 +111,24 @@ function collapseWhitespaceSmart(str, prevTag, nextTag, options, inlineElements,
   if (trimLeft && !options.collapseInlineTagWhitespace) {
     trimLeft = prevTag.charAt(0) === '/' ? !inlineElements.has(prevTag.slice(1)) : !inlineTextSet.has(prevTag);
   }
+  // When `collapseInlineTagWhitespace` is enabled, still preserve whitespace around inline text elements
+  if (trimLeft && options.collapseInlineTagWhitespace) {
+    const tagName = prevTag.charAt(0) === '/' ? prevTag.slice(1) : prevTag;
+    if (inlineElementsToKeepWhitespaceWithin.has(tagName)) {
+      trimLeft = false;
+    }
+  }
   let trimRight = nextTag && !inlineElementsToKeepWhitespace.has(nextTag);
   if (trimRight && !options.collapseInlineTagWhitespace) {
     trimRight = nextTag.charAt(0) === '/' ? !inlineTextSet.has(nextTag.slice(1)) : !inlineElements.has(nextTag);
   }
+  // When `collapseInlineTagWhitespace` is enabled, still preserve whitespace around inline text elements
+  if (trimRight && options.collapseInlineTagWhitespace) {
+    const tagName = nextTag.charAt(0) === '/' ? nextTag.slice(1) : nextTag;
+    if (inlineElementsToKeepWhitespaceWithin.has(tagName)) {
+      trimRight = false;
+    }
+  }
   return collapseWhitespace(str, options, trimLeft, trimRight, prevTag && nextTag);
 }