@emasoft/svg-matrix 1.2.1 → 1.3.0

package/src/index.js

@@ -5,7 +5,7 @@
  * SVG path conversion, and 2D/3D affine transformations using Decimal.js.
  *
  * @module @emasoft/svg-matrix
- * @version 1.2.1
+ * @version 1.3.0
  * @license MIT
  *
  * @example
@@ -135,7 +135,7 @@ Decimal.set({ precision: 80 });
  * Library version
  * @constant {string}
  */
-export const VERSION = '1.2.1';
+export const VERSION = '1.3.0';
 
 /**
  * Default precision for path output (decimal places)

package/src/inkscape-support.js

@@ -215,8 +215,8 @@ export function getNodeTypes(element) {
   const nodeTypes = element.getAttribute("sodipodi:nodetypes");
   if (!nodeTypes) return null;
 
-  // Validate format: should only contain c, s, z, a characters
-  if (!/^[csza]+$/i.test(nodeTypes)) return null;
+  // Validate format: should only contain c, s, z, a characters (case-sensitive)
+  if (!/^[csza]+$/.test(nodeTypes)) return null;
 
   return nodeTypes;
 }

package/src/mask-resolver.js

@@ -44,8 +44,6 @@
  */
 
 import Decimal from "decimal.js";
-import { Matrix as _Matrix } from "./matrix.js";
-import * as _Transforms2D from "./transforms2d.js";
 import * as PolygonClip from "./polygon-clip.js";
 import * as ClipPathResolver from "./clip-path-resolver.js";
 import * as MeshGradient from "./mesh-gradient.js";
@@ -1721,10 +1719,15 @@ export function clipWithMeshGradientShape(
   }
 
   // Union all patch polygons to get the complete mesh shape
