html-minifier-next 4.15.2 → 4.16.1

package/README.md

@@ -358,41 +358,39 @@ 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 | **50** | 51 | 52 | 51 | 54 | 52 |
-| [Apple](https://www.apple.com/) | 266 | **206** | 236 | 239 | 240 | 242 | 243 |
-| [BBC](https://www.bbc.co.uk/) | 643 | **584** | 603 | 604 | 605 | 638 | n/a |
+| [Apple](https://www.apple.com/) | 211 | **177** | 188 | 190 | 191 | 192 | 193 |
+| [BBC](https://www.bbc.co.uk/) | 675 | **614** | 633 | 634 | 635 | 669 | n/a |
 | [CERN](https://home.cern/) | 152 | **83** | 91 | 91 | 91 | 93 | 96 |
 | [CSS-Tricks](https://css-tricks.com/) | 162 | **119** | 127 | 143 | 143 | 148 | 144 |
 | [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 | 49 | 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/) | 1564 | 1457 | **1404** | 1489 | 1500 | 1511 | n/a |
+| [FAZ](https://www.faz.net/aktuell/) | 1579 | 1468 | **1414** | 1503 | 1514 | 1525 | n/a |
 | [French Tech](https://lafrenchtech.gouv.fr/) | 153 | **122** | 126 | 126 | 126 | 132 | 127 |
-| [Frontend Dogma](https://frontenddogma.com/) | 225 | **217** | 238 | 223 | 225 | 243 | 224 |
-| [Google](https://www.google.com/) | 76 | **71** | n/a | 72 | 73 | 75 | 75 |
-| [Ground News](https://ground.news/) | 2373 | **2089** | 2185 | 2211 | 2213 | 2360 | n/a |
+| [Frontend Dogma](https://frontenddogma.com/) | 225 | **217** | 238 | 223 | 225 | 244 | 225 |
+| [Google](https://www.google.com/) | 18 | **16** | 17 | 17 | 17 | 18 | 18 |
 | [HTML Living Standard](https://html.spec.whatwg.org/multipage/) | 149 | 148 | 153 | **147** | 149 | 155 | 149 |
 | [Igalia](https://www.igalia.com/) | 50 | **33** | 36 | 36 | 36 | 37 | 36 |
-| [Leanpub](https://leanpub.com/) | 229 | **199** | 214 | 213 | 214 | 224 | 226 |
+| [Leanpub](https://leanpub.com/) | 231 | **202** | 216 | 216 | 217 | 227 | 229 |
 | [Mastodon](https://mastodon.social/explore) | 37 | **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/) | 223 | **196** | 203 | 201 | 200 | 202 | 203 |
-| [Mistral AI](https://mistral.ai/) | 360 | **319** | 323 | 326 | 327 | 357 | n/a |
+| [MDN](https://developer.mozilla.org/en-US/) | 106 | **60** | 62 | 63 | 63 | 66 | 66 |
+| [Middle East Eye](https://www.middleeasteye.net/) | 223 | **197** | 203 | 201 | 201 | 203 | 204 |
+| [Mistral AI](https://mistral.ai/) | 361 | **319** | 324 | 326 | 327 | 357 | n/a |
 | [Mozilla](https://www.mozilla.org/) | 45 | **31** | 34 | 34 | 34 | 35 | 35 |
 | [Nielsen Norman Group](https://www.nngroup.com/) | 86 | 68 | **55** | 74 | 75 | 77 | 76 |
-| [SitePoint](https://www.sitepoint.com/) | 491 | **360** | 431 | 465 | 470 | 488 | n/a |
 | [Startup-Verband](https://startupverband.de/) | 42 | **29** | 30 | 30 | 30 | 31 | 30 |
-| [TetraLogical](https://tetralogical.com/) | 44 | 39 | **35** | 38 | 39 | 39 | 39 |
+| [TetraLogical](https://tetralogical.com/) | 44 | 38 | **35** | 38 | 39 | 39 | 39 |
 | [TPGi](https://www.tpgi.com/) | 175 | **159** | 160 | 164 | 166 | 172 | 172 |
-| [United Nations](https://www.un.org/en/) | 151 | **112** | 121 | 125 | 125 | 130 | 123 |
+| [United Nations](https://www.un.org/en/) | 152 | **112** | 121 | 125 | 125 | 130 | 123 |
 | [Vivaldi](https://vivaldi.com/) | 92 | **74** | n/a | 79 | 81 | 83 | 81 |
 | [W3C](https://www.w3.org/) | 50 | **36** | 39 | 38 | 38 | 41 | 39 |
-| **Average processing time** |  | 121 ms (30/30) | 648 ms (28/30) | 50 ms (30/30) | **14 ms (30/30)** | 275 ms (30/30) | 1409 ms (24/30) |
+| **Average processing time** |  | 120 ms (28/28) | 138 ms (27/28) | 41 ms (28/28) | **14 ms (28/28)** | 283 ms (28/28) | 1349 ms (24/28) |
 
-(Last updated: Dec 23, 2025)
+(Last updated: Dec 26, 2025)
 <!-- End auto-generated -->
 
-Notes: htmlnano runs in an isolated process for crash protection, adding ~50–100ms overhead per test. 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.
+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.
 
 ## Examples
 

package/dist/htmlminifier.cjs

@@ -624,37 +624,29 @@ class Sorter {
     for (let i = 0, len = this.keys.length; i < len; i++) {
       const token = this.keys[i];
 
-      // Build position map for this token to avoid repeated `indexOf`
-      const positions = [];
+      // Single pass: Count matches and collect non-matches
+      let matchCount = 0;
+      const others = [];
+
       for (let j = fromIndex; j < tokens.length; j++) {
         if (tokens[j] === token) {
-          positions.push(j);
+          matchCount++;
+        } else {
+          others.push(tokens[j]);
         }
       }
 
-      if (positions.length > 0) {
-        // Build new array with tokens in sorted order instead of splicing
-        const result = [];
-
-        // Add all instances of the current token first
-        for (let j = 0; j < positions.length; j++) {
-          result.push(token);
+      if (matchCount > 0) {
+        // Rebuild: `matchCount` instances of token first, then others
+        let writeIdx = fromIndex;
+        for (let j = 0; j < matchCount; j++) {
+          tokens[writeIdx++] = token;
         }
-
-        // Add other tokens, skipping positions where current token was
-        const posSet = new Set(positions);
-        for (let j = fromIndex; j < tokens.length; j++) {
-          if (!posSet.has(j)) {
-            result.push(tokens[j]);
-          }
+        for (let j = 0; j < others.length; j++) {
+          tokens[writeIdx++] = others[j];
         }
 
-        // Copy sorted portion back to tokens array
-        for (let j = 0; j < result.length; j++) {
-          tokens[fromIndex + j] = result[j];
-        }
-
-        const newFromIndex = fromIndex + positions.length;
+        const newFromIndex = fromIndex + matchCount;
         return this.sorterMap.get(token).sort(tokens, newFromIndex);
       }
     }
@@ -1260,8 +1252,31 @@ async function processScript(text, options, currentAttrs, minifyHTML) {
  * - 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)
+ * - Color minification (hex shortening, rgb() to hex, named colors)
+ * - Identity transform removal
+ * - Path data space optimization
+ */
+
+
+// Cache for minified numbers
+const numberCache = new LRU(100);
+
+/**
+ * Named colors that are shorter than their hex equivalents
+ * Only includes cases where using the name saves bytes
  */
+const NAMED_COLORS = {
+  '#f00': 'red',        // #f00 (4) → red (3), saves 1
+  '#c0c0c0': 'silver',  // #c0c0c0 (7) → silver (6), saves 1
+  '#808080': 'gray',    // #808080 (7) → gray (4), saves 3
+  '#800000': 'maroon',  // #800000 (7) → maroon (6), saves 1
+  '#808000': 'olive',   // #808000 (7) → olive (5), saves 2
+  '#008000': 'green',   // #008000 (7) → green (5), saves 2
+  '#800080': 'purple',  // #800080 (7) → purple (6), saves 1
+  '#008080': 'teal',    // #008080 (7) → teal (4), saves 3
+  '#000080': 'navy',    // #000080 (7) → navy (4), saves 3
+  '#ffa500': 'orange'   // #ffa500 (7) → orange (6), saves 1
+};
 
 /**
  * Default SVG attribute values that can be safely removed
@@ -1295,7 +1310,22 @@ const SVG_DEFAULT_ATTRS = {
   opacity: value => value === '1',
   visibility: value => value === 'visible',
   display: value => value === 'inline',
-  overflow: value => value === 'visible'
+  // Note: Overflow handled especially in `isDefaultAttribute` (not safe for root `<svg>`)
+
+  // Clipping and masking defaults
+  'clip-rule': value => value === 'nonzero',
+  'clip-path': value => value === 'none',
+  mask: value => value === 'none',
+
+  // Marker defaults
+  'marker-start': value => value === 'none',
+  'marker-mid': value => value === 'none',
+  'marker-end': value => value === 'none',
+
+  // Filter and color defaults
+  filter: value => value === 'none',
+  'color-interpolation': value => value === 'sRGB',
+  'color-interpolation-filters': value => value === 'linearRGB'
 };
 
 /**
@@ -1305,6 +1335,20 @@ const SVG_DEFAULT_ATTRS = {
  * @returns {string} Minified numeric string
  */
 function minifyNumber(num, precision = 3) {
+  // Fast path for common values (avoids parsing and caching)
+  if (num === '0' || num === '1') return num;
+  // Common decimal variants that tools export
+  if (num === '0.0' || num === '0.00' || num === '0.000') return '0';
+  if (num === '1.0' || num === '1.00' || num === '1.000') return '1';
+
+  // Check cache
+  // (Note: uses input string as key, so “0.0000” and “0.00000” create separate entries.
+  // This is intentional to avoid parsing overhead.
+  // Real-world SVG files from export tools typically use consistent formats.)
+  const cacheKey = `${num}:${precision}`;
+  const cached = numberCache.get(cacheKey);
+  if (cached !== undefined) return cached;
+
   const parsed = parseFloat(num);
 
   // Handle special cases
@@ -1316,11 +1360,13 @@ function minifyNumber(num, precision = 3) {
   const fixed = parsed.toFixed(precision);
   const trimmed = fixed.replace(/\.?0+$/, '');
 
-  return trimmed || '0';
+  const result = trimmed || '0';
+  numberCache.set(cacheKey, result);
+  return result;
 }
 
 /**
- * Minify SVG path data by reducing numeric precision
+ * Minify SVG path data by reducing numeric precision and removing unnecessary spaces
  * @param {string} pathData - SVG path data string
  * @param {number} precision - Decimal precision for coordinates
  * @returns {string} Minified path data
@@ -1328,11 +1374,25 @@ function minifyNumber(num, precision = 3) {
 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) => {
+  // First, minify all numbers
+  let result = pathData.replace(/-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/g, (match) => {
     return minifyNumber(match, precision);
   });
+
+  // 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 before command letter when preceded by a number
+  // 0 L → 0L, 20 M → 20M
+  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');
+
+  return result;
 }
 
 /**
@@ -1361,27 +1421,49 @@ function minifyAttributeWhitespace(value) {
 }
 
 /**
- * Minify color values (hex shortening, rgb to hex conversion)
+ * Minify color values (hex shortening, rgb to hex conversion, named colors)
+ * Only processes simple color values; preserves case-sensitive references like `url(#id)`
  * @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();
+  const trimmed = color.trim();
+
+  // Don’t process values that aren’t simple colors (preserve case-sensitive references)
+  // `url(#id)`, `var(--name)`, `inherit`, `currentColor`, etc.
+  if (trimmed.includes('url(') || trimmed.includes('var(') ||
+      trimmed === 'inherit' || trimmed === 'currentColor') {
+    return trimmed;
+  }
+
+  // Now safe to lowercase for color matching
+  const lower = trimmed.toLowerCase();
 
   // Shorten 6-digit hex to 3-digit when possible
   // #aabbcc → #abc, #000000 → #000
-  const hexMatch = trimmed.match(/^#([0-9a-f]{6})$/);
+  const hexMatch = lower.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];
+      const shortened = '#' + hex[0] + hex[2] + hex[4];
+      // Try to use named color if shorter
+      return NAMED_COLORS[shortened] || shortened;
     }
+    // Can’t shorten, but check for named color
+    return NAMED_COLORS[lower] || lower;
+  }
+
+  // Match 3-digit hex colors
+  const hex3Match = lower.match(/^#[0-9a-f]{3}$/);
+  if (hex3Match) {
+    // Check if there’s a shorter named color
+    return NAMED_COLORS[lower] || lower;
   }
 
   // Convert rgb(255,255,255) to hex
-  const rgbMatch = trimmed.match(/^rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/);
+  const rgbMatch = lower.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);
@@ -1396,13 +1478,15 @@ function minifyColor(color) {
 
       // 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];
+        const shortened = '#' + hexColor[1] + hexColor[3] + hexColor[5];
+        return NAMED_COLORS[shortened] || shortened;
       }
-      return hexColor;
+      return NAMED_COLORS[hexColor] || hexColor;
     }
   }
 
-  return color;
+  // Not a recognized color format, return as-is (preserves case)
+  return trimmed;
 }
 
 // Attributes that contain numeric sequences or path data
@@ -1432,13 +1516,58 @@ const COLOR_ATTRS = new Set([
   'lighting-color'
 ]);
 
+// Pre-compiled regexes for identity transform detection (compiled once at module load)
+// Separator pattern: Accepts comma with optional spaces or one or more spaces
+const SEP = '(?:\\s*,\\s*|\\s+)';
+
+// `translate(0)`, `translate(0,0)`, `translate(0 0)` (matches 0, 0.0, 0.00, etc.)
+const IDENTITY_TRANSLATE_RE = new RegExp(`^translate\\s*\\(\\s*0(?:\\.0+)?\\s*(?:${SEP}0(?:\\.0+)?\\s*)?\\)$`, 'i');
+
+// `scale(1)`, `scale(1,1)`, `scale(1 1)` (matches 1, 1.0, 1.00, etc.)
+const IDENTITY_SCALE_RE = new RegExp(`^scale\\s*\\(\\s*1(?:\\.0+)?\\s*(?:${SEP}1(?:\\.0+)?\\s*)?\\)$`, 'i');
+
+// `rotate(0)`, `rotate(0 cx cy)`, `rotate(0, cx, cy)` (matches 0, 0.0, 0.00, etc.)
+// Note: `cx` and `cy` must be valid numbers if present
+const IDENTITY_ROTATE_RE = new RegExp(`^rotate\\s*\\(\\s*0(?:\\.0+)?\\s*(?:${SEP}-?\\d+(?:\\.\\d+)?${SEP}-?\\d+(?:\\.\\d+)?)?\\s*\\)$`, 'i');
+
+// `skewX(0)`, `skewY(0)` (matches 0, 0.0, 0.00, etc.)
+const IDENTITY_SKEW_RE = /^skew[XY]\s*\(\s*0(?:\.0+)?\s*\)$/i;
+
+// `matrix(1,0,0,1,0,0)`, `matrix(1 0 0 1 0 0)`—identity matrix (matches 1.0/0.0 variants)
+const IDENTITY_MATRIX_RE = new RegExp(`^matrix\\s*\\(\\s*1(?:\\.0+)?\\s*${SEP}0(?:\\.0+)?\\s*${SEP}0(?:\\.0+)?\\s*${SEP}1(?:\\.0+)?\\s*${SEP}0(?:\\.0+)?\\s*${SEP}0(?:\\.0+)?\\s*\\)$`, 'i');
+
+/**
+ * Check if a transform attribute has no effect (identity transform)
+ * @param {string} transform - Transform attribute value
+ * @returns {boolean} True if transform is an identity (has no effect)
+ */
+function isIdentityTransform(transform) {
+  if (!transform || typeof transform !== 'string') return false;
+
+  const trimmed = transform.trim();
+
+  // Check for common identity transforms using pre-compiled regexes
+  return IDENTITY_TRANSLATE_RE.test(trimmed) ||
+         IDENTITY_SCALE_RE.test(trimmed) ||
+         IDENTITY_ROTATE_RE.test(trimmed) ||
+         IDENTITY_SKEW_RE.test(trimmed) ||
+         IDENTITY_MATRIX_RE.test(trimmed);
+}
+
 /**
  * Check if an attribute should be removed based on default value
+ * @param {string} tag - Element tag name (e.g., `svg`, `rect`, `path`)
  * @param {string} name - Attribute name
  * @param {string} value - Attribute value
  * @returns {boolean} True if attribute can be removed
  */
-function isDefaultAttribute(name, value) {
+function isDefaultAttribute(tag, name, value) {
+  // Special case: `overflow="visible"` is unsafe for root `<svg>` element
+  // Root SVG may need explicit `overflow="visible"` to show clipped content
+  if (name === 'overflow' && value === 'visible') {
+    return tag !== 'svg'; // Only remove for non-root SVG elements
+  }
+
   const checker = SVG_DEFAULT_ATTRS[name];
   if (!checker) return false;
 
@@ -1489,17 +1618,23 @@ function minifySVGAttributeValue(name, value, options = {}) {
 
 /**
  * Check if an SVG attribute can be removed
+ * @param {string} tag - Element tag name (e.g., `svg`, `rect`, `path`)
  * @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 = {}) {
+function shouldRemoveSVGAttribute(tag, name, value, options = {}) {
   const { removeDefaults = true } = options;
 
   if (!removeDefaults) return false;
 
-  return isDefaultAttribute(name, value);
+  // Check for identity transforms
+  if (name === 'transform' && isIdentityTransform(value)) {
+    return true;
+  }
+
+  return isDefaultAttribute(tag, name, value);
 }
 
 /**
@@ -2067,7 +2202,15 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
   // Apply early whitespace normalization if enabled
   // Preserves special spaces (non-breaking space, hair space, etc.) for consistency with `collapseWhitespace`
   if (options.collapseAttributeWhitespace) {
-    attrValue = attrValue.replace(/[ \n\r\t\f]+/g, ' ').replace(/^[ \n\r\t\f]+|[ \n\r\t\f]+$/g, '');
+    // Single-pass: Trim leading/trailing whitespace and collapse internal whitespace to single space
+    attrValue = attrValue.replace(/^[ \n\r\t\f]+|[ \n\r\t\f]+$|[ \n\r\t\f]+/g, function(match, offset, str) {
+      // Leading whitespace (`offset === 0`)
+      if (offset === 0) return '';
+      // Trailing whitespace (match ends at string end)
+      if (offset + match.length === str.length) return '';
+      // Internal whitespace
+      return ' ';
+    });
   }
 
   if (isEventAttribute(attrName, options)) {
@@ -2241,7 +2384,7 @@ async function normalizeAttr(attr, attrs, tag, options, minifyHTML) {
     (options.removeStyleLinkTypeAttributes && (tag === 'style' || tag === 'link') &&
       attrName === 'type' && isStyleLinkTypeAttribute(attrValue)) ||
     (options.insideSVG && options.minifySVG &&
-      shouldRemoveSVGAttribute(attrName, attrValue, options.minifySVG))) {
+      shouldRemoveSVGAttribute(tag, attrName, attrValue, options.minifySVG))) {
     return;
   }
 

package/dist/htmlminifier.esm.bundle.js

@@ -3236,37 +3236,29 @@ class Sorter {
     for (let i = 0, len = this.keys.length; i < len; i++) {
       const token = this.keys[i];
 
-      // Build position map for this token to avoid repeated `indexOf`
-      const positions = [];
+      // Single pass: Count matches and collect non-matches
+      let matchCount = 0;
+      const others = [];
+
       for (let j = fromIndex; j < tokens.length; j++) {
         if (tokens[j] === token) {
-          positions.push(j);
+          matchCount++;
+        } else {
+          others.push(tokens[j]);
         }
       }
 
-      if (positions.length > 0) {
-        // Build new array with tokens in sorted order instead of splicing
-        const result = [];
-
-        // Add all instances of the current token first
-        for (let j = 0; j < positions.length; j++) {
-          result.push(token);
+      if (matchCount > 0) {
+        // Rebuild: `matchCount` instances of token first, then others
+        let writeIdx = fromIndex;
+        for (let j = 0; j < matchCount; j++) {
+          tokens[writeIdx++] = token;
         }
-
-        // Add other tokens, skipping positions where current token was
-        const posSet = new Set(positions);
-        for (let j = fromIndex; j < tokens.length; j++) {
-          if (!posSet.has(j)) {
-            result.push(tokens[j]);
-          }
+        for (let j = 0; j < others.length; j++) {
+          tokens[writeIdx++] = others[j];
         }
 
-        // Copy sorted portion back to tokens array
-        for (let j = 0; j < result.length; j++) {
-          tokens[fromIndex + j] = result[j];
-        }
-
-        const newFromIndex = fromIndex + positions.length;
+        const newFromIndex = fromIndex + matchCount;
         return this.sorterMap.get(token).sort(tokens, newFromIndex);
       }
     }
@@ -6402,8 +6394,31 @@ async function processScript(text, options, currentAttrs, minifyHTML) {
  * - 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)
+ * - Color minification (hex shortening, rgb() to hex, named colors)
+ * - Identity transform removal
+ * - Path data space optimization
+ */
+
+
+// Cache for minified numbers
+const numberCache = new LRU(100);
+
+/**
+ * Named colors that are shorter than their hex equivalents
+ * Only includes cases where using the name saves bytes
  */
+const NAMED_COLORS = {
+  '#f00': 'red',        // #f00 (4) → red (3), saves 1
+  '#c0c0c0': 'silver',  // #c0c0c0 (7) → silver (6), saves 1
+  '#808080': 'gray',    // #808080 (7) → gray (4), saves 3
+  '#800000': 'maroon',  // #800000 (7) → maroon (6), saves 1
+  '#808000': 'olive',   // #808000 (7) → olive (5), saves 2
+  '#008000': 'green',   // #008000 (7) → green (5), saves 2
+  '#800080': 'purple',  // #800080 (7) → purple (6), saves 1
+  '#008080': 'teal',    // #008080 (7) → teal (4), saves 3
+  '#000080': 'navy',    // #000080 (7) → navy (4), saves 3
+  '#ffa500': 'orange'   // #ffa500 (7) → orange (6), saves 1
+};
 
 /**
  * Default SVG attribute values that can be safely removed
@@ -6437,7 +6452,22 @@ const SVG_DEFAULT_ATTRS = {
   opacity: value => value === '1',
   visibility: value => value === 'visible',
   display: value => value === 'inline',
-  overflow: value => value === 'visible'
+  // Note: Overflow handled especially in `isDefaultAttribute` (not safe for root `<svg>`)
+
+  // Clipping and masking defaults
+  'clip-rule': value => value === 'nonzero',
+  'clip-path': value => value === 'none',
+  mask: value => value === 'none',
+
+  // Marker defaults
+  'marker-start': value => value === 'none',
+  'marker-mid': value => value === 'none',
+  'marker-end': value => value === 'none',
+
+  // Filter and color defaults
+  filter: value => value === 'none',
+  'color-interpolation': value => value === 'sRGB',
+  'color-interpolation-filters': value => value === 'linearRGB'
 };
 
 /**
@@ -6447,6 +6477,20 @@ const SVG_DEFAULT_ATTRS = {
  * @returns {string} Minified numeric string
  */
 function minifyNumber(num, precision = 3) {
+  // Fast path for common values (avoids parsing and caching)
+  if (num === '0' || num === '1') return num;
+  // Common decimal variants that tools export
+  if (num === '0.0' || num === '0.00' || num === '0.000') return '0';
+  if (num === '1.0' || num === '1.00' || num === '1.000') return '1';
+
+  // Check cache
+  // (Note: uses input string as key, so “0.0000” and “0.00000” create separate entries.
+  // This is intentional to avoid parsing overhead.
+  // Real-world SVG files from export tools typically use consistent formats.)
+  const cacheKey = `${num}:${precision}`;
+  const cached = numberCache.get(cacheKey);
+  if (cached !== undefined) return cached;
+
   const parsed = parseFloat(num);
 
   // Handle special cases
@@ -6458,11 +6502,13 @@ function minifyNumber(num, precision = 3) {
   const fixed = parsed.toFixed(precision);
   const trimmed = fixed.replace(/\.?0+$/, '');
 
-  return trimmed || '0';
+  const result = trimmed || '0';
+  numberCache.set(cacheKey, result);
+  return result;
 }
 
 /**
- * Minify SVG path data by reducing numeric precision
+ * Minify SVG path data by reducing numeric precision and removing unnecessary spaces
  * @param {string} pathData - SVG path data string
  * @param {number} precision - Decimal precision for coordinates
  * @returns {string} Minified path data
@@ -6470,11 +6516,25 @@ function minifyNumber(num, precision = 3) {
 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) => {
+  // First, minify all numbers
+  let result = pathData.replace(/-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/g, (match) => {
     return minifyNumber(match, precision);
   });
+
+  // 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 before command letter when preceded by a number
+  // 0 L → 0L, 20 M → 20M
+  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');
+
+  return result;
 }
 
 /**
@@ -6503,27 +6563,49 @@ function minifyAttributeWhitespace(value) {
 }
 
 /**
- * Minify color values (hex shortening, rgb to hex conversion)
+ * Minify color values (hex shortening, rgb to hex conversion, named colors)
+ * Only processes simple color values; preserves case-sensitive references like `url(#id)`
  * @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();
+  const trimmed = color.trim();
+
+  // Don’t process values that aren’t simple colors (preserve case-sensitive references)
+  // `url(#id)`, `var(--name)`, `inherit`, `currentColor`, etc.
+  if (trimmed.includes('url(') || trimmed.includes('var(') ||
+      trimmed === 'inherit' || trimmed === 'currentColor') {
+    return trimmed;
+  }
+
+  // Now safe to lowercase for color matching
+  const lower = trimmed.toLowerCase();
 
   // Shorten 6-digit hex to 3-digit when possible
   // #aabbcc → #abc, #000000 → #000
-  const hexMatch = trimmed.match(/^#([0-9a-f]{6})$/);
+  const hexMatch = lower.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];
+      const shortened = '#' + hex[0] + hex[2] + hex[4];
+      // Try to use named color if shorter
+      return NAMED_COLORS[shortened] || shortened;
     }
+    // Can’t shorten, but check for named color
+    return NAMED_COLORS[lower] || lower;
+  }
+
+  // Match 3-digit hex colors
+  const hex3Match = lower.match(/^#[0-9a-f]{3}$/);
+  if (hex3Match) {
+    // Check if there’s a shorter named color
+    return NAMED_COLORS[lower] || lower;
   }
 
   // Convert rgb(255,255,255) to hex
-  const rgbMatch = trimmed.match(/^rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/);
+  const rgbMatch = lower.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);
@@ -6538,13 +6620,15 @@ function minifyColor(color) {
 
       // 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];
+        const shortened = '#' + hexColor[1] + hexColor[3] + hexColor[5];
+        return NAMED_COLORS[shortened] || shortened;
       }
-      return hexColor;
+      return NAMED_COLORS[hexColor] || hexColor;
     }
   }
 
-  return color;
+  // Not a recognized color format, return as-is (preserves case)
+  return trimmed;
 }
 
 // Attributes that contain numeric sequences or path data
@@ -6574,13 +6658,58 @@ const COLOR_ATTRS = new Set([
   'lighting-color'
 ]);
 
+// Pre-compiled regexes for identity transform detection (compiled once at module load)
+// Separator pattern: Accepts comma with optional spaces or one or more spaces
+const SEP = '(?:\\s*,\\s*|\\s+)';
+
+// `translate(0)`, `translate(0,0)`, `translate(0 0)` (matches 0, 0.0, 0.00, etc.)
+const IDENTITY_TRANSLATE_RE = new RegExp(`^translate\\s*\\(\\s*0(?:\\.0+)?\\s*(?:${SEP}0(?:\\.0+)?\\s*)?\\)$`, 'i');
+
+// `scale(1)`, `scale(1,1)`, `scale(1 1)` (matches 1, 1.0, 1.00, etc.)
+const IDENTITY_SCALE_RE = new RegExp(`^scale\\s*\\(\\s*1(?:\\.0+)?\\s*(?:${SEP}1(?:\\.0+)?\\s*)?\\)$`, 'i');
+
+// `rotate(0)`, `rotate(0 cx cy)`, `rotate(0, cx, cy)` (matches 0, 0.0, 0.00, etc.)
+// Note: `cx` and `cy` must be valid numbers if present
+const IDENTITY_ROTATE_RE = new RegExp(`^rotate\\s*\\(\\s*0(?:\\.0+)?\\s*(?:${SEP}-?\\d+(?:\\.\\d+)?${SEP}-?\\d+(?:\\.\\d+)?)?\\s*\\)$`, 'i');
+
+// `skewX(0)`, `skewY(0)` (matches 0, 0.0, 0.00, etc.)
+const IDENTITY_SKEW_RE = /^skew[XY]\s*\(\s*0(?:\.0+)?\s*\)$/i;
+
+// `matrix(1,0,0,1,0,0)`, `matrix(1 0 0 1 0 0)`—identity matrix (matches 1.0/0.0 variants)
+const IDENTITY_MATRIX_RE = new RegExp(`^matrix\\s*\\(\\s*1(?:\\.0+)?\\s*${SEP}0(?:\\.0+)?\\s*${SEP}0(?:\\.0+)?\\s*${SEP}1(?:\\.0+)?\\s*${SEP}0(?:\\.0+)?\\s*${SEP}0(?:\\.0+)?\\s*\\)$`, 'i');
+
+/**
+ * Check if a transform attribute has no effect (identity transform)
+ * @param {string} transform - Transform attribute value
+ * @returns {boolean} True if transform is an identity (has no effect)
+ */
+function isIdentityTransform(transform) {
+  if (!transform || typeof transform !== 'string') return false;
+
+  const trimmed = transform.trim();
+
+  // Check for common identity transforms using pre-compiled regexes
+  return IDENTITY_TRANSLATE_RE.test(trimmed) ||
+         IDENTITY_SCALE_RE.test(trimmed) ||
+         IDENTITY_ROTATE_RE.test(trimmed) ||
+         IDENTITY_SKEW_RE.test(trimmed) ||
+         IDENTITY_MATRIX_RE.test(trimmed);
+}
+
 /**
  * Check if an attribute should be removed based on default value
+ * @param {string} tag - Element tag name (e.g., `svg`, `rect`, `path`)
  * @param {string} name - Attribute name
  * @param {string} value - Attribute value
  * @returns {boolean} True if attribute can be removed
  */
-function isDefaultAttribute(name, value) {
+function isDefaultAttribute(tag, name, value) {
+  // Special case: `overflow="visible"` is unsafe for root `<svg>` element
+  // Root SVG may need explicit `overflow="visible"` to show clipped content
+  if (name === 'overflow' && value === 'visible') {
+    return tag !== 'svg'; // Only remove for non-root SVG elements
+  }
+
   const checker = SVG_DEFAULT_ATTRS[name];
   if (!checker) return false;
 
@@ -6631,17 +6760,23 @@ function minifySVGAttributeValue(name, value, options = {}) {
 
 /**
  * Check if an SVG attribute can be removed
+ * @param {string} tag - Element tag name (e.g., `svg`, `rect`, `path`)
  * @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 = {}) {
+function shouldRemoveSVGAttribute(tag, name, value, options = {}) {
   const { removeDefaults = true } = options;
 
   if (!removeDefaults) return false;
 
-  return isDefaultAttribute(name, value);
+  // Check for identity transforms
+  if (name === 'transform' && isIdentityTransform(value)) {
+    return true;
+  }
+
+  return isDefaultAttribute(tag, name, value);
 }
 
 /**
@@ -7209,7 +7344,15 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
   // Apply early whitespace normalization if enabled
   // Preserves special spaces (non-breaking space, hair space, etc.) for consistency with `collapseWhitespace`
   if (options.collapseAttributeWhitespace) {
-    attrValue = attrValue.replace(/[ \n\r\t\f]+/g, ' ').replace(/^[ \n\r\t\f]+|[ \n\r\t\f]+$/g, '');
+    // Single-pass: Trim leading/trailing whitespace and collapse internal whitespace to single space
+    attrValue = attrValue.replace(/^[ \n\r\t\f]+|[ \n\r\t\f]+$|[ \n\r\t\f]+/g, function(match, offset, str) {
+      // Leading whitespace (`offset === 0`)
+      if (offset === 0) return '';
+      // Trailing whitespace (match ends at string end)
+      if (offset + match.length === str.length) return '';
+      // Internal whitespace
+      return ' ';
+    });
   }
 
   if (isEventAttribute(attrName, options)) {
@@ -7383,7 +7526,7 @@ async function normalizeAttr(attr, attrs, tag, options, minifyHTML) {
     (options.removeStyleLinkTypeAttributes && (tag === 'style' || tag === 'link') &&
       attrName === 'type' && isStyleLinkTypeAttribute(attrValue)) ||
     (options.insideSVG && options.minifySVG &&
-      shouldRemoveSVGAttribute(attrName, attrValue, options.minifySVG))) {
+      shouldRemoveSVGAttribute(tag, attrName, attrValue, options.minifySVG))) {
     return;
   }
 

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

@@ -1 +1 @@
-{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../src/lib/attributes.js"],"names":[],"mappings":"AAuBA,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,0IA0IC;AAsBD;;;;GAwCC;AAED,6GA4EC"}
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../src/lib/attributes.js"],"names":[],"mappings":"AAuBA,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,0IAkJC;AAsBD;;;;GAwCC;AAED,6GA4EC"}

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

@@ -8,12 +8,13 @@
 export function minifySVGAttributeValue(name: string, value: string, options?: any): string;
 /**
  * Check if an SVG attribute can be removed
+ * @param {string} tag - Element tag name (e.g., `svg`, `rect`, `path`)
  * @param {string} name - Attribute name
  * @param {string} value - Attribute value
  * @param {Object} options - Minification options
  * @returns {boolean} True if attribute should be removed
  */
-export function shouldRemoveSVGAttribute(name: string, value: string, options?: any): boolean;
+export function shouldRemoveSVGAttribute(tag: string, name: string, value: string, options?: any): boolean;
 /**
  * Get default SVG minification options
  * @param {Object} userOptions - User-provided options

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

@@ -1 +1 @@
-{"version":3,"file":"svg.d.ts","sourceRoot":"","sources":["../../../src/lib/svg.js"],"names":[],"mappings":"AAwMA;;;;;;GAMG;AACH,8CALW,MAAM,SACN,MAAM,kBAEJ,MAAM,CA0BlB;AAED;;;;;;GAMG;AACH,+CALW,MAAM,SACN,MAAM,kBAEJ,OAAO,CAQnB;AAED;;;;GAIG;AACH,6DAkBC"}
+{"version":3,"file":"svg.d.ts","sourceRoot":"","sources":["../../../src/lib/svg.js"],"names":[],"mappings":"AAkVA;;;;;;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/tokenchain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tokenchain.d.ts","sourceRoot":"","sources":["../../src/tokenchain.js"],"names":[],"mappings":";AA2CA;IAGI,mBAAoB;IAGtB,uBAOC;IAED,uBAiDC;CACF;AA5GD;IACE,2CAuCC;CACF"}
+{"version":3,"file":"tokenchain.d.ts","sourceRoot":"","sources":["../../src/tokenchain.js"],"names":[],"mappings":";AAmCA;IAGI,mBAAoB;IAGtB,uBAOC;IAED,uBAiDC;CACF;AApGD;IACE,2CA+BC;CACF"}

package/package.json

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

package/src/lib/attributes.js

@@ -226,7 +226,15 @@ async function cleanAttributeValue(tag, attrName, attrValue, options, attrs, min
   // Apply early whitespace normalization if enabled
   // Preserves special spaces (non-breaking space, hair space, etc.) for consistency with `collapseWhitespace`
   if (options.collapseAttributeWhitespace) {
-    attrValue = attrValue.replace(/[ \n\r\t\f]+/g, ' ').replace(/^[ \n\r\t\f]+|[ \n\r\t\f]+$/g, '');
+    // Single-pass: Trim leading/trailing whitespace and collapse internal whitespace to single space
+    attrValue = attrValue.replace(/^[ \n\r\t\f]+|[ \n\r\t\f]+$|[ \n\r\t\f]+/g, function(match, offset, str) {
+      // Leading whitespace (`offset === 0`)
+      if (offset === 0) return '';
+      // Trailing whitespace (match ends at string end)
+      if (offset + match.length === str.length) return '';
+      // Internal whitespace
+      return ' ';
+    });
   }
 
   if (isEventAttribute(attrName, options)) {
@@ -400,7 +408,7 @@ async function normalizeAttr(attr, attrs, tag, options, minifyHTML) {
     (options.removeStyleLinkTypeAttributes && (tag === 'style' || tag === 'link') &&
       attrName === 'type' && isStyleLinkTypeAttribute(attrValue)) ||
     (options.insideSVG && options.minifySVG &&
-      shouldRemoveSVGAttribute(attrName, attrValue, options.minifySVG))) {
+      shouldRemoveSVGAttribute(tag, attrName, attrValue, options.minifySVG))) {
     return;
   }
 

package/src/lib/svg.js

@@ -4,9 +4,33 @@
  * - 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)
+ * - Color minification (hex shortening, rgb() to hex, named colors)
+ * - Identity transform removal
+ * - Path data space optimization
  */
 
+import { LRU } from './utils.js';
+
+// Cache for minified numbers
+const numberCache = new LRU(100);
+
+/**
+ * Named colors that are shorter than their hex equivalents
+ * Only includes cases where using the name saves bytes
+ */
+const NAMED_COLORS = {
+  '#f00': 'red',        // #f00 (4) → red (3), saves 1
+  '#c0c0c0': 'silver',  // #c0c0c0 (7) → silver (6), saves 1
+  '#808080': 'gray',    // #808080 (7) → gray (4), saves 3
+  '#800000': 'maroon',  // #800000 (7) → maroon (6), saves 1
+  '#808000': 'olive',   // #808000 (7) → olive (5), saves 2
+  '#008000': 'green',   // #008000 (7) → green (5), saves 2
+  '#800080': 'purple',  // #800080 (7) → purple (6), saves 1
+  '#008080': 'teal',    // #008080 (7) → teal (4), saves 3
+  '#000080': 'navy',    // #000080 (7) → navy (4), saves 3
+  '#ffa500': 'orange'   // #ffa500 (7) → orange (6), saves 1
+};
+
 /**
  * Default SVG attribute values that can be safely removed
  * Only includes well-documented, widely-supported defaults
@@ -39,7 +63,22 @@ const SVG_DEFAULT_ATTRS = {
   opacity: value => value === '1',
   visibility: value => value === 'visible',
   display: value => value === 'inline',
-  overflow: value => value === 'visible'
+  // Note: Overflow handled especially in `isDefaultAttribute` (not safe for root `<svg>`)
+
+  // Clipping and masking defaults
+  'clip-rule': value => value === 'nonzero',
+  'clip-path': value => value === 'none',
+  mask: value => value === 'none',
+
+  // Marker defaults
+  'marker-start': value => value === 'none',
+  'marker-mid': value => value === 'none',
+  'marker-end': value => value === 'none',
+
+  // Filter and color defaults
+  filter: value => value === 'none',
+  'color-interpolation': value => value === 'sRGB',
+  'color-interpolation-filters': value => value === 'linearRGB'
 };
 
 /**
@@ -49,6 +88,20 @@ const SVG_DEFAULT_ATTRS = {
  * @returns {string} Minified numeric string
  */
 function minifyNumber(num, precision = 3) {
+  // Fast path for common values (avoids parsing and caching)
+  if (num === '0' || num === '1') return num;
+  // Common decimal variants that tools export
+  if (num === '0.0' || num === '0.00' || num === '0.000') return '0';
+  if (num === '1.0' || num === '1.00' || num === '1.000') return '1';
+
+  // Check cache
+  // (Note: uses input string as key, so “0.0000” and “0.00000” create separate entries.
+  // This is intentional to avoid parsing overhead.
+  // Real-world SVG files from export tools typically use consistent formats.)
+  const cacheKey = `${num}:${precision}`;
+  const cached = numberCache.get(cacheKey);
+  if (cached !== undefined) return cached;
+
   const parsed = parseFloat(num);
 
   // Handle special cases
@@ -60,11 +113,13 @@ function minifyNumber(num, precision = 3) {
   const fixed = parsed.toFixed(precision);
   const trimmed = fixed.replace(/\.?0+$/, '');
 
-  return trimmed || '0';
+  const result = trimmed || '0';
+  numberCache.set(cacheKey, result);
+  return result;
 }
 
 /**
- * Minify SVG path data by reducing numeric precision
+ * Minify SVG path data by reducing numeric precision and removing unnecessary spaces
  * @param {string} pathData - SVG path data string
  * @param {number} precision - Decimal precision for coordinates
  * @returns {string} Minified path data
@@ -72,11 +127,25 @@ function minifyNumber(num, precision = 3) {
 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) => {
+  // First, minify all numbers
+  let result = pathData.replace(/-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/g, (match) => {
     return minifyNumber(match, precision);
   });
+
+  // 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 before command letter when preceded by a number
+  // 0 L → 0L, 20 M → 20M
+  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');
+
+  return result;
 }
 
 /**
@@ -105,27 +174,49 @@ function minifyAttributeWhitespace(value) {
 }
 
 /**
- * Minify color values (hex shortening, rgb to hex conversion)
+ * Minify color values (hex shortening, rgb to hex conversion, named colors)
+ * Only processes simple color values; preserves case-sensitive references like `url(#id)`
  * @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();
+  const trimmed = color.trim();
+
+  // Don’t process values that aren’t simple colors (preserve case-sensitive references)
+  // `url(#id)`, `var(--name)`, `inherit`, `currentColor`, etc.
+  if (trimmed.includes('url(') || trimmed.includes('var(') ||
+      trimmed === 'inherit' || trimmed === 'currentColor') {
+    return trimmed;
+  }
+
+  // Now safe to lowercase for color matching
+  const lower = trimmed.toLowerCase();
 
   // Shorten 6-digit hex to 3-digit when possible
   // #aabbcc → #abc, #000000 → #000
-  const hexMatch = trimmed.match(/^#([0-9a-f]{6})$/);
+  const hexMatch = lower.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];
+      const shortened = '#' + hex[0] + hex[2] + hex[4];
+      // Try to use named color if shorter
+      return NAMED_COLORS[shortened] || shortened;
     }
+    // Can’t shorten, but check for named color
+    return NAMED_COLORS[lower] || lower;
+  }
+
+  // Match 3-digit hex colors
+  const hex3Match = lower.match(/^#[0-9a-f]{3}$/);
+  if (hex3Match) {
+    // Check if there’s a shorter named color
+    return NAMED_COLORS[lower] || lower;
   }
 
   // Convert rgb(255,255,255) to hex
-  const rgbMatch = trimmed.match(/^rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/);
+  const rgbMatch = lower.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);
@@ -140,13 +231,15 @@ function minifyColor(color) {
 
       // 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];
+        const shortened = '#' + hexColor[1] + hexColor[3] + hexColor[5];
+        return NAMED_COLORS[shortened] || shortened;
       }
-      return hexColor;
+      return NAMED_COLORS[hexColor] || hexColor;
     }
   }
 
-  return color;
+  // Not a recognized color format, return as-is (preserves case)
+  return trimmed;
 }
 
 // Attributes that contain numeric sequences or path data
@@ -176,13 +269,58 @@ const COLOR_ATTRS = new Set([
   'lighting-color'
 ]);
 
+// Pre-compiled regexes for identity transform detection (compiled once at module load)
+// Separator pattern: Accepts comma with optional spaces or one or more spaces
+const SEP = '(?:\\s*,\\s*|\\s+)';
+
+// `translate(0)`, `translate(0,0)`, `translate(0 0)` (matches 0, 0.0, 0.00, etc.)
+const IDENTITY_TRANSLATE_RE = new RegExp(`^translate\\s*\\(\\s*0(?:\\.0+)?\\s*(?:${SEP}0(?:\\.0+)?\\s*)?\\)$`, 'i');
+
+// `scale(1)`, `scale(1,1)`, `scale(1 1)` (matches 1, 1.0, 1.00, etc.)
+const IDENTITY_SCALE_RE = new RegExp(`^scale\\s*\\(\\s*1(?:\\.0+)?\\s*(?:${SEP}1(?:\\.0+)?\\s*)?\\)$`, 'i');
+
+// `rotate(0)`, `rotate(0 cx cy)`, `rotate(0, cx, cy)` (matches 0, 0.0, 0.00, etc.)
+// Note: `cx` and `cy` must be valid numbers if present
+const IDENTITY_ROTATE_RE = new RegExp(`^rotate\\s*\\(\\s*0(?:\\.0+)?\\s*(?:${SEP}-?\\d+(?:\\.\\d+)?${SEP}-?\\d+(?:\\.\\d+)?)?\\s*\\)$`, 'i');
+
+// `skewX(0)`, `skewY(0)` (matches 0, 0.0, 0.00, etc.)
+const IDENTITY_SKEW_RE = /^skew[XY]\s*\(\s*0(?:\.0+)?\s*\)$/i;
+
+// `matrix(1,0,0,1,0,0)`, `matrix(1 0 0 1 0 0)`—identity matrix (matches 1.0/0.0 variants)
+const IDENTITY_MATRIX_RE = new RegExp(`^matrix\\s*\\(\\s*1(?:\\.0+)?\\s*${SEP}0(?:\\.0+)?\\s*${SEP}0(?:\\.0+)?\\s*${SEP}1(?:\\.0+)?\\s*${SEP}0(?:\\.0+)?\\s*${SEP}0(?:\\.0+)?\\s*\\)$`, 'i');
+
+/**
+ * Check if a transform attribute has no effect (identity transform)
+ * @param {string} transform - Transform attribute value
+ * @returns {boolean} True if transform is an identity (has no effect)
+ */
+function isIdentityTransform(transform) {
+  if (!transform || typeof transform !== 'string') return false;
+
+  const trimmed = transform.trim();
+
+  // Check for common identity transforms using pre-compiled regexes
+  return IDENTITY_TRANSLATE_RE.test(trimmed) ||
+         IDENTITY_SCALE_RE.test(trimmed) ||
+         IDENTITY_ROTATE_RE.test(trimmed) ||
+         IDENTITY_SKEW_RE.test(trimmed) ||
+         IDENTITY_MATRIX_RE.test(trimmed);
+}
+
 /**
  * Check if an attribute should be removed based on default value
+ * @param {string} tag - Element tag name (e.g., `svg`, `rect`, `path`)
  * @param {string} name - Attribute name
  * @param {string} value - Attribute value
  * @returns {boolean} True if attribute can be removed
  */
-function isDefaultAttribute(name, value) {
+function isDefaultAttribute(tag, name, value) {
+  // Special case: `overflow="visible"` is unsafe for root `<svg>` element
+  // Root SVG may need explicit `overflow="visible"` to show clipped content
+  if (name === 'overflow' && value === 'visible') {
+    return tag !== 'svg'; // Only remove for non-root SVG elements
+  }
+
   const checker = SVG_DEFAULT_ATTRS[name];
   if (!checker) return false;
 
@@ -233,17 +371,23 @@ export function minifySVGAttributeValue(name, value, options = {}) {
 
 /**
  * Check if an SVG attribute can be removed
+ * @param {string} tag - Element tag name (e.g., `svg`, `rect`, `path`)
  * @param {string} name - Attribute name
  * @param {string} value - Attribute value
  * @param {Object} options - Minification options
  * @returns {boolean} True if attribute should be removed
  */
-export function shouldRemoveSVGAttribute(name, value, options = {}) {
+export function shouldRemoveSVGAttribute(tag, name, value, options = {}) {
   const { removeDefaults = true } = options;
 
   if (!removeDefaults) return false;
 
-  return isDefaultAttribute(name, value);
+  // Check for identity transforms
+  if (name === 'transform' && isIdentityTransform(value)) {
+    return true;
+  }
+
+  return isDefaultAttribute(tag, name, value);
 }
 
 /**

package/src/tokenchain.js

@@ -3,37 +3,29 @@ class Sorter {
     for (let i = 0, len = this.keys.length; i < len; i++) {
       const token = this.keys[i];
 
-      // Build position map for this token to avoid repeated `indexOf`
-      const positions = [];
+      // Single pass: Count matches and collect non-matches
+      let matchCount = 0;
+      const others = [];
+
       for (let j = fromIndex; j < tokens.length; j++) {
         if (tokens[j] === token) {
-          positions.push(j);
+          matchCount++;
+        } else {
+          others.push(tokens[j]);
         }
       }
 
-      if (positions.length > 0) {
-        // Build new array with tokens in sorted order instead of splicing
-        const result = [];
-
-        // Add all instances of the current token first
-        for (let j = 0; j < positions.length; j++) {
-          result.push(token);
-        }
-
-        // Add other tokens, skipping positions where current token was
-        const posSet = new Set(positions);
-        for (let j = fromIndex; j < tokens.length; j++) {
-          if (!posSet.has(j)) {
-            result.push(tokens[j]);
-          }
+      if (matchCount > 0) {
+        // Rebuild: `matchCount` instances of token first, then others
+        let writeIdx = fromIndex;
+        for (let j = 0; j < matchCount; j++) {
+          tokens[writeIdx++] = token;
         }
-
-        // Copy sorted portion back to tokens array
-        for (let j = 0; j < result.length; j++) {
-          tokens[fromIndex + j] = result[j];
+        for (let j = 0; j < others.length; j++) {
+          tokens[writeIdx++] = others[j];
         }
 
-        const newFromIndex = fromIndex + positions.length;
+        const newFromIndex = fromIndex + matchCount;
         return this.sorterMap.get(token).sort(tokens, newFromIndex);
       }
     }