html-minifier-next 4.14.1 → 4.15.0

package/README.md

@@ -14,6 +14,12 @@ From npm for use as a command line app:
 npm i -g html-minifier-next
 ```
 
+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
 
@@ -162,6 +168,7 @@ Options can be used in config files (camelCase) or via CLI flags (kebab-case wit
 | `maxLineLength`<br>`--max-line-length` | Specify a maximum line length; compressed output will be split by newlines at valid HTML split-points | |
 | `minifyCSS`<br>`--minify-css` | Minify CSS in `style` elements and `style` 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`) |
 | `minifyURLs`<br>`--minify-urls` | Minify URLs in various attributes (uses [relateurl](https://github.com/stevenvachon/relateurl)) | `false` (could be `String`, `Object`, `Function(text)`, `async Function(text)`) |
 | `noNewlinesBeforeTagClose`<br>`--no-newlines-before-tag-close` | Never add a newline before a tag that closes an element | `false` |
 | `partialMarkup`<br>`--partial-markup` | Treat input as a partial HTML fragment, preserving stray end tags (closing tags without opening tags) and preventing auto-closing of unclosed tags at end of input | `false` |
@@ -237,7 +244,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 +255,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:
@@ -288,42 +297,95 @@ const result = await minify(html, {
 });
 ```
 
+### SVG minification
+
+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
+const result = await minify(html, {
+  minifySVG: true // Enable with default settings
+});
+```
+
+What gets optimized:
+
+1. Numeric precision reduction: Coordinates and path data are rounded to 3 decimal places by default
+   - `<path d="M 0.00000000 0.00000000"/>` → `<path d="M 0 0"/>`
+   - `<circle cx="10.500000" cy="20.300000" r="5.000"/>` → `<circle cx="10.5" cy="20.3" r="5"/>`
+
+2. Whitespace removal: Excess whitespace in numeric attribute values is removed
+   - `transform="translate( 10 , 20 )"` → `transform="translate(10,20)"`
+   - `points="100, 10  40,  198"` → `points="100,10 40,198"`
+
+3. Color minification: Hex colors are shortened and RGB values converted to hex
+   - `fill="#000000"` → `fill="#000"`
+   - `fill="rgb(255,255,255)"` → `fill="#fff"`
+
+4. Default attribute removal: Well-documented SVG default attributes are removed
+   - `fill-opacity="1"` → removed
+   - `stroke-linecap="butt"` → removed
+
+You can customize the optimization behavior by providing an options object:
+
+```js
+const result = await minify(html, {
+  minifySVG: {
+    precision: 2,           // Use 2 decimal places instead of 3
+    removeDefaults: true,   // Remove default attributes (default: true)
+    minifyColors: true      // Minify color values (default: true)
+  }
+});
+```
+
+Available options:
+
+* `precision`: Number of decimal places for coordinates and path data (default: `3`)
+* `removeDefaults`: Remove attributes with default values (default: `true`)
+* `minifyColors`: Minify color values with hex shortening and RGB-to-hex conversion (default: `true`)
+
+**Important:**
+
+* SVG minification only applies within `<svg>` elements
+* Case sensitivity and self-closing slashes are automatically preserved in SVG (regardless of global settings)
+* For maximum compression, use `minifySVG` together with `collapseWhitespace` and other options
+* This is a lightweight, built-in implementation; for more aggressive SVG optimization, consider using [SVGO](https://github.com/svg/svgo) as a separate build step
+
 ## Minification comparison
 
-How does HTML Minifier Next compare to other minifiers? (All with the most aggressive settings—though without [hyper-optimization](https://meiert.com/blog/the-ways-of-writing-html/#toc-hyper-optimized)—and against some large documents.—Minimize does not minify CSS or JS.)
+How does HTML Minifier Next compare to other minifiers? (All minification with the most aggressive settings—though without [hyper-optimization](https://meiert.com/blog/the-ways-of-writing-html/#toc-hyper-optimized)—and against some large documents. Note that HTML Minifier Terser cannot currently—Dec 2025—handle modern CSS syntax like CSS nesting and removes such code, which can make it appear more effective than it is. Minimize does not minify CSS and JS.)
 
 <!-- Auto-generated benchmarks, don’t edit -->
 | 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) | [HTML Minifier Terser](https://github.com/terser/html-minifier-terser)<br>[![npm last update](https://img.shields.io/npm/last-update/html-minifier-terser)](https://socket.dev/npm/package/html-minifier-terser) | [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** | 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/) | 730 | **663** | 673 | 685 | 686 | 687 | 724 | n/a |
-| [CERN](https://home.cern/) | 152 | **83** | 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 |
+| [A List Apart](https://alistapart.com/) | 59 | **50** | **50** | 51 | 52 | 51 | 54 | 52 |
+| [Apple](https://www.apple.com/) | 266 | **206** | 207 | 236 | 239 | 240 | 242 | 243 |
+| [BBC](https://www.bbc.co.uk/) | 647 | **587** | 598 | 607 | 607 | 608 | 641 | n/a |
+| [CERN](https://home.cern/) | 152 | **83** | 84 | 91 | 91 | 92 | 93 | 96 |
+| [CSS-Tricks](https://css-tricks.com/) | 162 | **119** | 120 | 127 | 143 | 143 | 148 | 145 |
+| [ECMAScript](https://tc39.es/ecma262/) | 7250 | 6402 | **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 | **46** | 47 | 49 | 48 | 49 | 50 | 50 |
 | [European Alternatives](https://european-alternatives.eu/) | 48 | **30** | **30** | 32 | 32 | 32 | 32 | 32 |
-| [FAZ](https://www.faz.net/aktuell/) | 1562 | 1455 | 1460 | **1401** | 1487 | 1498 | 1509 | n/a |
+| [FAZ](https://www.faz.net/aktuell/) | 1559 | 1451 | 1460 | **1398** | 1484 | 1495 | 1506 | 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 | 224 |
+| [Frontend Dogma](https://frontenddogma.com/) | 225 | **217** | **217** | 238 | 223 | 225 | 243 | 224 |
 | [Google](https://www.google.com/) | 18 | **16** | 17 | 17 | 17 | 17 | 18 | 18 |
-| [Ground News](https://ground.news/) | 2344 | **2062** | 2064 | 2159 | 2184 | 2188 | 2331 | n/a |
-| [HTML Living Standard](https://html.spec.whatwg.org/multipage/) | 149 | **147** | **147** | 153 | **147** | 149 | 155 | 149 |
+| [Ground News](https://ground.news/) | 2104 | **1841** | 1843 | 1936 | 1959 | 1964 | 2091 | n/a |
+| [HTML Living Standard](https://html.spec.whatwg.org/multipage/) | 149 | 148 | **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 | **190** | 207 | 207 | 207 | 217 | 219 |
+| [Leanpub](https://leanpub.com/) | 229 | 200 | **198** | 214 | 214 | 215 | 225 | 227 |
 | [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 | 202 |
-| [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 |
-| [TetraLogical](https://tetralogical.com/) | 44 | 38 | 38 | **35** | 38 | 39 | 39 | 39 |
+| [MDN](https://developer.mozilla.org/en-US/) | 108 | **62** | **62** | 64 | 64 | 65 | 67 | 67 |
+| [Middle East Eye](https://www.middleeasteye.net/) | 221 | **195** | **195** | 201 | 199 | 199 | 201 | 202 |
+| [Nielsen Norman Group](https://www.nngroup.com/) | 86 | 68 | 74 | **55** | 74 | 75 | 77 | 76 |
+| [SitePoint](https://www.sitepoint.com/) | 491 | **360** | **360** | 431 | 465 | 470 | 488 | n/a |
+| [TetraLogical](https://tetralogical.com/) | 44 | 39 | 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 |
+| [United Nations](https://www.un.org/en/) | 152 | **113** | 115 | 122 | 125 | 125 | 131 | 124 |
 | [W3C](https://www.w3.org/) | 50 | **36** | **36** | 39 | 38 | 38 | 41 | 39 |
-| **Average processing time** |  | 264 ms (26/26) | 365 ms (26/26) | 162 ms (26/26) | 56 ms (26/26) | **16 ms (26/26)** | 323 ms (26/26) | 1373 ms (21/26) |
+| **Average processing time** |  | 246 ms (26/26) | 343 ms (26/26) | 154 ms (26/26) | 54 ms (26/26) | **15 ms (26/26)** | 312 ms (26/26) | 1379 ms (21/26) |
 
-(Last updated: Dec 21, 2025)
+(Last updated: Dec 22, 2025)
 <!-- End auto-generated -->
 
 ## Examples
@@ -332,13 +394,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
 
@@ -356,7 +424,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
 
@@ -369,7 +437,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
 
@@ -384,7 +452,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/cli.js

@@ -140,8 +140,9 @@ 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')],
-  minifyCSS: ['Minify CSS in “style” elements and “style” attributes (uses Lightning CSS)', parseJSON],
-  minifyJS: ['Minify JavaScript in “script” elements and event attributes (uses Terser or SWC; pass “{"engine": "swc"}” for SWC)', parseJSON],
+  minifyCSS: ['Minify CSS in "style" elements and "style" 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],
   minifyURLs: ['Minify URLs in various attributes (uses relateurl)', parseJSON],
   noNewlinesBeforeTagClose: 'Never add a newline before a tag that closes an element',
   partialMarkup: 'Treat input as a partial HTML fragment, preserving stray end tags and unclosed tags',

package/dist/htmlminifier.cjs

@@ -192,7 +192,7 @@ class HTMLParser {
             }
           }
 
-          // https://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
+          // https://web.archive.org/web/20241201212701/https://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
           if (/^<!\[/.test(html)) {
             const conditionalEnd = html.indexOf(']>');
 
@@ -761,6 +761,7 @@ const presets = {
     decodeEntities: true,
     minifyCSS: true,
     minifyJS: true,
+    minifySVG: true,
     minifyURLs: true,
     noNewlinesBeforeTagClose: true,
     processConditionalComments: true,
@@ -1135,10 +1136,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);
 }
 
@@ -1239,6 +1254,279 @@ async function processScript(text, options, currentAttrs, minifyHTML) {
   return text;
 }
 
+/**
+ * Lightweight SVG optimizations:
+ *
+ * - Numeric precision reduction for coordinates and path data
+ * - Whitespace removal in attribute values (numeric sequences)
+ * - Default attribute removal (safe, well-documented defaults)
+ * - Color minification (hex shortening, rgb() to hex)
+ */
+
+/**
+ * Default SVG attribute values that can be safely removed
+ * Only includes well-documented, widely-supported defaults
+ */
+const SVG_DEFAULT_ATTRS = {
+  // Fill and stroke defaults
+  fill: value => value === 'black' || value === '#000' || value === '#000000',
+  'fill-opacity': value => value === '1',
+  'fill-rule': value => value === 'nonzero',
+  stroke: value => value === 'none',
+  'stroke-dasharray': value => value === 'none',
+  'stroke-dashoffset': value => value === '0',
+  'stroke-linecap': value => value === 'butt',
+  'stroke-linejoin': value => value === 'miter',
+  'stroke-miterlimit': value => value === '4',
+  'stroke-opacity': value => value === '1',
+  'stroke-width': value => value === '1',
+
+  // Text and font defaults
+  'font-family': value => value === 'inherit',
+  'font-size': value => value === 'medium',
+  'font-style': value => value === 'normal',
+  'font-variant': value => value === 'normal',
+  'font-weight': value => value === 'normal',
+  'letter-spacing': value => value === 'normal',
+  'text-decoration': value => value === 'none',
+  'text-anchor': value => value === 'start',
+
+  // Other common defaults
+  opacity: value => value === '1',
+  visibility: value => value === 'visible',
+  display: value => value === 'inline',
+  overflow: value => value === 'visible'
+};
+
+/**
+ * Minify numeric value by removing trailing zeros and unnecessary decimals
+ * @param {string} num - Numeric string to minify
+ * @param {number} precision - Maximum decimal places to keep
+ * @returns {string} Minified numeric string
+ */
+function minifyNumber(num, precision = 3) {
+  const parsed = parseFloat(num);
+
+  // Handle special cases
+  if (isNaN(parsed)) return num;
+  if (parsed === 0) return '0';
+  if (!isFinite(parsed)) return num;
+
+  // Convert to fixed precision, then remove trailing zeros
+  const fixed = parsed.toFixed(precision);
+  const trimmed = fixed.replace(/\.?0+$/, '');
+
+  return trimmed || '0';
+}
+
+/**
+ * Minify SVG path data by reducing numeric precision
+ * @param {string} pathData - SVG path data string
+ * @param {number} precision - Decimal precision for coordinates
+ * @returns {string} Minified path data
+ */
+function minifyPathData(pathData, precision = 3) {
+  if (!pathData || typeof pathData !== 'string') return pathData;
+
+  // Match numbers (including scientific notation and negative values)
+  // Regex: optional minus, digits, optional decimal point and more digits, optional exponent
+  return pathData.replace(/-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/g, (match) => {
+    return minifyNumber(match, precision);
+  });
+}
+
+/**
+ * Minify whitespace in numeric attribute values
+ * Examples:
+ *   "10 , 20" → "10,20"
+ *   "translate( 10 20 )" → "translate(10 20)"
+ *   "100, 10  40,  198" → "100,10 40,198"
+ *
+ * @param {string} value - Attribute value to minify
+ * @returns {string} Minified value
+ */
+function minifyAttributeWhitespace(value) {
+  if (!value || typeof value !== 'string') return value;
+
+  return value
+    // Remove spaces around commas
+    .replace(/\s*,\s*/g, ',')
+    // Remove spaces around parentheses
+    .replace(/\(\s+/g, '(')
+    .replace(/\s+\)/g, ')')
+    // Collapse multiple spaces to single space
+    .replace(/\s+/g, ' ')
+    // Trim leading/trailing whitespace
+    .trim();
+}
+
+/**
+ * Minify color values (hex shortening, rgb to hex conversion)
+ * @param {string} color - Color value to minify
+ * @returns {string} Minified color value
+ */
+function minifyColor(color) {
+  if (!color || typeof color !== 'string') return color;
+
+  const trimmed = color.trim().toLowerCase();
+
+  // Shorten 6-digit hex to 3-digit when possible
+  // #aabbcc → #abc, #000000 → #000
+  const hexMatch = trimmed.match(/^#([0-9a-f]{6})$/);
+  if (hexMatch) {
+    const hex = hexMatch[1];
+    if (hex[0] === hex[1] && hex[2] === hex[3] && hex[4] === hex[5]) {
+      return '#' + hex[0] + hex[2] + hex[4];
+    }
+  }
+
+  // Convert rgb(255,255,255) to hex
+  const rgbMatch = trimmed.match(/^rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/);
+  if (rgbMatch) {
+    const r = parseInt(rgbMatch[1], 10);
+    const g = parseInt(rgbMatch[2], 10);
+    const b = parseInt(rgbMatch[3], 10);
+
+    if (r >= 0 && r <= 255 && g >= 0 && g <= 255 && b >= 0 && b <= 255) {
+      const toHex = (n) => {
+        const h = n.toString(16);
+        return h.length === 1 ? '0' + h : h;
+      };
+      const hexColor = '#' + toHex(r) + toHex(g) + toHex(b);
+
+      // Try to shorten if possible
+      if (hexColor[1] === hexColor[2] && hexColor[3] === hexColor[4] && hexColor[5] === hexColor[6]) {
+        return '#' + hexColor[1] + hexColor[3] + hexColor[5];
+      }
+      return hexColor;
+    }
+  }
+
+  return color;
+}
+
+// Attributes that contain numeric sequences or path data
+const NUMERIC_ATTRS = new Set([
+  'd', // Path data
+  'points', // Polygon/polyline points
+  'viewBox', // viewBox coordinates
+  'transform', // Transform functions
+  'x', 'y', 'x1', 'y1', 'x2', 'y2', // Coordinates
+  'cx', 'cy', 'r', 'rx', 'ry', // Circle/ellipse
+  'width', 'height', // Dimensions
+  'dx', 'dy', // Text offsets
+  'offset', // Gradient offset
+  'startOffset', // textPath
+  'pathLength', // Path length
+  'stdDeviation', // Filter params
+  'baseFrequency', // Turbulence
+  'k1', 'k2', 'k3', 'k4' // Composite filter
+]);
+
+// Attributes that contain color values
+const COLOR_ATTRS = new Set([
+  'fill',
+  'stroke',
+  'stop-color',
+  'flood-color',
+  'lighting-color'
+]);
+
+/**
+ * Check if an attribute should be removed based on default value
+ * @param {string} name - Attribute name
+ * @param {string} value - Attribute value
+ * @returns {boolean} True if attribute can be removed
+ */
+function isDefaultAttribute(name, value) {
+  const checker = SVG_DEFAULT_ATTRS[name];
+  if (!checker) return false;
+
+  // Special case: Don’t remove `fill="black"` if stroke exists without fill
+  // This would change the rendering (stroke-only shapes would gain black fill)
+  if (name === 'fill' && checker(value)) {
+    // This check would require looking at other attributes on the same element
+    // For safety, we’ll keep this conservative and not remove `fill="black"`
+    // in the initial implementation. Can be refined later.
+    return false;
+  }
+
+  return checker(value);
+}
+
+/**
+ * Minify SVG attribute value based on attribute name
+ * @param {string} name - Attribute name
+ * @param {string} value - Attribute value
+ * @param {Object} options - Minification options
+ * @returns {string} Minified attribute value
+ */
+function minifySVGAttributeValue(name, value, options = {}) {
+  if (!value || typeof value !== 'string') return value;
+
+  const { precision = 3, minifyColors = true } = options;
+
+  // Path data gets special treatment
+  if (name === 'd') {
+    return minifyPathData(value, precision);
+  }
+
+  // Numeric attributes get precision reduction and whitespace minification
+  if (NUMERIC_ATTRS.has(name)) {
+    const minified = value.replace(/-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/g, (match) => {
+      return minifyNumber(match, precision);
+    });
+    return minifyAttributeWhitespace(minified);
+  }
+
+  // Color attributes get color minification
+  if (minifyColors && COLOR_ATTRS.has(name)) {
+    return minifyColor(value);
+  }
+
+  return value;
+}
+
+/**
+ * Check if an SVG attribute can be removed
+ * @param {string} name - Attribute name
+ * @param {string} value - Attribute value
+ * @param {Object} options - Minification options
+ * @returns {boolean} True if attribute should be removed
+ */
+function shouldRemoveSVGAttribute(name, value, options = {}) {
+  const { removeDefaults = true } = options;
+
+  if (!removeDefaults) return false;
+
+  return isDefaultAttribute(name, value);
+}
+
+/**
+ * Get default SVG minification options
+ * @param {Object} userOptions - User-provided options
+ * @returns {Object} Complete options object with defaults
+ */
+function getSVGMinifierOptions(userOptions) {
+  if (typeof userOptions === 'boolean') {
+    return userOptions ? {
+      precision: 3,
+      removeDefaults: true,
+      minifyColors: true
+    } : null;
+  }
+
+  if (typeof userOptions === 'object' && userOptions !== null) {
+    return {
+      precision: userOptions.precision ?? 3,
+      removeDefaults: userOptions.removeDefaults ?? true,
+      minifyColors: userOptions.minifyColors ?? true
+    };
+  }
+
+  return null;
+}
+
 // Imports
 
 
@@ -1251,7 +1539,8 @@ function shouldMinifyInnerHTML(options) {
     options.removeOptionalTags ||
     options.minifyJS !== identity ||
     options.minifyCSS !== identityAsync ||
-    options.minifyURLs !== identity
+    options.minifyURLs !== identity ||
+    options.minifySVG
   );
 }
 
@@ -1288,7 +1577,8 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, cssM
     log: identity,
     minifyCSS: identityAsync,
     minifyJS: identity,
-    minifyURLs: identity
+    minifyURLs: identity,
+    minifySVG: null
   };
 
   Object.keys(inputOptions).forEach(function (key) {
@@ -1521,6 +1811,11 @@ const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, cssM
           return text;
         }
       };
+    } else if (key === 'minifySVG') {
+      // Process SVG minification options
+      // Unlike minifyCSS/minifyJS, this is a simple options object, not a function
+      // The actual minification is applied inline during attribute processing
+      options.minifySVG = getSVGMinifierOptions(option);
     } else {
       options[key] = option;
     }
@@ -1859,6 +2154,17 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
       return attrValue;
     }
     return minifyHTMLSelf(attrValue, options, true);
+  } else if (options.insideSVG && options.minifySVG) {
+    // Apply SVG-specific attribute minification when inside SVG elements
+    try {
+      return minifySVGAttributeValue(attrName, attrValue, options.minifySVG);
+    } catch (err) {
+      if (!options.continueOnMinifyError) {
+        throw err;
+      }
+      options.log && options.log(err);
+      return attrValue;
+    }
   }
   return attrValue;
 }
@@ -1899,7 +2205,9 @@ async function normalizeAttr(attr, attrs, tag, options, minifyHTML) {
     (options.removeScriptTypeAttributes && tag === 'script' &&
       attrName === 'type' && isScriptTypeAttribute(attrValue) && !keepScriptTypeAttribute(attrValue)) ||
     (options.removeStyleLinkTypeAttributes && (tag === 'style' || tag === 'link') &&
-      attrName === 'type' && isStyleLinkTypeAttribute(attrValue))) {
+      attrName === 'type' && isStyleLinkTypeAttribute(attrValue)) ||
+    (options.insideSVG && options.minifySVG &&
+      shouldRemoveSVGAttribute(attrName, attrValue, options.minifySVG))) {
     return;
   }
 
@@ -2469,6 +2777,16 @@ const jsMinifyCache = new LRU(200);
  *
  *  Default: `false`
  *
+ * @prop {boolean | {precision?: number, removeDefaults?: boolean, minifyColors?: boolean}} [minifySVG]
+ *  When true, enables SVG-specific optimizations for SVG elements and attributes.
+ *  If an object is provided, it can include:
+ *  - `precision`: Number of decimal places for numeric values (coordinates, path data, etc.). Default: `3`
+ *  - `removeDefaults`: Remove attributes with default values (e.g., `fill="black"`). Default: `true`
+ *  - `minifyColors`: Minify color values (hex shortening, rgb to hex conversion). Default: `true`
+ *  If disabled, SVG content is minified using standard HTML rules only.
+ *
+ *  Default: `false`
+ *
  * @prop {(name: string) => string} [name]
  *  Function used to normalise tag/attribute names. By default, this lowercases
  *  names, unless `caseSensitive` is enabled.
@@ -3063,6 +3381,7 @@ async function minifyHTML(value, options, partialMarkup) {
         options.caseSensitive = true;
         options.keepClosingSlash = true;
         options.name = identity;
+        options.insideSVG = lowerTag === 'svg';
       }
       tag = options.name(tag);
       currentTag = tag;