-  let meshShape = meshPolygons[0].polygon;
-  if (!meshShape || meshShape.length < 3) {
+  // Validate first polygon before use
+  if (
+    !meshPolygons[0] ||
+    !meshPolygons[0].polygon ||
+    meshPolygons[0].polygon.length < 3
+  ) {
     return [];
   }
+  let meshShape = meshPolygons[0].polygon;
 
   for (let i = 1; i < meshPolygons.length; i++) {
     if (
@@ -1817,10 +1820,15 @@ export function meshGradientToClipPath(meshData, options = {}) {
   }
 
   // Union all patches into one shape
-  let result = meshPolygons[0].polygon;
-  if (!result || result.length < 3) {
+  // Validate first polygon before use
+  if (
+    !meshPolygons[0] ||
+    !meshPolygons[0].polygon ||
+    meshPolygons[0].polygon.length < 3
+  ) {
     return [];
   }
+  let result = meshPolygons[0].polygon;
 
   for (let i = 1; i < meshPolygons.length; i++) {
     if (!meshPolygons[i] || !meshPolygons[i].polygon) continue; // Skip invalid polygons

package/src/mesh-gradient.js

@@ -8,8 +8,6 @@
  */
 
 import Decimal from "decimal.js";
-import { Matrix as _Matrix } from "./matrix.js";
-import * as _Transforms2D from "./transforms2d.js";
 import * as PolygonClip from "./polygon-clip.js";
 
 Decimal.set({ precision: 80 });

package/src/off-canvas-detection.js

@@ -795,7 +795,7 @@ export function pathBoundingBox(pathCommands) {
         }
         break;
 
-      case "A": // Arc (proper extrema calculation)
+      case "A": // Arc (conservative bounding box using extrema bounds)
         {
           // Validate required properties (WHY: prevent accessing undefined properties)
           if (
@@ -825,30 +825,22 @@ export function pathBoundingBox(pathCommands) {
             maxY = Decimal.max(maxY, currentY, y);
             samplePoints.push({ x: currentX, y: currentY }, { x, y });
           } else {
-            // For proper arc bounding box, include start, end, and potential extrema
-            // Start and end points
-            minX = Decimal.min(minX, currentX, x);
-            minY = Decimal.min(minY, currentY, y);
-            maxX = Decimal.max(maxX, currentX, x);
-            maxY = Decimal.max(maxY, currentY, y);
-
-            // For a complete solution, we'd need to:
-            // 1. Convert to center parameterization (complex for arbitrary precision)
-            // 2. Check if extrema angles (0°, 90°, 180°, 270°) fall within arc sweep
-            // 3. Include those extrema in bbox
-            // For now, conservatively expand bbox by radii to ensure containment
-            // This may overestimate slightly but guarantees correctness
-            const centerX = currentX.plus(x).div(2);
-            const centerY = currentY.plus(y).div(2);
-            minX = Decimal.min(minX, centerX.minus(rx));
-            minY = Decimal.min(minY, centerY.minus(ry));
-            maxX = Decimal.max(maxX, centerX.plus(rx));
-            maxY = Decimal.max(maxY, centerY.plus(ry));
-
-            // Sample arc for verification points
+            // FIX: Use conservative bounds that guarantee containment (WHY: exact arc center requires complex calculations)
+            // The tightest conservative bound without full arc parameterization is to
+            // consider all possible extrema within a box of size 2*rx by 2*ry centered at each endpoint
+            // This ensures we never underestimate the bbox, though we may slightly overestimate
+            minX = Decimal.min(minX, currentX, x, currentX.minus(rx), x.minus(rx));
+            minY = Decimal.min(minY, currentY, y, currentY.minus(ry), y.minus(ry));
+            maxX = Decimal.max(maxX, currentX, x, currentX.plus(rx), x.plus(rx));
+            maxY = Decimal.max(maxY, currentY, y, currentY.plus(ry), y.plus(ry));
+
+            // Sample arc for verification: use parametric sampling along the arc
+            // Note: This is still an approximation, but better than linear interpolation
             const samples = 20;
             for (let i = 0; i <= samples; i++) {
               const t = D(i).div(samples);
+              // Simple parametric interpolation (approximation)
+              // For exact results, we'd need to convert to center parameterization
               const px = currentX.plus(x.minus(currentX).mul(t));
               const py = currentY.plus(y.minus(currentY).mul(t));
               samplePoints.push({ x: px, y: py });

package/src/svg-boolean-ops.js

@@ -23,15 +23,10 @@ const EPSILON = new Decimal("1e-40");
 
 const {
   point,
-  pointsEqual: _pointsEqual,
   cross,
-  polygonArea: _polygonArea,
   polygonIntersection,
   polygonUnion,
   polygonDifference,
-  isCounterClockwise: _isCounterClockwise,
-  ensureCCW: _ensureCCW,
-  segmentIntersection: _segmentIntersection,
 } = PolygonClip;
 
 // ============================================================================

package/src/svg-collections.js

@@ -459,6 +459,7 @@ export const colorsProps = new Set([
 
 /**
  * Complete list of known SVG elements
+ * Includes both canonical names and lowercase variants for case-insensitive matching
  */
 export const knownElements = new Set([
   // Structural elements
@@ -487,8 +488,13 @@ export const knownElements = new Set([
   "glyphRef",
   // Gradient elements
   "linearGradient",
+  "lineargradient", // lowercase variant for case-insensitive matching
   "radialGradient",
+  "radialgradient", // lowercase variant for case-insensitive matching
   "meshGradient",
+  "meshgradient", // lowercase variant for case-insensitive matching
+  "meshrow", // SVG 2.0 mesh gradient row
+  "meshpatch", // SVG 2.0 mesh gradient patch
   "stop",
   // Container elements
   "a",
@@ -496,6 +502,7 @@ export const knownElements = new Set([
   "mask",
   "pattern",
   "clipPath",
+  "clippath", // lowercase variant for case-insensitive matching
   "switch",
   // Filter elements
   "filter",
@@ -531,8 +538,11 @@ export const knownElements = new Set([
   // Animation elements
   "animate",
   "animateColor",
+  "animatecolor", // lowercase variant for case-insensitive matching
   "animateMotion",
+  "animatemotion", // lowercase variant for case-insensitive matching
   "animateTransform",
+  "animatetransform", // lowercase variant for case-insensitive matching
   "set",
   "mpath",
   // Other elements
@@ -542,6 +552,7 @@ export const knownElements = new Set([
   "style",
   "script",
   "solidColor",
+  "solidcolor", // lowercase variant for case-insensitive matching
   "hatch",
   "hatchpath",
 ]);

package/src/svg-matrix-lib.js

@@ -5,7 +5,7 @@
  * Works in both Node.js and browser environments.
  *
  * @module svg-matrix-lib
- * @version 1.2.1
+ * @version 1.3.0
  * @license MIT
  *
  * @example Browser usage:
@@ -32,7 +32,7 @@ Decimal.set({ precision: 80 });
 /**
  * Library version
  */
-export const VERSION = "1.2.1";
+export const VERSION = "1.3.0";
 
 // Export core classes
 export { Decimal, Matrix, Vector };

package/src/svg-parser.js

@@ -666,30 +666,6 @@ export class SVGElement {
 // INTERNAL PARSING FUNCTIONS
 // ============================================================================
 
-/**
- * Check if whitespace should be preserved based on xml:space attribute.
- * BUG FIX 2: Helper function to check xml:space="preserve" on element or ancestors
- * @private
- * @param {SVGElement} element - Element to check for xml:space attribute
- * @returns {boolean} True if whitespace should be preserved, false otherwise
- */
-function _shouldPreserveWhitespace(element) {
-  // Validation: Ensure element is not null/undefined
-  if (!element) {
-    throw new Error(
-      "_shouldPreserveWhitespace: element cannot be null or undefined",
-    );
-  }
-  let current = element;
-  while (current) {
-    const xmlSpace = current.getAttribute("xml:space");
-    if (xmlSpace === "preserve") return true;
-    if (xmlSpace === "default") return false;
-    current = current.parentNode;
-  }
-  return false;
-}
-
 /**
  * Parse a single element from SVG string.
  * @private

package/src/svg-rendering-context.js

@@ -31,10 +31,8 @@ import Decimal from "decimal.js";
 import {
   FillRule,
   pointInPolygonWithRule,
-  offsetPolygon as _offsetPolygon,
   strokeToFilledPolygon,
 } from "./svg-boolean-ops.js";
-import * as _PolygonClip from "./polygon-clip.js";
 
 Decimal.set({ precision: 80 });
 
@@ -353,9 +351,9 @@ export class SVGRenderingContext {
       extent = halfWidth.times(this.strokeMiterlimit);
     }
 
-    // Square linecaps extend by half stroke width beyond endpoints - Why: total extent is stroke radius + cap extension = strokeWidth
+    // Square linecaps extend strokeWidth/2 beyond endpoints - Why: total extent is base strokeWidth/2 + cap extension strokeWidth/2 = strokeWidth
     if (this.strokeLinecap === "square") {
-      const capExtent = halfWidth.times(2); // strokeWidth/2 + strokeWidth/2
+      const capExtent = halfWidth.times(2); // Total extent: strokeWidth (base halfWidth + cap halfWidth)
       if (capExtent.gt(extent)) {
         extent = capExtent;
       }

package/src/svg-toolbox-lib.js

@@ -5,7 +5,7 @@
  * Provides 69+ operations for cleaning, optimizing, and transforming SVG files.
  *
  * @module svg-toolbox-lib
- * @version 1.2.1
+ * @version 1.3.0
  * @license MIT
  *
  * @example Browser usage:
@@ -34,7 +34,7 @@ import * as SVGToolboxModule from "./svg-toolbox.js";
 /**
  * Library version
  */
-export const VERSION = "1.2.1";
+export const VERSION = "1.3.0";
 
 /**
  * Default export for browser global (window.SVGToolbox)

package/src/svgm-lib.js

@@ -5,7 +5,7 @@
  * comprehensive SVG manipulation (SVGToolbox). Works in Node.js and browser.
  *
  * @module svgm-lib
- * @version 1.2.1
+ * @version 1.3.0
  * @license MIT
  *
  * @example Browser usage:
@@ -49,7 +49,7 @@ Decimal.set({ precision: 80 });
 /**
  * Library version
  */
-export const VERSION = "1.2.1";
+export const VERSION = "1.3.0";
 
 // Export math classes
 export { Decimal, Matrix, Vector };

package/src/transform-optimization.js

@@ -196,6 +196,97 @@ export function matricesEqual(m1, m2, tolerance = VERIFICATION_TOLERANCE) {
   return matrixMaxDifference(m1, m2).lessThan(D(tolerance));
 }
 
+/**
+ * Compute the combined matrix from a list of transform objects.
+ * Used internally for verification that optimizations preserve the transform result.
+ *
+ * @param {Array<Object>} transforms - Array of transform objects with type and params
+ * @returns {Matrix} Combined 3x3 transformation matrix
+ *
+ * @example
+ * const transforms = [
+ *   { type: 'translate', params: { tx: 10, ty: 20 } },
+ *   { type: 'rotate', params: { angle: 0.5 } }
+ * ];
+ * const combined = computeCombinedMatrix(transforms);
+ */
+export function computeCombinedMatrix(transforms) {
+  let combined = identityMatrix();
+
+  for (const t of transforms) {
+    // Validate transform object structure
+    if (
+      !t ||
+      typeof t !== "object" ||
+      !t.type ||
+      !t.params ||
+      typeof t.params !== "object"
+    ) {
+      continue; // Skip malformed transforms
+    }
+
+    let m = null;
+    switch (t.type) {
+      case "translate":
+        if (
+          t.params.tx === null ||
+          t.params.tx === undefined ||
+          t.params.ty === null ||
+          t.params.ty === undefined
+        ) {
+          continue; // Skip transforms with missing params
+        }
+        m = translationMatrix(t.params.tx, t.params.ty);
+        break;
+      case "rotate":
+        if (t.params.angle === null || t.params.angle === undefined) {
+          continue; // Skip transforms with missing angle
+        }
+        if (
+          t.params.cx !== undefined &&
+          t.params.cx !== null &&
+          t.params.cy !== undefined &&
+          t.params.cy !== null
+        ) {
+          m = rotationMatrixAroundPoint(
+            t.params.angle,
+            t.params.cx,
+            t.params.cy,
+          );
+        } else {
+          m = rotationMatrix(t.params.angle);
+        }
+        break;
+      case "scale":
+        if (
+          t.params.sx === null ||
+          t.params.sx === undefined ||
+          t.params.sy === null ||
+          t.params.sy === undefined
+        ) {
+          continue; // Skip transforms with missing params
+        }
+        m = scaleMatrix(t.params.sx, t.params.sy);
+        break;
+      case "matrix":
+        if (!t.params.matrix) {
+          continue; // Skip transforms with missing matrix
+        }
+        m = t.params.matrix;
+        break;
+      default:
+        // Skip unknown transform types
+        continue;
+    }
+
+    if (m !== null) {
+      combined = combined.mul(m);
+    }
+  }
+
+  return combined;
+}
+
 // ============================================================================
 // Transform Merging Functions
 // ============================================================================
@@ -920,77 +1011,7 @@ export function optimizeTransformList(transforms) {
   }
 
   // Calculate original combined matrix for verification
-  let originalMatrix = identityMatrix();
-  for (const t of transforms) {
-    // Validate transform object structure
-    if (
-      !t ||
-      typeof t !== "object" ||
-      !t.type ||
-      !t.params ||
-      typeof t.params !== "object"
-    ) {
-      continue; // Skip malformed transforms
-    }
-
-    let m = null; // Initialize m to null to catch missing assignments
-    switch (t.type) {
-      case "translate":
-        if (
-          t.params.tx === null ||
-          t.params.tx === undefined ||
-          t.params.ty === null ||
-          t.params.ty === undefined
-        ) {
-          continue; // Skip transforms with missing params
-        }
-        m = translationMatrix(t.params.tx, t.params.ty);
-        break;
-      case "rotate":
-        if (t.params.angle === null || t.params.angle === undefined) {
-          continue; // Skip transforms with missing angle
-        }
-        if (
-          t.params.cx !== undefined &&
-          t.params.cx !== null &&
-          t.params.cy !== undefined &&
-          t.params.cy !== null
-        ) {
-          m = rotationMatrixAroundPoint(
-            t.params.angle,
-            t.params.cx,
-            t.params.cy,
-          );
-        } else {
-          m = rotationMatrix(t.params.angle);
-        }
-        break;
-      case "scale":
-        if (
-          t.params.sx === null ||
-          t.params.sx === undefined ||
-          t.params.sy === null ||
-          t.params.sy === undefined
-        ) {
-          continue; // Skip transforms with missing params
-        }
-        m = scaleMatrix(t.params.sx, t.params.sy);
-        break;
-      case "matrix":
-        if (!t.params.matrix) {
-          continue; // Skip transforms with missing matrix
-        }
-        m = t.params.matrix;
-        break;
-      default:
-        // Skip unknown transform types, but don't try to multiply null matrix
-        continue;
-    }
-    // Only multiply if m was successfully assigned (prevents undefined matrix multiplication)
-    if (m !== null) {
-      originalMatrix = originalMatrix.mul(m);
-    }
-  }
+  const originalMatrix = computeCombinedMatrix(transforms);
 
   // Step 1: Remove identity transforms
   const { transforms: step1, removedCount: _removedCount } =
@@ -1210,77 +1231,7 @@ export function optimizeTransformList(transforms) {
   const { transforms: final } = removeIdentityTransforms(optimized);
 
   // Calculate optimized combined matrix for verification
-  let optimizedMatrix = identityMatrix();
-  for (const t of final) {
-    // Validate transform object structure
-    if (
-      !t ||
-      typeof t !== "object" ||
-      !t.type ||
-      !t.params ||
-      typeof t.params !== "object"
-    ) {
-      continue; // Skip malformed transforms
-    }
-
-    let m = null; // Initialize m to null to catch missing assignments
-    switch (t.type) {
-      case "translate":
-        if (
-          t.params.tx === null ||
-          t.params.tx === undefined ||
-          t.params.ty === null ||
-          t.params.ty === undefined
-        ) {
-          continue; // Skip transforms with missing params
-        }
-        m = translationMatrix(t.params.tx, t.params.ty);
-        break;
-      case "rotate":
-        if (t.params.angle === null || t.params.angle === undefined) {
-          continue; // Skip transforms with missing angle
-        }
-        if (
-          t.params.cx !== undefined &&
-          t.params.cx !== null &&
-          t.params.cy !== undefined &&
-          t.params.cy !== null
-        ) {
-          m = rotationMatrixAroundPoint(
-            t.params.angle,
-            t.params.cx,
-            t.params.cy,
-          );
-        } else {
-          m = rotationMatrix(t.params.angle);
-        }
-        break;
-      case "scale":
-        if (
-          t.params.sx === null ||
-          t.params.sx === undefined ||
-          t.params.sy === null ||
-          t.params.sy === undefined
-        ) {
-          continue; // Skip transforms with missing params
-        }
-        m = scaleMatrix(t.params.sx, t.params.sy);
-        break;
-      case "matrix":
-        if (!t.params.matrix) {
-          continue; // Skip transforms with missing matrix
-        }
-        m = t.params.matrix;
-        break;
-      default:
-        // Skip unknown transform types, but don't try to multiply null matrix
-        continue;
-    }
-    // Only multiply if m was successfully assigned (prevents undefined matrix multiplication)
-    if (m !== null) {
-      optimizedMatrix = optimizedMatrix.mul(m);
-    }
-  }
+  const optimizedMatrix = computeCombinedMatrix(final);
 
   // VERIFICATION: Combined matrices must be equal
   const maxError = matrixMaxDifference(originalMatrix, optimizedMatrix);

package/src/verification.js

@@ -15,8 +15,6 @@
  */
 
 import Decimal from "decimal.js";
-import { Matrix as _Matrix } from "./matrix.js";
-import { Vector as _Vector } from "./vector.js";
 import * as Transforms2D from "./transforms2d.js";
 
 // Use high precision for verifications

package/templates/svgm_replacement_map.yml

@@ -0,0 +1,53 @@
+# SVG Font Replacement Map
+# ========================
+# This file defines font replacements for SVG processing.
+#
+# Format:
+#   original_font: replacement_font
+#
+# Examples:
+#   "Arial": "Inter"           # Replace Arial with Inter
+#   "Times New Roman": "Noto Serif"
+#
+# Font sources (in priority order):
+#   1. Local system fonts
+#   2. Google Fonts (default, free)
+#   3. FontGet (npm: fontget)
+#   4. fnt (brew: alexmyczko/fnt/fnt)
+#
+# Options per font:
+#   embed: true                # Embed as base64 (default: true)
+#   subset: true               # Only include used glyphs (default: true)
+#   source: "google"           # Force specific source
+#   weight: "400,700"          # Specific weights to include
+#   style: "normal,italic"     # Specific styles
+#
+# Advanced format:
+#   "Arial":
+#     replacement: "Inter"
+#     embed: true
+#     subset: true
+#     source: "google"
+#     weights: ["400", "500", "700"]
+
+replacements:
+  # Common font replacements
+  # "Arial": "Inter"
+  # "Helvetica": "Inter"
+  # "Times New Roman": "Noto Serif"
+  # "Times": "Noto Serif"
+  # "Courier New": "Fira Code"
+  # "Courier": "Fira Code"
+  # "Georgia": "Merriweather"
+  # "Verdana": "Open Sans"
+  # "Comic Sans MS": "Comic Neue"
+
+  # Icon fonts
+  # "Font Awesome": "Font Awesome 6 Free"
+  # "Material Icons": "Material Symbols Outlined"
+
+options:
+  default_embed: true
+  default_subset: true
+  fallback_source: "google"
+  auto_download: true