html-minifier-next 5.0.6 → 5.1.0

package/dist/htmlminifier.cjs

@@ -1034,7 +1034,6 @@ const RE_ESCAPE_LT = /</g;
 const RE_ATTR_WS_CHECK = /[ \n\r\t\f]/;
 const RE_ATTR_WS_COLLAPSE = /[ \n\r\t\f]+/g;
 const RE_ATTR_WS_TRIM = /^[ \n\r\t\f]+|[ \n\r\t\f]+$/g;
-const RE_NUMERIC_VALUE = /-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/g;
 
 // Inline element sets for whitespace handling
 
@@ -1638,427 +1637,6 @@ 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, 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
- * 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',
-  // 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'
-};
-
-/**
- * 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) {
-  // 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
-  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+$/, '');
-
-  // 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;
-}
-
-/**
- * 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
- */
-function minifyPathData(pathData, precision = 3) {
-  if (!pathData || typeof pathData !== 'string') return pathData;
-
-  // First, minify all numbers
-  let result = pathData.replace(RE_NUMERIC_VALUE, (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 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`, `.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`, `.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;
-}
-
-/**
- * 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, 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();
-
-  // 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 = 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]) {
-      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() to hex
-  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);
-    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]) {
-        const shortened = '#' + hexColor[1] + hexColor[3] + hexColor[5];
-        return NAMED_COLORS[shortened] || shortened;
-      }
-      return NAMED_COLORS[hexColor] || hexColor;
-    }
-  }
-
-  // Not a recognized color format, return as-is (preserves case)
-  return trimmed;
-}
-
-// 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'
-]);
-
-// 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(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;
-
-  // 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(RE_NUMERIC_VALUE, (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} 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(tag, name, value, options = {}) {
-  const { removeDefaults = true } = options;
-
-  if (!removeDefaults) return false;
-
-  // Check for identity transforms
-  if (name === 'transform' && isIdentityTransform(value)) {
-    return true;
-  }
-
-  return isDefaultAttribute(tag, 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;
-}
-
 // Single source of truth for minifier option names, descriptions, types, and shared defaults
 
 
@@ -2100,11 +1678,13 @@ function shouldMinifyInnerHTML(options) {
  * @param {Function} deps.getLightningCSS - Function to lazily load Lightning CSS
  * @param {Function} deps.getTerser - Function to lazily load Terser
  * @param {Function} deps.getSwc - Function to lazily load @swc/core
+ * @param {Function} deps.getSvgo - Function to lazily load SVGO
  * @param {LRU} deps.cssMinifyCache - CSS minification cache
  * @param {LRU} deps.jsMinifyCache - JS minification cache
+ * @param {LRU} deps.svgMinifyCache - SVG minification cache
  * @returns {MinifierOptions} Normalized options with defaults applied
  */
-const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, cssMinifyCache, jsMinifyCache } = {}) => {
+const processOptions = (inputOptions, { getLightningCSS, getTerser, getSwc, getSvgo, cssMinifyCache, jsMinifyCache, svgMinifyCache } = {}) => {
   const options = {
     name: lowercase,
     canCollapseWhitespace,
@@ -2405,11 +1985,54 @@ 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 if (key === 'minifySVG' && typeof option !== 'function') {
+      if (!option) {
+        return;
+      }
+
+      const svgoOptions = typeof option === 'object' ? option : {};
+
+      // Pre-compute option signature for cache keys
+      const svgSig = stableStringify({
+        ...svgoOptions,
+        cont: !!options.continueOnMinifyError
+      });
+
+      options.minifySVG = async function (svgContent) {
+        if (!svgContent || !svgContent.trim()) {
+          return svgContent;
+        }
+
+        // Cache key
+        const svgKey = svgContent.length > 2048
+          ? (svgContent.length + '|' + svgContent.slice(0, 50) + svgContent.slice(-50) + '|' + svgSig)
+          : (svgContent + '|' + svgSig);
+
+        try {
+          const cached = svgMinifyCache.get(svgKey);
+          if (cached) {
+            return await cached;
+          }
+
+          const inFlight = (async () => {
+            const optimize = await getSvgo();
+            const result = optimize(svgContent, svgoOptions);
+            return result.data;
+          })();
+
+          svgMinifyCache.set(svgKey, inFlight);
+          const resolved = await inFlight;
+          svgMinifyCache.set(svgKey, resolved);
+          return resolved;
+        } catch (err) {
+          svgMinifyCache.delete(svgKey);
+          if (!options.continueOnMinifyError) {
+            throw err;
+          }
+          options.log && options.log(err);
+          return svgContent;
+        }
+      };
     } else if (key === 'customAttrCollapse') {
       // Single regex pattern
       options[key] = parseRegExp(option);
@@ -2813,17 +2436,6 @@ 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;
 }
@@ -2864,9 +2476,7 @@ 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)) ||
-      (options.insideSVG && options.minifySVG &&
-       shouldRemoveSVGAttribute(tag, attrName, attrValue, options.minifySVG))) {
+       attrName === 'type' && isStyleLinkTypeAttribute(attrValue))) {
     return;
   }
 
