html-minifier-next 4.17.1 → 4.18.0

package/README.md

@@ -61,7 +61,7 @@ You can use a configuration file to specify options. The file can be either JSON
 
 **JavaScript module configuration example:**
 
-```js
+```javascript
 module.exports = {
   collapseWhitespace: true,
   removeComments: true,
@@ -74,7 +74,7 @@ module.exports = {
 
 ESM with Node.js ≥16.14:
 
-```js
+```javascript
 import { minify } from 'html-minifier-next';
 
 const result = await minify('<p title="example" id="moo">foo</p>', {
@@ -86,7 +86,7 @@ console.log(result); // “<p title=example id=moo>foo”
 
 CommonJS:
 
-```js
+```javascript
 const { minify, getPreset } = require('html-minifier-next');
 
 (async () => {
@@ -152,6 +152,7 @@ Options can be used in config files (camelCase) or via CLI flags (kebab-case wit
 | `keepClosingSlash`<br>`--keep-closing-slash` | Keep the trailing slash on void elements | `false` |
 | `maxInputLength`<br>`--max-input-length` | Maximum input length to prevent ReDoS attacks (disabled by default) | `undefined` |
 | `maxLineLength`<br>`--max-line-length` | Specify a maximum line length; compressed output will be split by newlines at valid HTML split-points | `undefined` |
+| `mergeScripts`<br>`--merge-scripts` | Merge consecutive inline `script` elements into one (only merges compatible scripts with same `type`, matching `async`/`defer`/`nomodule`/`nonce`) | `false` |
 | `minifyCSS`<br>`--minify-css` | Minify CSS in `style` elements and attributes (uses [Lightning CSS](https://lightningcss.dev/)) | `false` (could be `true`, `Object`, `Function(text, type)`) |
 | `minifyJS`<br>`--minify-js` | Minify JavaScript in `script` elements and event attributes (uses [Terser](https://github.com/terser/terser) or [SWC](https://swc.rs/)) | `false` (could be `true`, `Object`, `Function(text, inline)`) |
 | `minifySVG`<br>`--minify-svg` | Minify SVG elements and attributes (numeric precision, default attributes, colors) | `false` (could be `true`, `Object`) |
@@ -188,7 +189,7 @@ When `minifyCSS` is set to `true`, HTML Minifier Next uses [Lightning CSS](https
 
 You can pass Lightning CSS configuration options by providing an object:
 
-```js
+```javascript
 const result = await minify(html, {
   minifyCSS: {
     targets: {
@@ -211,7 +212,7 @@ Available Lightning CSS options when passed as an object:
 
 For advanced usage, you can also pass a function:
 
-```js
+```javascript
 const result = await minify(html, {
   minifyCSS: function(text, type) {
     // `text`: CSS string to minify
@@ -227,7 +228,7 @@ When `minifyJS` is set to `true`, HTML Minifier Next uses [Terser](https://githu
 
 You can choose between different JS minifiers using the `engine` field:
 
-```js
+```javascript
 const result = await minify(html, {
   minifyJS: {
     engine: 'swc', // Use SWC for faster minification
@@ -253,7 +254,7 @@ npm i @swc/core
 
 You can pass engine-specific configuration options:
 
-```js
+```javascript
 // Using Terser with custom options
 const result = await minify(html, {
   minifyJS: {
@@ -273,7 +274,7 @@ const result = await minify(html, {
 
 For advanced usage, you can also pass a function:
 
-```js
+```javascript
 const result = await minify(html, {
   minifyJS: function(text, inline) {
     // `text`: JavaScript string to minify
@@ -287,7 +288,7 @@ const result = await minify(html, {
 
 When `minifySVG` is set to `true`, HTML Minifier Next applies SVG-specific optimizations to SVG elements and their attributes. These optimizations are lightweight, fast, and safe:
 
-```js
+```javascript
 const result = await minify(html, {
   minifySVG: true // Enable with default settings
 });
@@ -313,7 +314,7 @@ What gets optimized:
 
 You can customize the optimization behavior by providing an options object:
 
-```js
+```javascript
 const result = await minify(html, {
   minifySVG: {
     precision: 2,           // Use 2 decimal places instead of 3
@@ -344,38 +345,38 @@ How does HTML Minifier Next compare to other minifiers? (All minification with t
 | Site | Original Size (KB) | [HTML Minifier Next](https://github.com/j9t/html-minifier-next) ([config](https://github.com/j9t/html-minifier-next/blob/main/benchmarks/html-minifier.json))<br>[![npm last update](https://img.shields.io/npm/last-update/html-minifier-next)](https://socket.dev/npm/package/html-minifier-next) | [htmlnano](https://github.com/posthtml/htmlnano)<br>[![npm last update](https://img.shields.io/npm/last-update/htmlnano)](https://socket.dev/npm/package/htmlnano) | [@swc/html](https://github.com/swc-project/swc)<br>[![npm last update](https://img.shields.io/npm/last-update/@swc/html)](https://socket.dev/npm/package/@swc/html) | [minify-html](https://github.com/wilsonzlin/minify-html)<br>[![npm last update](https://img.shields.io/npm/last-update/@minify-html/node)](https://socket.dev/npm/package/@minify-html/node) | [minimize](https://github.com/Swaagie/minimize)<br>[![npm last update](https://img.shields.io/npm/last-update/minimize)](https://socket.dev/npm/package/minimize) | [html­com­pressor.­com](https://htmlcompressor.com/) |
 | --- | --- | --- | --- | --- | --- | --- | --- |
 | [A List Apart](https://alistapart.com/) | 59 | **49** | 51 | 52 | 51 | 54 | 52 |
-| [Apple](https://www.apple.com/) | 259 | **201** | 230 | 234 | 234 | 236 | 237 |
-| [BBC](https://www.bbc.co.uk/) | 647 | **586** | 608 | 608 | 609 | 642 | n/a |
-| [CERN](https://home.cern/) | 151 | **83** | 91 | 91 | 91 | 93 | 96 |
-| [CSS-Tricks](https://css-tricks.com/) | 161 | **119** | 127 | 142 | 142 | 147 | 144 |
+| [Apple](https://www.apple.com/) | 124 | **108** | 115 | 116 | 118 | 119 | 119 |
+| [BBC](https://www.bbc.co.uk/) | 618 | **561** | 580 | 581 | 582 | 613 | n/a |
+| [CERN](https://home.cern/) | 151 | **82** | 90 | 90 | 91 | 93 | 95 |
+| [CSS-Tricks](https://css-tricks.com/) | 161 | **119** | 126 | 141 | 142 | 147 | 143 |
 | [ECMAScript](https://tc39.es/ecma262/) | 7250 | **6401** | 6573 | 6455 | 6578 | 6626 | n/a |
 | [EDRi](https://edri.org/) | 80 | **59** | 70 | 70 | 71 | 75 | 73 |
-| [EFF](https://www.eff.org/) | 55 | **46** | 49 | 48 | 48 | 50 | 50 |
+| [EFF](https://www.eff.org/) | 54 | **45** | 49 | 47 | 48 | 49 | 49 |
 | [European Alternatives](https://european-alternatives.eu/) | 48 | **30** | 32 | 32 | 32 | 32 | 32 |
-| [FAZ](https://www.faz.net/aktuell/) | 1579 | 1468 | **1416** | 1503 | 1515 | 1526 | n/a |
+| [FAZ](https://www.faz.net/aktuell/) | 1595 | 1456 | **1428** | 1519 | 1530 | 1540 | n/a |
 | [French Tech](https://lafrenchtech.gouv.fr/) | 153 | **122** | 126 | 126 | 126 | 132 | 127 |
-| [Frontend Dogma](https://frontenddogma.com/) | 227 | **219** | 240 | 225 | 227 | 245 | 226 |
+| [Frontend Dogma](https://frontenddogma.com/) | 228 | **220** | 242 | 227 | 228 | 247 | 228 |
 | [Google](https://www.google.com/) | 18 | **16** | 17 | 17 | 17 | 18 | 18 |
-| [Ground News](https://ground.news/) | 2626 | **2321** | 2417 | 2444 | 2446 | 2613 | n/a |
+| [Ground News](https://ground.news/) | 2212 | **1945** | 2040 | 2068 | 2069 | 2198 | n/a |
 | [HTML Living Standard](https://html.spec.whatwg.org/multipage/) | 149 | 148 | 153 | **147** | 149 | 155 | 149 |
-| [Igalia](https://www.igalia.com/) | 48 | **33** | 35 | 35 | 35 | 36 | 36 |
-| [Leanpub](https://leanpub.com/) | 245 | **214** | 228 | 228 | 229 | 241 | 242 |
-| [Mastodon](https://mastodon.social/explore) | 37 | **28** | 32 | 35 | 35 | 36 | 36 |
+| [Igalia](https://www.igalia.com/) | 49 | **33** | 36 | 35 | 36 | 36 | 36 |
+| [Leanpub](https://leanpub.com/) | 250 | **218** | 233 | 233 | 234 | 245 | 247 |
+| [Mastodon](https://mastodon.social/explore) | 38 | **28** | 32 | 35 | 35 | 36 | 36 |
 | [MDN](https://developer.mozilla.org/en-US/) | 109 | **62** | 64 | 65 | 65 | 68 | 68 |
-| [Middle East Eye](https://www.middleeasteye.net/) | 222 | **196** | 202 | 200 | 200 | 202 | 202 |
-| [Mistral AI](https://mistral.ai/) | 356 | **313** | 318 | 322 | 323 | 352 | n/a |
-| [Mozilla](https://www.mozilla.org/) | 45 | **31** | 35 | 34 | 34 | 35 | 35 |
+| [Middle East Eye](https://www.middleeasteye.net/) | 221 | **195** | 201 | 200 | 199 | 201 | 202 |
+| [Mistral AI](https://mistral.ai/) | 364 | **319** | 326 | 329 | 330 | 360 | n/a |
+| [Mozilla](https://www.mozilla.org/) | 54 | **36** | 42 | 42 | 41 | 43 | 43 |
 | [Nielsen Norman Group](https://www.nngroup.com/) | 93 | 70 | **57** | 75 | 77 | 78 | 77 |
-| [SitePoint](https://www.sitepoint.com/) | 478 | **347** | 419 | 452 | 457 | 475 | n/a |
+| [SitePoint](https://www.sitepoint.com/) | 483 | **352** | 424 | 457 | 462 | 480 | n/a |
 | [Startup-Verband](https://startupverband.de/) | 43 | **30** | 31 | **30** | 31 | 31 | 31 |
-| [TetraLogical](https://tetralogical.com/) | 44 | 39 | **36** | 38 | 39 | 39 | 39 |
-| [TPGi](https://www.tpgi.com/) | 175 | **159** | 160 | 164 | 166 | 172 | 172 |
-| [United Nations](https://www.un.org/en/) | 152 | **113** | 122 | 126 | 126 | 131 | 124 |
+| [TetraLogical](https://tetralogical.com/) | 44 | 38 | **36** | 38 | 39 | 39 | 39 |
+| [TPGi](https://www.tpgi.com/) | 173 | **157** | 159 | 163 | 164 | 170 | 170 |
+| [United Nations](https://www.un.org/en/) | 151 | **112** | 121 | 125 | 125 | 130 | 123 |
 | [Vivaldi](https://vivaldi.com/) | 93 | **74** | n/a | 79 | 81 | 84 | 82 |
-| [W3C](https://www.w3.org/) | 50 | **36** | 39 | 38 | 38 | 41 | 39 |
-| **Average processing time** |  | 97 ms (30/30) | 157 ms (29/30) | 51 ms (30/30) | **15 ms (30/30)** | 289 ms (30/30) | 1288 ms (24/30) |
+| [W3C](https://www.w3.org/) | 51 | **36** | 39 | 38 | 38 | 41 | 39 |
+| **Average processing time** |  | 98 ms (30/30) | 152 ms (29/30) | 48 ms (30/30) | **14 ms (30/30)** | 274 ms (30/30) | 1437 ms (24/30) |
 
-(Last updated: Jan 8, 2026)
+(Last updated: Jan 19, 2026)
 <!-- End auto-generated -->
 
 Notes: Minimize does not minify CSS and JS. [HTML Minifier Terser](https://github.com/terser/html-minifier-terser) is currently not included due to issues around whitespace collapsing and removal of code using modern CSS features, issues which appeared to distort the data.

package/cli.js

@@ -144,6 +144,7 @@ const mainOptions = {
   keepClosingSlash: 'Keep the trailing slash on void elements',
   maxInputLength: ['Maximum input length to prevent ReDoS attacks', parseValidInt('maxInputLength')],
   maxLineLength: ['Specify a maximum line length; compressed output will be split by newlines at valid HTML split-points', parseValidInt('maxLineLength')],
+  mergeScripts: 'Merge consecutive inline `script` elements into one',
   minifyCSS: ['Minify CSS in `style` elements and attributes (uses Lightning CSS)', parseJSON],
   minifyJS: ['Minify JavaScript in `script` elements and event attributes (uses Terser or SWC; pass `{"engine": "swc"}` for SWC)', parseJSON],
   minifySVG: ['Minify SVG elements and attributes (numeric precision, default attributes, colors)', parseJSON],

package/dist/htmlminifier.cjs

@@ -781,6 +781,7 @@ const presets = {
     collapseWhitespace: true,
     continueOnParseError: true,
     decodeEntities: true,
+    mergeScripts: true,
     minifyCSS: true,
     minifyJS: true,
     minifySVG: true,
@@ -999,6 +1000,11 @@ const isSimpleBoolean = new Set(['allowfullscreen', 'async', 'autofocus', 'autop
 
 const isBooleanValue = new Set(['true', 'false']);
 
+// Attributes where empty value can be collapsed to just the attribute name
+// `crossorigin=""` → `crossorigin` (empty string equals anonymous mode)
+// `contenteditable=""` → `contenteditable` (empty string equals `true`)
+const emptyCollapsible = new Set(['crossorigin', 'contenteditable']);
+
 // `srcset` elements
 
 const srcsetElements = new Set(['img', 'source']);
@@ -1448,7 +1454,8 @@ function minifyNumber(num, precision = 3) {
   const fixed = parsed.toFixed(precision);
   const trimmed = fixed.replace(/\.?0+$/, '');
 
-  const result = trimmed || '0';
+  // Remove leading zero before decimal point (e.g., `0.5` → `.5`, `-0.3` → `-.3`)
+  const result = (trimmed || '0').replace(/^(-?)0\./, '$1.');
   numberCache.set(cacheKey, result);
   return result;
 }
@@ -1468,17 +1475,23 @@ function minifyPathData(pathData, precision = 3) {
   });
 
   // Remove unnecessary spaces around path commands
-  // Safe to remove space after a command letter when it’s followed by a number (which may be negative)
-  // `M 10 20` → `M10 20`, `L -5 -3` → `L-5-3`
-  result = result.replace(/([MLHVCSQTAZmlhvcsqtaz])\s+(?=-?\d)/g, '$1');
+  // Safe to remove space after a command letter when it’s followed by a number
+  // (which may be negative or start with a decimal point)
+  // `M 10 20` → `M10 20`, `L -5 -3` → `L-5-3`, `M .5 .3` → `M.5.3`
+  result = result.replace(/([MLHVCSQTAZmlhvcsqtaz])\s+(?=-?\.?\d)/g, '$1');
 
   // Safe to remove space before command letter when preceded by a number
-  // `0 L` → `0L`, `20 M` → `20M`
-  result = result.replace(/(\d)\s+([MLHVCSQTAZmlhvcsqtaz])/g, '$1$2');
+  // `0 L` → `0L`, `20 M` → `20M`, `.5 L` → `.5L`
+  result = result.replace(/([\d.])\s+([MLHVCSQTAZmlhvcsqtaz])/g, '$1$2');
 
   // Safe to remove space before negative number when preceded by a number
-  // `10 -20` → `10-20` (numbers are separated by the minus sign)
-  result = result.replace(/(\d)\s+(-\d)/g, '$1$2');
+  // `10 -20` → `10-20`, `.5 -.3` → `.5-.3` (minus sign is always a separator)
+  result = result.replace(/([\d.])\s+(-)/g, '$1$2');
+
+  // Safe to remove space between two decimal numbers (decimal point acts as separator)
+  // `.5 .3` → `.5.3` (only when previous char is `.`, indicating a complete decimal)
+  // Note: `0 .3` must not become `0.3` (that would change two numbers into one)
+  result = result.replace(/(\.\d*)\s+(\.)/g, '$1$2');
 
   return result;
 }
@@ -2255,7 +2268,9 @@ function isStyleElement(tag, attrs) {
 }
 
 function isBooleanAttribute(attrName, attrValue) {
-  return isSimpleBoolean.has(attrName) || (attrName === 'draggable' && !isBooleanValue.has(attrValue));
+  return isSimpleBoolean.has(attrName) ||
+    (attrName === 'draggable' && !isBooleanValue.has(attrValue)) ||
+    (attrValue === '' && emptyCollapsible.has(attrName));
 }
 
 function isUriTypeAttribute(attrName, tag) {
@@ -2933,11 +2948,126 @@ async function getSwc() {
 }
 
 // Minification caches
-
 const cssMinifyCache = new LRU(500);
 const jsMinifyCache = new LRU(500);
 const urlMinifyCache = new LRU(500);
 
+// Pre-compiled patterns for script merging (avoid repeated allocation in hot path)
+const RE_SCRIPT_ATTRS = /([^\s=]+)(?:=(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
+const SCRIPT_BOOL_ATTRS = new Set(['async', 'defer', 'nomodule']);
+const DEFAULT_JS_TYPES = new Set(['', 'text/javascript', 'application/javascript']);
+
+// Pre-compiled patterns for buffer scanning
+const RE_START_TAG = /^<[^/!]/;
+const RE_END_TAG = /^<\//;
+
+// Script merging
+
+/**
+ * Merge consecutive inline script tags into one (`mergeConsecutiveScripts`).
+ * Only merges scripts that are compatible:
+ * - Both inline (no `src` attribute)
+ * - Same `type` (or both default JavaScript)
+ * - No conflicting attributes (`async`, `defer`, `nomodule`, different `nonce`)
+ *
+ * Limitation: This function uses regex-based matching (`pattern` variable below),
+ * which can produce incorrect results if a script’s content contains a literal
+ * `</script>` string (e.g., `document.write('<script>…</script>')`). In valid
+ * HTML, such strings should be escaped as `<\/script>` or split like
+ * `'</scr' + 'ipt>'`, so this limitation rarely affects real-world code. The
+ * earlier `minifyJS` step (if enabled) typically handles this escaping already.
+ *
+ * @param {string} html - The HTML string to process
+ * @returns {string} HTML with consecutive scripts merged
+ */
+function mergeConsecutiveScripts(html) {
+  // `pattern`: Regex to match consecutive `</script>` followed by `<script…>`.
+  // See function JSDoc above for known limitations with literal `</script>` in content.
+  // Captures:
+  // 1. first script attrs
+  // 2. first script content
+  // 3. whitespace between
+  // 4. second script attrs
+  // 5. second script content
+  const pattern = /<script([^>]*)>([\s\S]*?)<\/script>([\s]*)<script([^>]*)>([\s\S]*?)<\/script>/gi;
+
+  let result = html;
+  let changed = true;
+
+  // Keep merging until no more changes (handles chains of 3+ scripts)
+  while (changed) {
+    changed = false;
+    result = result.replace(pattern, (match, attrs1, content1, whitespace, attrs2, content2) => {
+      // Parse attributes from both script tags (uses pre-compiled RE_SCRIPT_ATTRS)
+      const parseAttrs = (attrStr) => {
+        const attrs = {};
+        RE_SCRIPT_ATTRS.lastIndex = 0; // Reset for reuse
+        let m;
+        while ((m = RE_SCRIPT_ATTRS.exec(attrStr)) !== null) {
+          const name = m[1].toLowerCase();
+          const value = m[2] ?? m[3] ?? m[4] ?? '';
+          attrs[name] = value;
+        }
+        return attrs;
+      };
+
+      const a1 = parseAttrs(attrs1);
+      const a2 = parseAttrs(attrs2);
+
+      // Check for `src`—cannot merge external scripts
+      if ('src' in a1 || 'src' in a2) {
+        return match;
+      }
+
+      // Check `type` compatibility (both must be same, or both default JS)
+      const type1 = a1.type || '';
+      const type2 = a2.type || '';
+
+      if (DEFAULT_JS_TYPES.has(type1) && DEFAULT_JS_TYPES.has(type2)) ; else if (type1 === type2) ; else {
+        // Incompatible types
+        return match;
+      }
+
+      // Check for conflicting boolean attributes (uses pre-compiled SCRIPT_BOOL_ATTRS)
+      for (const attr of SCRIPT_BOOL_ATTRS) {
+        const has1 = attr in a1;
+        const has2 = attr in a2;
+        if (has1 !== has2) {
+          // One has it, one doesn't - incompatible
+          return match;
+        }
+      }
+
+      // Check `nonce`—must be same or both absent
+      if (a1.nonce !== a2.nonce) {
+        return match;
+      }
+
+      // Scripts are compatible—merge them
+      changed = true;
+
+      // Combine content—use semicolon normally, newline only for trailing `//` comments
+      const c1 = content1.trim();
+      const c2 = content2.trim();
+      let mergedContent;
+      if (c1 && c2) {
+        // Check if last line of c1 contains `//` (single-line comment)
+        // If so, use newline to terminate it; otherwise use semicolon (if not already present)
+        const lastLine = c1.slice(c1.lastIndexOf('\n') + 1);
+        const separator = lastLine.includes('//') ? '\n' : (c1.endsWith(';') ? '' : ';');
+        mergedContent = c1 + separator + c2;
+      } else {
+        mergedContent = c1 || c2;
+      }
+
+      // Use first script’s attributes (they should be compatible)
+      return `<script${attrs1}>${mergedContent}</script>`;
+    });
+  }
+
+  return result;
+}
+
 // Type definitions
 
 /**
@@ -3118,6 +3248,13 @@ const urlMinifyCache = new LRU(500);
  *
  *  Default: No limit
  *
+ * @prop {boolean} [mergeScripts]
+ *  When true, consecutive inline `<script>` elements are merged into one.
+ *  Only merges compatible scripts (same `type`, matching `async`/`defer`/
+ *  `nomodule`/`nonce` attributes). Does not merge external scripts (with `src`).
+ *
+ *  Default: `false`
+ *
  * @prop {boolean | Partial<import("lightningcss").TransformOptions<import("lightningcss").CustomAtRules>> | ((text: string, type?: string) => Promise<string> | string)} [minifyCSS]
  *  When true, enables CSS minification for inline `<style>` tags or
  *  `style` attributes. If an object is provided, it is passed to
@@ -3696,7 +3833,7 @@ async function minifyHTML(value, options, partialMarkup) {
 
   function removeStartTag() {
     let index = buffer.length - 1;
-    while (index > 0 && !/^<[^/!]/.test(buffer[index])) {
+    while (index > 0 && !RE_START_TAG.test(buffer[index])) {
       index--;
     }
     buffer.length = Math.max(0, index);
@@ -3704,7 +3841,7 @@ async function minifyHTML(value, options, partialMarkup) {
 
   function removeEndTag() {
     let index = buffer.length - 1;
-    while (index > 0 && !/^<\//.test(buffer[index])) {
+    while (index > 0 && !RE_END_TAG.test(buffer[index])) {
       index--;
     }
     buffer.length = Math.max(0, index);
@@ -3929,6 +4066,20 @@ async function minifyHTML(value, options, partialMarkup) {
           text = entities.decodeHTML(text);
         }
       }
+      // Trim outermost newline-based whitespace inside `pre`/`textarea` elements
+      // This removes trailing newlines often added by template engines before closing tags
+      // Only trims single trailing newlines (multiple newlines are likely intentional formatting)
+      if (options.collapseWhitespace && stackNoTrimWhitespace.length) {
+        const topTag = stackNoTrimWhitespace[stackNoTrimWhitespace.length - 1];
+        if (stackNoTrimWhitespace.includes('pre') || stackNoTrimWhitespace.includes('textarea')) {
+          // Trim trailing whitespace only if it ends with a single newline (not multiple)
+          // Multiple newlines are likely intentional formatting, single newline is often a template artifact
+          // Treat CRLF (`\r\n`), CR (`\r`), and LF (`\n`) as single line-ending units
+          if (nextTag && nextTag === '/' + topTag && /[^\r\n](?:\r\n|\r|\n)[ \t]*$/.test(text)) {
+            text = text.replace(/(?:\r\n|\r|\n)[ \t]*$/, '');
+          }
+        }
+      }
       if (options.collapseWhitespace) {
         if (!stackNoTrimWhitespace.length) {
           if (prevTag === 'comment') {
@@ -4001,8 +4152,8 @@ async function minifyHTML(value, options, partialMarkup) {
       charsPrevTag = /^\s*$/.test(text) ? prevTag : 'comment';
       if (options.decodeEntities && text && !specialContentElements.has(currentTag)) {
         // Escape any `&` symbols that start either:
-        // 1) a legacy-named character reference (i.e., one that doesn’t end with `;`)
-        // 2) or any other character reference (i.e., one that does end with `;`)
+        // 1. a legacy-named character reference (i.e., one that doesn’t end with `;`)
+        // 2. or any other character reference (i.e., one that does end with `;`)
         // Note that `&` can be escaped as `&amp`, without the semicolon.
         // https://mathiasbynens.be/notes/ambiguous-ampersands
         if (text.indexOf('&') !== -1) {
@@ -4221,7 +4372,13 @@ const minify = async function (value, options) {
     jsMinifyCache,
     urlMinifyCache
   });
-  const result = await minifyHTML(value, options);
+  let result = await minifyHTML(value, options);
+
+  // Post-processing: Merge consecutive inline scripts if enabled
+  if (options.mergeScripts) {
+    result = mergeConsecutiveScripts(result);
+  }
+
   options.log('minified in: ' + (Date.now() - start) + 'ms');
   return result;
 };

package/dist/htmlminifier.esm.bundle.js

@@ -3393,6 +3393,7 @@ const presets = {
     collapseWhitespace: true,
     continueOnParseError: true,
     decodeEntities: true,
+    mergeScripts: true,
     minifyCSS: true,
     minifyJS: true,
     minifySVG: true,
@@ -3611,6 +3612,11 @@ const isSimpleBoolean = new Set(['allowfullscreen', 'async', 'autofocus', 'autop
 
 const isBooleanValue = new Set(['true', 'false']);
 
+// Attributes where empty value can be collapsed to just the attribute name
+// `crossorigin=""` → `crossorigin` (empty string equals anonymous mode)
+// `contenteditable=""` → `contenteditable` (empty string equals `true`)
+const emptyCollapsible = new Set(['crossorigin', 'contenteditable']);
+
 // `srcset` elements
 
 const srcsetElements = new Set(['img', 'source']);
@@ -6590,7 +6596,8 @@ function minifyNumber(num, precision = 3) {
   const fixed = parsed.toFixed(precision);
   const trimmed = fixed.replace(/\.?0+$/, '');
 
-  const result = trimmed || '0';
+  // Remove leading zero before decimal point (e.g., `0.5` → `.5`, `-0.3` → `-.3`)
+  const result = (trimmed || '0').replace(/^(-?)0\./, '$1.');
   numberCache.set(cacheKey, result);
   return result;
 }
@@ -6610,17 +6617,23 @@ function minifyPathData(pathData, precision = 3) {
   });
 
   // Remove unnecessary spaces around path commands
-  // Safe to remove space after a command letter when it’s followed by a number (which may be negative)
-  // `M 10 20` → `M10 20`, `L -5 -3` → `L-5-3`
-  result = result.replace(/([MLHVCSQTAZmlhvcsqtaz])\s+(?=-?\d)/g, '$1');
+  // Safe to remove space after a command letter when it’s followed by a number
+  // (which may be negative or start with a decimal point)
+  // `M 10 20` → `M10 20`, `L -5 -3` → `L-5-3`, `M .5 .3` → `M.5.3`
+  result = result.replace(/([MLHVCSQTAZmlhvcsqtaz])\s+(?=-?\.?\d)/g, '$1');
 
   // Safe to remove space before command letter when preceded by a number
-  // `0 L` → `0L`, `20 M` → `20M`
-  result = result.replace(/(\d)\s+([MLHVCSQTAZmlhvcsqtaz])/g, '$1$2');
+  // `0 L` → `0L`, `20 M` → `20M`, `.5 L` → `.5L`
+  result = result.replace(/([\d.])\s+([MLHVCSQTAZmlhvcsqtaz])/g, '$1$2');
 
   // Safe to remove space before negative number when preceded by a number
-  // `10 -20` → `10-20` (numbers are separated by the minus sign)
-  result = result.replace(/(\d)\s+(-\d)/g, '$1$2');
+  // `10 -20` → `10-20`, `.5 -.3` → `.5-.3` (minus sign is always a separator)
+  result = result.replace(/([\d.])\s+(-)/g, '$1$2');
+
+  // Safe to remove space between two decimal numbers (decimal point acts as separator)
+  // `.5 .3` → `.5.3` (only when previous char is `.`, indicating a complete decimal)
+  // Note: `0 .3` must not become `0.3` (that would change two numbers into one)
+  result = result.replace(/(\.\d*)\s+(\.)/g, '$1$2');
 
   return result;
 }
@@ -7397,7 +7410,9 @@ function isStyleElement(tag, attrs) {
 }
 
 function isBooleanAttribute(attrName, attrValue) {
-  return isSimpleBoolean.has(attrName) || (attrName === 'draggable' && !isBooleanValue.has(attrValue));
+  return isSimpleBoolean.has(attrName) ||
+    (attrName === 'draggable' && !isBooleanValue.has(attrValue)) ||
+    (attrValue === '' && emptyCollapsible.has(attrName));
 }
 
 function isUriTypeAttribute(attrName, tag) {
@@ -8075,11 +8090,126 @@ async function getSwc() {
 }
 
 // Minification caches
-
 const cssMinifyCache = new LRU(500);
 const jsMinifyCache = new LRU(500);
 const urlMinifyCache = new LRU(500);
 
+// Pre-compiled patterns for script merging (avoid repeated allocation in hot path)
+const RE_SCRIPT_ATTRS = /([^\s=]+)(?:=(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
+const SCRIPT_BOOL_ATTRS = new Set(['async', 'defer', 'nomodule']);
+const DEFAULT_JS_TYPES = new Set(['', 'text/javascript', 'application/javascript']);
+
+// Pre-compiled patterns for buffer scanning
+const RE_START_TAG = /^<[^/!]/;
+const RE_END_TAG = /^<\//;
+
+// Script merging
+
+/**
+ * Merge consecutive inline script tags into one (`mergeConsecutiveScripts`).
+ * Only merges scripts that are compatible:
+ * - Both inline (no `src` attribute)
+ * - Same `type` (or both default JavaScript)
+ * - No conflicting attributes (`async`, `defer`, `nomodule`, different `nonce`)
+ *
+ * Limitation: This function uses regex-based matching (`pattern` variable below),
+ * which can produce incorrect results if a script’s content contains a literal
+ * `</script>` string (e.g., `document.write('<script>…</script>')`). In valid
+ * HTML, such strings should be escaped as `<\/script>` or split like
+ * `'</scr' + 'ipt>'`, so this limitation rarely affects real-world code. The
+ * earlier `minifyJS` step (if enabled) typically handles this escaping already.
+ *
+ * @param {string} html - The HTML string to process
+ * @returns {string} HTML with consecutive scripts merged
+ */
+function mergeConsecutiveScripts(html) {
+  // `pattern`: Regex to match consecutive `</script>` followed by `<script…>`.
+  // See function JSDoc above for known limitations with literal `</script>` in content.
+  // Captures:
+  // 1. first script attrs
+  // 2. first script content
+  // 3. whitespace between
+  // 4. second script attrs
+  // 5. second script content
+  const pattern = /<script([^>]*)>([\s\S]*?)<\/script>([\s]*)<script([^>]*)>([\s\S]*?)<\/script>/gi;
+
+  let result = html;
+  let changed = true;
+
+  // Keep merging until no more changes (handles chains of 3+ scripts)
+  while (changed) {
+    changed = false;
+    result = result.replace(pattern, (match, attrs1, content1, whitespace, attrs2, content2) => {
+      // Parse attributes from both script tags (uses pre-compiled RE_SCRIPT_ATTRS)
+      const parseAttrs = (attrStr) => {
+        const attrs = {};
+        RE_SCRIPT_ATTRS.lastIndex = 0; // Reset for reuse
+        let m;
+        while ((m = RE_SCRIPT_ATTRS.exec(attrStr)) !== null) {
+          const name = m[1].toLowerCase();
+          const value = m[2] ?? m[3] ?? m[4] ?? '';
+          attrs[name] = value;
+        }
+        return attrs;
+      };
+
+      const a1 = parseAttrs(attrs1);
+      const a2 = parseAttrs(attrs2);
+
+      // Check for `src`—cannot merge external scripts
+      if ('src' in a1 || 'src' in a2) {
+        return match;
+      }
+
+      // Check `type` compatibility (both must be same, or both default JS)
+      const type1 = a1.type || '';
+      const type2 = a2.type || '';
+
+      if (DEFAULT_JS_TYPES.has(type1) && DEFAULT_JS_TYPES.has(type2)) ; else if (type1 === type2) ; else {
+        // Incompatible types
+        return match;
+      }
+
+      // Check for conflicting boolean attributes (uses pre-compiled SCRIPT_BOOL_ATTRS)
+      for (const attr of SCRIPT_BOOL_ATTRS) {
+        const has1 = attr in a1;
+        const has2 = attr in a2;
+        if (has1 !== has2) {
+          // One has it, one doesn't - incompatible
+          return match;
+        }
+      }
+
+      // Check `nonce`—must be same or both absent
+      if (a1.nonce !== a2.nonce) {
+        return match;
+      }
+
+      // Scripts are compatible—merge them
+      changed = true;
+
+      // Combine content—use semicolon normally, newline only for trailing `//` comments
+      const c1 = content1.trim();
+      const c2 = content2.trim();
+      let mergedContent;
+      if (c1 && c2) {
+        // Check if last line of c1 contains `//` (single-line comment)
+        // If so, use newline to terminate it; otherwise use semicolon (if not already present)
+        const lastLine = c1.slice(c1.lastIndexOf('\n') + 1);
+        const separator = lastLine.includes('//') ? '\n' : (c1.endsWith(';') ? '' : ';');
+        mergedContent = c1 + separator + c2;
+      } else {
+        mergedContent = c1 || c2;
+      }
+
+      // Use first script’s attributes (they should be compatible)
+      return `<script${attrs1}>${mergedContent}</script>`;
+    });
+  }
+
+  return result;
+}
+
 // Type definitions
 
 /**
@@ -8260,6 +8390,13 @@ const urlMinifyCache = new LRU(500);
  *
  *  Default: No limit
  *
+ * @prop {boolean} [mergeScripts]
+ *  When true, consecutive inline `<script>` elements are merged into one.
+ *  Only merges compatible scripts (same `type`, matching `async`/`defer`/
+ *  `nomodule`/`nonce` attributes). Does not merge external scripts (with `src`).
+ *
+ *  Default: `false`
+ *
  * @prop {boolean | Partial<import("lightningcss").TransformOptions<import("lightningcss").CustomAtRules>> | ((text: string, type?: string) => Promise<string> | string)} [minifyCSS]
  *  When true, enables CSS minification for inline `<style>` tags or
  *  `style` attributes. If an object is provided, it is passed to
@@ -8838,7 +8975,7 @@ async function minifyHTML(value, options, partialMarkup) {
 
   function removeStartTag() {
     let index = buffer.length - 1;
-    while (index > 0 && !/^<[^/!]/.test(buffer[index])) {
+    while (index > 0 && !RE_START_TAG.test(buffer[index])) {
       index--;
     }
     buffer.length = Math.max(0, index);
@@ -8846,7 +8983,7 @@ async function minifyHTML(value, options, partialMarkup) {
 
   function removeEndTag() {
     let index = buffer.length - 1;
-    while (index > 0 && !/^<\//.test(buffer[index])) {
+    while (index > 0 && !RE_END_TAG.test(buffer[index])) {
       index--;
     }
     buffer.length = Math.max(0, index);
@@ -9071,6 +9208,20 @@ async function minifyHTML(value, options, partialMarkup) {
           text = decodeHTML(text);
         }
       }
+      // Trim outermost newline-based whitespace inside `pre`/`textarea` elements
+      // This removes trailing newlines often added by template engines before closing tags
+      // Only trims single trailing newlines (multiple newlines are likely intentional formatting)
+      if (options.collapseWhitespace && stackNoTrimWhitespace.length) {
+        const topTag = stackNoTrimWhitespace[stackNoTrimWhitespace.length - 1];
+        if (stackNoTrimWhitespace.includes('pre') || stackNoTrimWhitespace.includes('textarea')) {
+          // Trim trailing whitespace only if it ends with a single newline (not multiple)
+          // Multiple newlines are likely intentional formatting, single newline is often a template artifact
+          // Treat CRLF (`\r\n`), CR (`\r`), and LF (`\n`) as single line-ending units
+          if (nextTag && nextTag === '/' + topTag && /[^\r\n](?:\r\n|\r|\n)[ \t]*$/.test(text)) {
+            text = text.replace(/(?:\r\n|\r|\n)[ \t]*$/, '');
+          }
+        }
+      }
       if (options.collapseWhitespace) {
         if (!stackNoTrimWhitespace.length) {
           if (prevTag === 'comment') {
@@ -9143,8 +9294,8 @@ async function minifyHTML(value, options, partialMarkup) {
       charsPrevTag = /^\s*$/.test(text) ? prevTag : 'comment';
       if (options.decodeEntities && text && !specialContentElements.has(currentTag)) {
         // Escape any `&` symbols that start either:
-        // 1) a legacy-named character reference (i.e., one that doesn’t end with `;`)
-        // 2) or any other character reference (i.e., one that does end with `;`)
+        // 1. a legacy-named character reference (i.e., one that doesn’t end with `;`)
+        // 2. or any other character reference (i.e., one that does end with `;`)
         // Note that `&` can be escaped as `&amp`, without the semicolon.
         // https://mathiasbynens.be/notes/ambiguous-ampersands
         if (text.indexOf('&') !== -1) {
@@ -9363,7 +9514,13 @@ const minify$1 = async function (value, options) {
     jsMinifyCache,
     urlMinifyCache
   });
-  const result = await minifyHTML(value, options);
+  let result = await minifyHTML(value, options);
+
+  // Post-processing: Merge consecutive inline scripts if enabled
+  if (options.mergeScripts) {
+    result = mergeConsecutiveScripts(result);
+  }
+
   options.log('minified in: ' + (Date.now() - start) + 'ms');
   return result;
 };

package/dist/types/htmlminifier.d.ts

@@ -208,6 +208,14 @@ export type MinifierOptions = {
      * Default: No limit
      */
     maxLineLength?: number;
+    /**
+     * When true, consecutive inline `<script>` elements are merged into one.
+     * Only merges compatible scripts (same `type`, matching `async`/`defer`/
+     * `nomodule`/`nonce` attributes). Does not merge external scripts (with `src`).
+     *
+     * Default: `false`
+     */
+    mergeScripts?: boolean;
     /**
      * When true, enables CSS minification for inline `<style>` tags or
      * `style` attributes. If an object is provided, it is passed to

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

@@ -1 +1 @@
-{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../src/lib/attributes.js"],"names":[],"mappings":"AA0BA,yDAEC;AAED,mEAOC;AAED,uEAWC;AAED,8DAGC;AAED,4EAOC;AAED,mGAuCC;AAED,mEAGC;AAED,qEAGC;AAED,kEAWC;AAED,sEAGC;AAED,8DAWC;AAED,2EAEC;AAED,qEAaC;AAED,wEAUC;AAED,sEAUC;AAED,2EAEC;AAED,2DAEC;AAED,8DAUC;AAED,uEAUC;AAED,oGASC;AAED,4DAOC;AAID,0IAgJC;AAsBD;;;;GAwCC;AAED,6GAuHC"}
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../src/lib/attributes.js"],"names":[],"mappings":"AA2BA,yDAEC;AAED,mEAOC;AAED,uEAWC;AAED,8DAGC;AAED,4EAOC;AAED,mGAuCC;AAED,mEAGC;AAED,qEAGC;AAED,kEAWC;AAED,sEAGC;AAED,8DAWC;AAED,2EAIC;AAED,qEAaC;AAED,wEAUC;AAED,sEAUC;AAED,2EAEC;AAED,2DAEC;AAED,8DAUC;AAED,uEAUC;AAED,oGASC;AAED,4DAOC;AAID,0IAgJC;AAsBD;;;;GAwCC;AAED,6GAuHC"}

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

@@ -79,6 +79,7 @@ export const keepScriptsMimetypes: Set<string>;
 export const jsonScriptTypes: Set<string>;
 export const isSimpleBoolean: Set<string>;
 export const isBooleanValue: Set<string>;
+export const emptyCollapsible: Set<string>;
 export const srcsetElements: Set<string>;
 export const optionalStartTags: Set<string>;
 export const optionalEndTags: Set<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;AAC5C,wCAAwqB;AACxqB,kCAA0B;AAC1B,sCAAuC;AACvC,yCAA4C;AAC5C,qCAAuD;AACvD,sCAAmE;AAKnE,+DAAgb;AAGhb,+DAA6O;AAG7O,yDAAmF;AAGnF,8CAA8G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0C9G,qDAWG;AAEH,+CAEG;AAcH,0CAUG;AApBH,0CAAwhB;AAExhB,yCAAkD;AAIlD,yCAAkD;AAuBlD,4CAAiF;AAEjF,0CAAoM;AAEpM,yCAA4F;AAE5F,8CAAkD;AAElD,yCAAiT;AAEjT,0CAA0F;AAE1F,6CAA8D;AAE9D,gDAAqD;AAErD,yCAAuD;AAEvD,+CAAyD;AAEzD,+CAAkE;AAElE,uCAA2C;AAE3C,2CAA2D;AAE3D,0CAAkD;AAElD,wCAA+D;AAE/D,2CAAkD;AAElD,uCAAmxC;AAInxC,sCAEsD;AAItD,iDAA4D"}
+{"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;AAC5C,wCAAwqB;AACxqB,kCAA0B;AAC1B,sCAAuC;AACvC,yCAA4C;AAC5C,qCAAuD;AACvD,sCAAmE;AAKnE,+DAAgb;AAGhb,+DAA6O;AAG7O,yDAAmF;AAGnF,8CAA8G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0C9G,qDAWG;AAEH,+CAEG;AAmBH,0CAUG;AAzBH,0CAAwhB;AAExhB,yCAAkD;AAKlD,2CAAqE;AAIrE,yCAAkD;AAuBlD,4CAAiF;AAEjF,0CAAoM;AAEpM,yCAA4F;AAE5F,8CAAkD;AAElD,yCAAiT;AAEjT,0CAA0F;AAE1F,6CAA8D;AAE9D,gDAAqD;AAErD,yCAAuD;AAEvD,+CAAyD;AAEzD,+CAAkE;AAElE,uCAA2C;AAE3C,2CAA2D;AAE3D,0CAAkD;AAElD,wCAA+D;AAE/D,2CAAkD;AAElD,uCAAmxC;AAInxC,sCAEsD;AAItD,iDAA4D"}

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

@@ -1 +1 @@
-{"version":3,"file":"svg.d.ts","sourceRoot":"","sources":["../../../src/lib/svg.js"],"names":[],"mappings":"AAmVA;;;;;;GAMG;AACH,8CALW,MAAM,SACN,MAAM,kBAEJ,MAAM,CA0BlB;AAED;;;;;;;GAOG;AACH,8CANW,MAAM,QACN,MAAM,SACN,MAAM,kBAEJ,OAAO,CAanB;AAED;;;;GAIG;AACH,6DAkBC"}
+{"version":3,"file":"svg.d.ts","sourceRoot":"","sources":["../../../src/lib/svg.js"],"names":[],"mappings":"AA0VA;;;;;;GAMG;AACH,8CALW,MAAM,SACN,MAAM,kBAEJ,MAAM,CA0BlB;AAED;;;;;;;GAOG;AACH,8CANW,MAAM,QACN,MAAM,SACN,MAAM,kBAEJ,OAAO,CAanB;AAED;;;;GAIG;AACH,6DAkBC"}

package/dist/types/presets.d.ts

@@ -34,6 +34,7 @@ export namespace presets {
         export { continueOnParseError_1 as continueOnParseError };
         let decodeEntities_1: boolean;
         export { decodeEntities_1 as decodeEntities };
+        export let mergeScripts: boolean;
         export let minifyCSS: boolean;
         export let minifyJS: boolean;
         export let minifySVG: boolean;

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

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

package/package.json

@@ -21,12 +21,12 @@
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-terser": "^0.4.4",
-    "@swc/core": "^1.15.7",
+    "@swc/core": "^1.15.8",
     "eslint": "^9.39.2",
-    "rollup": "^4.54.0",
+    "rollup": "^4.55.1",
     "rollup-plugin-polyfill-node": "^0.13.0",
     "typescript": "^5.9.3",
-    "vite": "^7.3.0"
+    "vite": "^7.3.1"
   },
   "exports": {
     ".": {
@@ -98,5 +98,5 @@
   },
   "type": "module",
   "types": "./dist/types/htmlminifier.d.ts",
-  "version": "4.17.1"
+  "version": "4.18.0"
 }

package/src/htmlminifier.js

@@ -92,11 +92,130 @@ async function getSwc() {
 }
 
 // Minification caches
-
 const cssMinifyCache = new LRU(500);
 const jsMinifyCache = new LRU(500);
 const urlMinifyCache = new LRU(500);
 
+// Pre-compiled patterns for script merging (avoid repeated allocation in hot path)
+const RE_SCRIPT_ATTRS = /([^\s=]+)(?:=(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
+const SCRIPT_BOOL_ATTRS = new Set(['async', 'defer', 'nomodule']);
+const DEFAULT_JS_TYPES = new Set(['', 'text/javascript', 'application/javascript']);
+
+// Pre-compiled patterns for buffer scanning
+const RE_START_TAG = /^<[^/!]/;
+const RE_END_TAG = /^<\//;
+
+// Script merging
+
+/**
+ * Merge consecutive inline script tags into one (`mergeConsecutiveScripts`).
+ * Only merges scripts that are compatible:
+ * - Both inline (no `src` attribute)
+ * - Same `type` (or both default JavaScript)
+ * - No conflicting attributes (`async`, `defer`, `nomodule`, different `nonce`)
+ *
+ * Limitation: This function uses regex-based matching (`pattern` variable below),
+ * which can produce incorrect results if a script’s content contains a literal
+ * `</script>` string (e.g., `document.write('<script>…</script>')`). In valid
+ * HTML, such strings should be escaped as `<\/script>` or split like
+ * `'</scr' + 'ipt>'`, so this limitation rarely affects real-world code. The
+ * earlier `minifyJS` step (if enabled) typically handles this escaping already.
+ *
+ * @param {string} html - The HTML string to process
+ * @returns {string} HTML with consecutive scripts merged
+ */
+function mergeConsecutiveScripts(html) {
+  // `pattern`: Regex to match consecutive `</script>` followed by `<script…>`.
+  // See function JSDoc above for known limitations with literal `</script>` in content.
+  // Captures:
+  // 1. first script attrs
+  // 2. first script content
+  // 3. whitespace between
+  // 4. second script attrs
+  // 5. second script content
+  const pattern = /<script([^>]*)>([\s\S]*?)<\/script>([\s]*)<script([^>]*)>([\s\S]*?)<\/script>/gi;
+
+  let result = html;
+  let changed = true;
+
+  // Keep merging until no more changes (handles chains of 3+ scripts)
+  while (changed) {
+    changed = false;
+    result = result.replace(pattern, (match, attrs1, content1, whitespace, attrs2, content2) => {
+      // Parse attributes from both script tags (uses pre-compiled RE_SCRIPT_ATTRS)
+      const parseAttrs = (attrStr) => {
+        const attrs = {};
+        RE_SCRIPT_ATTRS.lastIndex = 0; // Reset for reuse
+        let m;
+        while ((m = RE_SCRIPT_ATTRS.exec(attrStr)) !== null) {
+          const name = m[1].toLowerCase();
+          const value = m[2] ?? m[3] ?? m[4] ?? '';
+          attrs[name] = value;
+        }
+        return attrs;
+      };
+
+      const a1 = parseAttrs(attrs1);
+      const a2 = parseAttrs(attrs2);
+
+      // Check for `src`—cannot merge external scripts
+      if ('src' in a1 || 'src' in a2) {
+        return match;
+      }
+
+      // Check `type` compatibility (both must be same, or both default JS)
+      const type1 = a1.type || '';
+      const type2 = a2.type || '';
+
+      if (DEFAULT_JS_TYPES.has(type1) && DEFAULT_JS_TYPES.has(type2)) {
+        // Both are default JavaScript—compatible
+      } else if (type1 === type2) {
+        // Same explicit type—compatible
+      } else {
+        // Incompatible types
+        return match;
+      }
+
+      // Check for conflicting boolean attributes (uses pre-compiled SCRIPT_BOOL_ATTRS)
+      for (const attr of SCRIPT_BOOL_ATTRS) {
+        const has1 = attr in a1;
+        const has2 = attr in a2;
+        if (has1 !== has2) {
+          // One has it, one doesn't - incompatible
+          return match;
+        }
+      }
+
+      // Check `nonce`—must be same or both absent
+      if (a1.nonce !== a2.nonce) {
+        return match;
+      }
+
+      // Scripts are compatible—merge them
+      changed = true;
+
+      // Combine content—use semicolon normally, newline only for trailing `//` comments
+      const c1 = content1.trim();
+      const c2 = content2.trim();
+      let mergedContent;
+      if (c1 && c2) {
+        // Check if last line of c1 contains `//` (single-line comment)
+        // If so, use newline to terminate it; otherwise use semicolon (if not already present)
+        const lastLine = c1.slice(c1.lastIndexOf('\n') + 1);
+        const separator = lastLine.includes('//') ? '\n' : (c1.endsWith(';') ? '' : ';');
+        mergedContent = c1 + separator + c2;
+      } else {
+        mergedContent = c1 || c2;
+      }
+
+      // Use first script’s attributes (they should be compatible)
+      return `<script${attrs1}>${mergedContent}</script>`;
+    });
+  }
+
+  return result;
+}
+
 // Type definitions
 
 /**
@@ -277,6 +396,13 @@ const urlMinifyCache = new LRU(500);
  *
  *  Default: No limit
  *
+ * @prop {boolean} [mergeScripts]
+ *  When true, consecutive inline `<script>` elements are merged into one.
+ *  Only merges compatible scripts (same `type`, matching `async`/`defer`/
+ *  `nomodule`/`nonce` attributes). Does not merge external scripts (with `src`).
+ *
+ *  Default: `false`
+ *
  * @prop {boolean | Partial<import("lightningcss").TransformOptions<import("lightningcss").CustomAtRules>> | ((text: string, type?: string) => Promise<string> | string)} [minifyCSS]
  *  When true, enables CSS minification for inline `<style>` tags or
  *  `style` attributes. If an object is provided, it is passed to
@@ -855,7 +981,7 @@ async function minifyHTML(value, options, partialMarkup) {
 
   function removeStartTag() {
     let index = buffer.length - 1;
-    while (index > 0 && !/^<[^/!]/.test(buffer[index])) {
+    while (index > 0 && !RE_START_TAG.test(buffer[index])) {
       index--;
     }
     buffer.length = Math.max(0, index);
@@ -863,7 +989,7 @@ async function minifyHTML(value, options, partialMarkup) {
 
   function removeEndTag() {
     let index = buffer.length - 1;
-    while (index > 0 && !/^<\//.test(buffer[index])) {
+    while (index > 0 && !RE_END_TAG.test(buffer[index])) {
       index--;
     }
     buffer.length = Math.max(0, index);
@@ -1088,6 +1214,20 @@ async function minifyHTML(value, options, partialMarkup) {
           text = decodeHTML(text);
         }
       }
+      // Trim outermost newline-based whitespace inside `pre`/`textarea` elements
+      // This removes trailing newlines often added by template engines before closing tags
+      // Only trims single trailing newlines (multiple newlines are likely intentional formatting)
+      if (options.collapseWhitespace && stackNoTrimWhitespace.length) {
+        const topTag = stackNoTrimWhitespace[stackNoTrimWhitespace.length - 1];
+        if (stackNoTrimWhitespace.includes('pre') || stackNoTrimWhitespace.includes('textarea')) {
+          // Trim trailing whitespace only if it ends with a single newline (not multiple)
+          // Multiple newlines are likely intentional formatting, single newline is often a template artifact
+          // Treat CRLF (`\r\n`), CR (`\r`), and LF (`\n`) as single line-ending units
+          if (nextTag && nextTag === '/' + topTag && /[^\r\n](?:\r\n|\r|\n)[ \t]*$/.test(text)) {
+            text = text.replace(/(?:\r\n|\r|\n)[ \t]*$/, '');
+          }
+        }
+      }
       if (options.collapseWhitespace) {
         if (!stackNoTrimWhitespace.length) {
           if (prevTag === 'comment') {
@@ -1160,8 +1300,8 @@ async function minifyHTML(value, options, partialMarkup) {
       charsPrevTag = /^\s*$/.test(text) ? prevTag : 'comment';
       if (options.decodeEntities && text && !specialContentElements.has(currentTag)) {
         // Escape any `&` symbols that start either:
-        // 1) a legacy-named character reference (i.e., one that doesn’t end with `;`)
-        // 2) or any other character reference (i.e., one that does end with `;`)
+        // 1. a legacy-named character reference (i.e., one that doesn’t end with `;`)
+        // 2. or any other character reference (i.e., one that does end with `;`)
         // Note that `&` can be escaped as `&amp`, without the semicolon.
         // https://mathiasbynens.be/notes/ambiguous-ampersands
         if (text.indexOf('&') !== -1) {
@@ -1380,7 +1520,13 @@ export const minify = async function (value, options) {
     jsMinifyCache,
     urlMinifyCache
   });
-  const result = await minifyHTML(value, options);
+  let result = await minifyHTML(value, options);
+
+  // Post-processing: Merge consecutive inline scripts if enabled
+  if (options.mergeScripts) {
+    result = mergeConsecutiveScripts(result);
+  }
+
   options.log('minified in: ' + (Date.now() - start) + 'ms');
   return result;
 };

package/src/lib/attributes.js

@@ -15,6 +15,7 @@ import {
   keepScriptsMimetypes,
   isSimpleBoolean,
   isBooleanValue,
+  emptyCollapsible,
   srcsetElements,
   reEmptyAttribute
 } from './constants.js';
@@ -147,7 +148,9 @@ function isStyleElement(tag, attrs) {
 }
 
 function isBooleanAttribute(attrName, attrValue) {
-  return isSimpleBoolean.has(attrName) || (attrName === 'draggable' && !isBooleanValue.has(attrValue));
+  return isSimpleBoolean.has(attrName) ||
+    (attrName === 'draggable' && !isBooleanValue.has(attrValue)) ||
+    (attrValue === '' && emptyCollapsible.has(attrName));
 }
 
 function isUriTypeAttribute(attrName, tag) {

package/src/lib/constants.js

@@ -96,6 +96,11 @@ const isSimpleBoolean = new Set(['allowfullscreen', 'async', 'autofocus', 'autop
 
 const isBooleanValue = new Set(['true', 'false']);
 
+// Attributes where empty value can be collapsed to just the attribute name
+// `crossorigin=""` → `crossorigin` (empty string equals anonymous mode)
+// `contenteditable=""` → `contenteditable` (empty string equals `true`)
+const emptyCollapsible = new Set(['crossorigin', 'contenteditable']);
+
 // `srcset` elements
 
 const srcsetElements = new Set(['img', 'source']);
@@ -206,6 +211,7 @@ export {
   // Boolean sets
   isSimpleBoolean,
   isBooleanValue,
+  emptyCollapsible,
 
   // Misc
   srcsetElements,

package/src/lib/svg.js

@@ -115,7 +115,8 @@ function minifyNumber(num, precision = 3) {
   const fixed = parsed.toFixed(precision);
   const trimmed = fixed.replace(/\.?0+$/, '');
 
-  const result = trimmed || '0';
+  // Remove leading zero before decimal point (e.g., `0.5` → `.5`, `-0.3` → `-.3`)
+  const result = (trimmed || '0').replace(/^(-?)0\./, '$1.');
   numberCache.set(cacheKey, result);
   return result;
 }
@@ -135,17 +136,23 @@ function minifyPathData(pathData, precision = 3) {
   });
 
   // Remove unnecessary spaces around path commands
-  // Safe to remove space after a command letter when it’s followed by a number (which may be negative)
-  // `M 10 20` → `M10 20`, `L -5 -3` → `L-5-3`
-  result = result.replace(/([MLHVCSQTAZmlhvcsqtaz])\s+(?=-?\d)/g, '$1');
+  // Safe to remove space after a command letter when it’s followed by a number
+  // (which may be negative or start with a decimal point)
+  // `M 10 20` → `M10 20`, `L -5 -3` → `L-5-3`, `M .5 .3` → `M.5.3`
+  result = result.replace(/([MLHVCSQTAZmlhvcsqtaz])\s+(?=-?\.?\d)/g, '$1');
 
   // Safe to remove space before command letter when preceded by a number
-  // `0 L` → `0L`, `20 M` → `20M`
-  result = result.replace(/(\d)\s+([MLHVCSQTAZmlhvcsqtaz])/g, '$1$2');
+  // `0 L` → `0L`, `20 M` → `20M`, `.5 L` → `.5L`
+  result = result.replace(/([\d.])\s+([MLHVCSQTAZmlhvcsqtaz])/g, '$1$2');
 
   // Safe to remove space before negative number when preceded by a number
-  // `10 -20` → `10-20` (numbers are separated by the minus sign)
-  result = result.replace(/(\d)\s+(-\d)/g, '$1$2');
+  // `10 -20` → `10-20`, `.5 -.3` → `.5-.3` (minus sign is always a separator)
+  result = result.replace(/([\d.])\s+(-)/g, '$1$2');
+
+  // Safe to remove space between two decimal numbers (decimal point acts as separator)
+  // `.5 .3` → `.5.3` (only when previous char is `.`, indicating a complete decimal)
+  // Note: `0 .3` must not become `0.3` (that would change two numbers into one)
+  result = result.replace(/(\.\d*)\s+(\.)/g, '$1$2');
 
   return result;
 }

package/src/presets.js

@@ -27,6 +27,7 @@ export const presets = {
     collapseWhitespace: true,
     continueOnParseError: true,
     decodeEntities: true,
+    mergeScripts: true,
     minifyCSS: true,
     minifyJS: true,
     minifySVG: true,