@@ -3273,9 +2883,18 @@ async function getSwc() {
   return swcPromise;
 }
 
+let svgoPromise;
+async function getSvgo() {
+  if (!svgoPromise) {
+    svgoPromise = import('svgo').then(m => m.optimize);
+  }
+  return svgoPromise;
+}
+
 // Minification caches (initialized on first use with configurable sizes)
 let cssMinifyCache = null;
 let jsMinifyCache = null;
+let svgMinifyCache = null;
 
 // Pre-compiled patterns for script merging (avoid repeated allocation in hot path)
 const RE_SCRIPT_ATTRS = /([^\s=]+)(?:=(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
@@ -3445,6 +3064,15 @@ function mergeConsecutiveScripts(html) {
  *
  *  Default: `500`
  *
+ * @prop {number} [cacheSVG]
+ *  The maximum number of entries for the SVG minification cache. Higher
+ *  values improve performance for inputs with repeated SVG content.
+ *  - Cache is created on first `minify()` call and persists for the process lifetime
+ *  - Cache size is locked after first call—subsequent calls reuse the same cache
+ *  - Explicit `0` values are coerced to `1` (minimum functional cache size)
+ *
+ *  Default: `500`
+ *
  * @prop {boolean} [caseSensitive]
  *  When true, tag and attribute names are treated as case-sensitive.
  *  Useful for custom HTML tags.
@@ -3627,12 +3255,10 @@ function mergeConsecutiveScripts(html) {
  *
  *  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`
+ * @prop {boolean | Object} [minifySVG]
+ *  When true, enables SVG minification using [SVGO](https://github.com/svg/svgo).
+ *  Complete SVG subtrees are extracted and optimized as a block.
+ *  If an object is provided, it is passed to SVGO as configuration options.
  *  If disabled, SVG content is minified using standard HTML rules only.
  *
  *  Default: `false`
@@ -4216,6 +3842,11 @@ async function minifyHTML(value, options, partialMarkup) {
     trimTrailingWhitespace(charsIndex, nextTag);
   }
 
+  // SVG subtree capture: When SVGO is active, record buffer positions for post-processing
+  const svgBlocks = []; // Array of { start, end } buffer indices
+  let svgBufferStartIndex = -1;
+  let svgDepth = 0;
+
   const parser = new HTMLParser(value, {
     partialMarkup: partialMarkup ?? options.partialMarkup,
     continueOnParseError: options.continueOnParseError,
@@ -4233,6 +3864,10 @@ async function minifyHTML(value, options, partialMarkup) {
         options.name = identity;
         options.insideSVG = lowerTag === 'svg';
         options.insideForeignContent = true;
+        // Disable HTML-specific options that produce invalid XML
+        options.removeAttributeQuotes = false;
+        options.removeTagWhitespace = false;
+        options.decodeEntities = false;
       }
       // `foreignObject` in SVG and `annotation-xml` in MathML contain HTML content
       // Note: The element itself is in SVG/MathML namespace, only its children are HTML
@@ -4247,6 +3882,9 @@ async function minifyHTML(value, options, partialMarkup) {
         options.parentName = parentName; // Preserve for the element tag itself
         options.name = options.htmlName || lowercase;
         options.insideForeignContent = false;
+        // Note: `removeAttributeQuotes`, `removeTagWhitespace`, and `decodeEntities`
+        // stay disabled (inherited from SVG context) because the entire SVG block
+        // must be valid XML for SVGO processing
         useParentNameForTag = true;
       }
       tag = (useParentNameForTag ? options.parentName : options.name)(tag);
@@ -4298,6 +3936,14 @@ async function minifyHTML(value, options, partialMarkup) {
         }
       }
 
+      // Track SVG subtree for SVGO block processing
+      if (lowerTag === 'svg' && options.minifySVG) {
+        if (svgDepth === 0) {
+          svgBufferStartIndex = buffer.length; // Record position before <svg> is pushed
+        }
+        svgDepth++;
+      }
+
       const openTag = '<' + tag;
       const hasUnarySlash = unarySlash && options.keepClosingSlash;
 
@@ -4428,6 +4074,15 @@ async function minifyHTML(value, options, partialMarkup) {
           currentChars += '|';
         }
       }
+
+      // SVG subtree capture: Record end position for post-processing with SVGO
+      if (lowerTag === 'svg' && options.minifySVG && svgDepth > 0) {
+        svgDepth--;
+        if (svgDepth === 0 && svgBufferStartIndex >= 0) {
+          svgBlocks.push({ start: svgBufferStartIndex, end: buffer.length });
+          svgBufferStartIndex = -1;
+        }
+      }
     },
     chars: async function (text, prevTag, nextTag, prevAttrs, nextAttrs) {
       prevTag = prevTag === '' ? 'comment' : prevTag;
@@ -4652,6 +4307,19 @@ async function minifyHTML(value, options, partialMarkup) {
 
   await parser.parse();
 
+  // Post-processing: Optimize SVG blocks with SVGO
+  // Run all SVGO calls in parallel, then splice results in reverse to preserve indices
+  if (options.minifySVG && svgBlocks.length) {
+    const optimized = await Promise.all(
+      svgBlocks.map(({ start, end }) =>
+        options.minifySVG(buffer.slice(start, end).join(''))
+      )
+    );
+    for (let i = svgBlocks.length - 1; i >= 0; i--) {
+      buffer.splice(svgBlocks[i].start, svgBlocks[i].end - svgBlocks[i].start, optimized[i]);
+    }
+  }
+
   if (options.removeOptionalTags) {
     // `<html>` may be omitted if first thing inside is not a comment
     // `<head>` or `<body>` may be omitted if empty
@@ -4738,7 +4406,7 @@ function joinResultSegments(results, options, restoreCustom, restoreIgnore) {
  * Important behavior notes:
  * - Caches are created on the first `minify()` call and persist for the lifetime of the process
  * - Cache sizes are locked after first initialization—subsequent calls use the same caches
- *   even if different `cacheCSS`/`cacheJS` options are provided
+ *   even if different `cacheCSS`/`cacheJS`/`cacheSVG` options are provided
  * - The first call’s options determine the cache sizes for subsequent calls
  * - Explicit `0` values are coerced to `1` (minimum functional cache size)
  */
@@ -4762,16 +4430,20 @@ function initCaches(options) {
                  : (parseEnvCacheSize(process.env.HMN_CACHE_CSS) ?? defaultSize);
     const jsSize = options.cacheJS !== undefined ? options.cacheJS
                  : (parseEnvCacheSize(process.env.HMN_CACHE_JS) ?? defaultSize);
+    const svgSize = options.cacheSVG !== undefined ? options.cacheSVG
+                 : (parseEnvCacheSize(process.env.HMN_CACHE_SVG) ?? defaultSize);
 
     // Coerce `0` to `1` (minimum functional cache size) to avoid immediate eviction
     const cssFinalSize = cssSize === 0 ? 1 : cssSize;
     const jsFinalSize = jsSize === 0 ? 1 : jsSize;
+    const svgFinalSize = svgSize === 0 ? 1 : svgSize;
 
     cssMinifyCache = new LRU(cssFinalSize);
     jsMinifyCache = new LRU(jsFinalSize);
+    svgMinifyCache = new LRU(svgFinalSize);
   }
 
-  return { cssMinifyCache, jsMinifyCache };
+  return { cssMinifyCache, jsMinifyCache, svgMinifyCache };
 }
 
 /**
@@ -4789,6 +4461,7 @@ const minify = async function (value, options) {
     getLightningCSS,
     getTerser,
     getSwc,
+    getSvgo,
     ...caches
   });
   let result = await minifyHTML(value, options);