modern-path2d 1.4.16 → 1.5.1

package/dist/index.cjs

@@ -49,9 +49,10 @@ function setCanvasContext(ctx, style) {
 }
 
 class Vector2 {
-  constructor(x = 0, y = 0) {
-    this.x = x;
-    this.y = y;
+  constructor(_x = 0, _y = 0, _onUpdate) {
+    this._x = _x;
+    this._y = _y;
+    this._onUpdate = _onUpdate;
   }
   static get MAX() {
     return new Vector2(Infinity, Infinity);
@@ -59,141 +60,173 @@ class Vector2 {
   static get MIN() {
     return new Vector2(-Infinity, -Infinity);
   }
-  get array() {
-    return [this.x, this.y];
+  static lerp(a, b, t) {
+    return new Vector2(b.x, b.y).clone().sub(a).multiply(t).add(a);
   }
-  finite() {
-    this.x = Number.isFinite(this.x) ? this.x : 0;
-    this.y = Number.isFinite(this.y) ? this.y : 0;
-    return this;
+  get width() {
+    return this.x;
   }
-  set(x, y) {
-    this.x = x;
-    this.y = y;
-    return this;
+  set width(val) {
+    this.x = val;
   }
-  add(vec) {
-    this.x += vec.x;
-    this.y += vec.y;
-    return this;
+  get height() {
+    return this.y;
   }
-  sub(vec) {
-    this.x -= vec.x;
-    this.y -= vec.y;
-    return this;
+  set height(val) {
+    this.y = val;
   }
-  multiply(vec) {
-    this.x *= vec.x;
-    this.y *= vec.y;
-    return this;
+  get left() {
+    return this.x;
   }
-  divide(vec) {
-    this.x /= vec.x;
-    this.y /= vec.y;
-    return this;
+  set left(val) {
+    this.x = val;
   }
-  dot(vec) {
-    return this.x * vec.x + this.y * vec.y;
+  get top() {
+    return this.y;
   }
-  cross(vec) {
-    return this.x * vec.y - this.y * vec.x;
+  set top(val) {
+    this.y = val;
   }
-  rotate(a, target = { x: 0, y: 0 }) {
-    const rotation = -a / 180 * Math.PI;
-    const x = this.x - target.x;
-    const y = -(this.y - target.y);
-    const sin = Math.sin(rotation);
-    const cos = Math.cos(rotation);
-    this.set(
-      target.x + (x * cos - y * sin),
-      target.y - (x * sin + y * cos)
-    );
+  get x() {
+    return this._x;
+  }
+  set x(value) {
+    if (this._x !== value) {
+      this._x = value;
+      this._onUpdate?.(this);
+    }
+  }
+  get y() {
+    return this._y;
+  }
+  set y(value) {
+    if (this._y !== value) {
+      this._y = value;
+      this._onUpdate?.(this);
+    }
+  }
+  set(x = 0, y = x) {
+    if (this._x !== x || this._y !== y) {
+      this._x = x;
+      this._y = y;
+      this._onUpdate?.(this);
+    }
     return this;
   }
-  distanceTo(vec) {
-    return Math.sqrt(this.distanceToSquared(vec));
+  add(p) {
+    return this.set(this._x + p.x, this._y + p.y);
   }
-  distanceToSquared(vec) {
-    const dx = this.x - vec.x;
-    const dy = this.y - vec.y;
-    return dx * dx + dy * dy;
+  sub(p) {
+    return this.set(this._x - p.x, this._y - p.y);
   }
-  lengthSquared() {
-    return this.x * this.x + this.y * this.y;
+  subVectors(a, b) {
+    return this.set(a.x - b.x, a.y - b.y);
   }
-  length() {
-    return Math.sqrt(this.lengthSquared());
+  multiply(x = 0, y = x) {
+    return this.set(this._x * x, this._y * y);
   }
-  scale(sx, sy = sx, target = { x: 0, y: 0 }) {
-    const x = sx < 0 ? target.x - this.x + target.x : this.x;
-    const y = sy < 0 ? target.y - this.y + target.y : this.y;
-    this.x = x * Math.abs(sx);
-    this.y = y * Math.abs(sy);
-    return this;
+  divide(x = 0, y = x) {
+    return this.set(this._x / x, this._y / y);
   }
-  skew(ax, ay = 0, target = { x: 0, y: 0 }) {
-    const dx = this.x - target.x;
-    const dy = this.y - target.y;
-    this.x = target.x + (dx + Math.tan(ax) * dy);
-    this.y = target.y + (dy + Math.tan(ay) * dx);
-    return this;
+  cross(p) {
+    return this._x * p.y - this._y * p.x;
   }
-  min(...vecs) {
-    this.x = Math.min(this.x, ...vecs.map((v) => v.x));
-    this.y = Math.min(this.y, ...vecs.map((v) => v.y));
-    return this;
+  dot(p) {
+    return this._x * p.x + this._y * p.y;
   }
-  max(...vecs) {
-    this.x = Math.max(this.x, ...vecs.map((v) => v.x));
-    this.y = Math.max(this.y, ...vecs.map((v) => v.y));
-    return this;
+  rotate(rad, origin = { x: 0, y: 0 }) {
+    const { x, y } = this;
+    const cos = Math.cos(rad);
+    const sin = Math.sin(rad);
+    return this.set(
+      (x - origin.x) * cos - (y - origin.y) * sin + origin.x,
+      (x - origin.x) * sin + (y - origin.y) * cos + origin.y
+    );
   }
-  normalize() {
-    return this.scale(1 / (this.length() || 1));
+  getLength() {
+    const { x, y } = this;
+    return Math.sqrt(x * x + y * y);
   }
-  addVectors(a, b) {
-    this.x = a.x + b.x;
-    this.y = a.y + b.y;
-    return this;
+  getAngle() {
+    return Math.atan2(-this.x, -this.y) + Math.PI;
   }
-  subVectors(a, b) {
-    this.x = a.x - b.x;
-    this.y = a.y - b.y;
-    return this;
+  distanceTo(p) {
+    return Math.hypot(p.x - this.x, p.y - this.y);
   }
-  multiplyVectors(a, b) {
-    this.x = a.x * b.x;
-    this.y = a.y * b.y;
+  normalize() {
+    const scalar = 1 / (this.getLength() || 1);
+    this.set(this.x * scalar, this.y * scalar);
     return this;
   }
-  divideVectors(a, b) {
-    this.x = a.x / b.x;
-    this.y = a.y / b.y;
+  copyFrom(p) {
+    if (this._x !== p.x || this._y !== p.y) {
+      this._x = p.x;
+      this._y = p.y;
+      this._onUpdate?.(this);
+    }
     return this;
   }
-  lerpVectors(v1, v2, alpha) {
-    this.x = v1.x + (v2.x - v1.x) * alpha;
-    this.y = v1.y + (v2.y - v1.y) * alpha;
-    return this;
+  copyTo(p) {
+    p.set(this._x, this._y);
+    return p;
   }
   equals(vec) {
-    return this.x === vec.x && this.y === vec.y;
-  }
-  applyMatrix3(m) {
-    const x = this.x;
-    const y = this.y;
-    const e = m.elements;
-    this.x = e[0] * x + e[3] * y + e[6];
-    this.y = e[1] * x + e[4] * y + e[7];
-    return this;
+    return this._x === vec.x && this._y === vec.y;
   }
-  copy(vec) {
-    this.x = vec.x;
-    this.y = vec.y;
-    return this;
+  get array() {
+    return [this.x, this.y];
   }
-  clone() {
-    return new Vector2(this.x, this.y);
+  finite() {
+    return this.set(
+      Number.isFinite(this._x) ? this._x : 0,
+      Number.isFinite(this._y) ? this._y : 0
+    );
+  }
+  lengthSquared() {
+    return this._x * this._x + this._y * this._y;
+  }
+  length() {
+    return Math.sqrt(this.lengthSquared());
+  }
+  scale(sx, sy = sx, origin = { x: 0, y: 0 }) {
+    const x = sx < 0 ? origin.x - this._x + origin.x : this._x;
+    const y = sy < 0 ? origin.y - this._y + origin.y : this._y;
+    return this.set(
+      x * Math.abs(sx),
+      y * Math.abs(sy)
+    );
+  }
+  skew(ax, ay = 0, origin = { x: 0, y: 0 }) {
+    const dx = this._x - origin.x;
+    const dy = this._y - origin.y;
+    return this.set(
+      origin.x + (dx + Math.tan(ax) * dy),
+      origin.y + (dy + Math.tan(ay) * dx)
+    );
+  }
+  clampMin(...pList) {
+    return this.set(
+      Math.min(this._x, ...pList.map((v) => v.x)),
+      Math.min(this._y, ...pList.map((v) => v.y))
+    );
+  }
+  clampMax(...pList) {
+    return this.set(
+      Math.max(this.x, ...pList.map((v) => v.x)),
+      Math.max(this.y, ...pList.map((v) => v.y))
+    );
+  }
+  clone(_onUpdate) {
+    return new Vector2(this._x, this._y, _onUpdate ?? this._onUpdate);
+  }
+  toJSON() {
+    return {
+      x: this._x,
+      y: this._y
+    };
+  }
+  destroy() {
+    this._onUpdate = void 0;
   }
 }
 
@@ -269,202 +302,6 @@ class BoundingBox {
   }
 }
 
-class Matrix3 {
-  elements = [];
-  constructor(n11 = 1, n12 = 0, n13 = 0, n21 = 0, n22 = 1, n23 = 0, n31 = 0, n32 = 0, n33 = 1) {
-    this.set(n11, n12, n13, n21, n22, n23, n31, n32, n33);
-  }
-  set(n11, n12, n13, n21, n22, n23, n31, n32, n33) {
-    const te = this.elements;
-    te[0] = n11;
-    te[1] = n21;
-    te[2] = n31;
-    te[3] = n12;
-    te[4] = n22;
-    te[5] = n32;
-    te[6] = n13;
-    te[7] = n23;
-    te[8] = n33;
-    return this;
-  }
-  identity() {
-    this.set(
-      1,
-      0,
-      0,
-      0,
-      1,
-      0,
-      0,
-      0,
-      1
-    );
-    return this;
-  }
-  copy(m) {
-    const te = this.elements;
-    const me = m.elements;
-    te[0] = me[0];
-    te[1] = me[1];
-    te[2] = me[2];
-    te[3] = me[3];
-    te[4] = me[4];
-    te[5] = me[5];
-    te[6] = me[6];
-    te[7] = me[7];
-    te[8] = me[8];
-    return this;
-  }
-  multiply(m) {
-    return this.multiplyMatrices(this, m);
-  }
-  premultiply(m) {
-    return this.multiplyMatrices(m, this);
-  }
-  multiplyMatrices(a, b) {
-    const ae = a.elements;
-    const be = b.elements;
-    const te = this.elements;
-    const a11 = ae[0];
-    const a12 = ae[3];
-    const a13 = ae[6];
-    const a21 = ae[1];
-    const a22 = ae[4];
-    const a23 = ae[7];
-    const a31 = ae[2];
-    const a32 = ae[5];
-    const a33 = ae[8];
-    const b11 = be[0];
-    const b12 = be[3];
-    const b13 = be[6];
-    const b21 = be[1];
-    const b22 = be[4];
-    const b23 = be[7];
-    const b31 = be[2];
-    const b32 = be[5];
-    const b33 = be[8];
-    te[0] = a11 * b11 + a12 * b21 + a13 * b31;
-    te[3] = a11 * b12 + a12 * b22 + a13 * b32;
-    te[6] = a11 * b13 + a12 * b23 + a13 * b33;
-    te[1] = a21 * b11 + a22 * b21 + a23 * b31;
-    te[4] = a21 * b12 + a22 * b22 + a23 * b32;
-    te[7] = a21 * b13 + a22 * b23 + a23 * b33;
-    te[2] = a31 * b11 + a32 * b21 + a33 * b31;
-    te[5] = a31 * b12 + a32 * b22 + a33 * b32;
-    te[8] = a31 * b13 + a32 * b23 + a33 * b33;
-    return this;
-  }
-  invert() {
-    const te = this.elements;
-    const n11 = te[0];
-    const n21 = te[1];
-    const n31 = te[2];
-    const n12 = te[3];
-    const n22 = te[4];
-    const n32 = te[5];
-    const n13 = te[6];
-    const n23 = te[7];
-    const n33 = te[8];
-    const t11 = n33 * n22 - n32 * n23;
-    const t12 = n32 * n13 - n33 * n12;
-    const t13 = n23 * n12 - n22 * n13;
-    const det = n11 * t11 + n21 * t12 + n31 * t13;
-    if (det === 0)
-      return this.set(0, 0, 0, 0, 0, 0, 0, 0, 0);
-    const detInv = 1 / det;
-    te[0] = t11 * detInv;
-    te[1] = (n31 * n23 - n33 * n21) * detInv;
-    te[2] = (n32 * n21 - n31 * n22) * detInv;
-    te[3] = t12 * detInv;
-    te[4] = (n33 * n11 - n31 * n13) * detInv;
-    te[5] = (n31 * n12 - n32 * n11) * detInv;
-    te[6] = t13 * detInv;
-    te[7] = (n21 * n13 - n23 * n11) * detInv;
-    te[8] = (n22 * n11 - n21 * n12) * detInv;
-    return this;
-  }
-  transpose() {
-    let tmp;
-    const m = this.elements;
-    tmp = m[1];
-    m[1] = m[3];
-    m[3] = tmp;
-    tmp = m[2];
-    m[2] = m[6];
-    m[6] = tmp;
-    tmp = m[5];
-    m[5] = m[7];
-    m[7] = tmp;
-    return this;
-  }
-  scale(sx, sy) {
-    this.premultiply(_m3.makeScale(sx, sy));
-    return this;
-  }
-  rotate(theta) {
-    this.premultiply(_m3.makeRotation(-theta));
-    return this;
-  }
-  translate(tx, ty) {
-    this.premultiply(_m3.makeTranslation(tx, ty));
-    return this;
-  }
-  makeTranslation(x, y) {
-    this.set(
-      1,
-      0,
-      x,
-      0,
-      1,
-      y,
-      0,
-      0,
-      1
-    );
-    return this;
-  }
-  makeRotation(theta) {
-    const c = Math.cos(theta);
-    const s = Math.sin(theta);
-    this.set(
-      c,
-      -s,
-      0,
-      s,
-      c,
-      0,
-      0,
-      0,
-      1
-    );
-    return this;
-  }
-  makeScale(x, y) {
-    this.set(
-      x,
-      0,
-      0,
-      0,
-      y,
-      0,
-      0,
-      0,
-      1
-    );
-    return this;
-  }
-  fromArray(array, offset = 0) {
-    for (let i = 0; i < 9; i++) {
-      this.elements[i] = array[i + offset];
-    }
-    return this;
-  }
-  clone() {
-    return new this.constructor().fromArray(this.elements);
-  }
-}
-const _m3 = /* @__PURE__ */ new Matrix3();
-
 function svgAngle(ux, uy, vx, vy) {
   const dot = ux * vx + uy * vy;
   const len = Math.sqrt(ux * ux + uy * uy) * Math.sqrt(vx * vx + vy * vy);
@@ -657,10 +494,10 @@ function svgPathCommandsAddToPath2D(commands, path) {
       if (cmd.type === "m") {
         current.add(cmd);
       } else {
-        current.copy(cmd);
+        current.copyFrom(cmd);
       }
       path.moveTo(current.x, current.y);
-      control.copy(current);
+      control.copyFrom(current);
     } else if (cmd.type === "h" || cmd.type === "H") {
       if (cmd.type === "h") {
         current.x += cmd.x;
@@ -668,7 +505,7 @@ function svgPathCommandsAddToPath2D(commands, path) {
         current.x = cmd.x;
       }
       path.lineTo(current.x, current.y);
-      control.copy(current);
+      control.copyFrom(current);
     } else if (cmd.type === "v" || cmd.type === "V") {
       if (cmd.type === "v") {
         current.y += cmd.y;
@@ -676,15 +513,15 @@ function svgPathCommandsAddToPath2D(commands, path) {
         current.y = cmd.y;
       }
       path.lineTo(current.x, current.y);
-      control.copy(current);
+      control.copyFrom(current);
     } else if (cmd.type === "l" || cmd.type === "L") {
       if (cmd.type === "l") {
         current.add(cmd);
       } else {
-        current.copy(cmd);
+        current.copyFrom(cmd);
       }
       path.lineTo(current.x, current.y);
-      control.copy(current);
+      control.copyFrom(current);
     } else if (cmd.type === "c" || cmd.type === "C") {
       if (cmd.type === "c") {
         path.bezierCurveTo(
@@ -709,7 +546,7 @@ function svgPathCommandsAddToPath2D(commands, path) {
         );
         control.x = cmd.x2;
         control.y = cmd.y2;
-        current.copy(cmd);
+        current.copyFrom(cmd);
       }
     } else if (cmd.type === "s" || cmd.type === "S") {
       if (cmd.type === "s") {
@@ -735,7 +572,7 @@ function svgPathCommandsAddToPath2D(commands, path) {
         );
         control.x = cmd.x2;
         control.y = cmd.y2;
-        current.copy(cmd);
+        current.copyFrom(cmd);
       }
     } else if (cmd.type === "q" || cmd.type === "Q") {
       if (cmd.type === "q") {
@@ -757,7 +594,7 @@ function svgPathCommandsAddToPath2D(commands, path) {
         );
         control.x = cmd.x1;
         control.y = cmd.y1;
-        current.copy(cmd);
+        current.copyFrom(cmd);
       }
     } else if (cmd.type === "t" || cmd.type === "T") {
       const rx = getReflection(current.x, control.x);
@@ -779,7 +616,7 @@ function svgPathCommandsAddToPath2D(commands, path) {
           cmd.x,
           cmd.y
         );
-        current.copy(cmd);
+        current.copyFrom(cmd);
       }
     } else if (cmd.type === "a" || cmd.type === "A") {
       const start = current.clone();
@@ -790,9 +627,9 @@ function svgPathCommandsAddToPath2D(commands, path) {
       } else {
         if (current.equals(cmd))
           continue;
-        current.copy(cmd);
+        current.copyFrom(cmd);
       }
-      control.copy(current);
+      control.copyFrom(current);
       parseArcCommand(
         path,
         cmd.rx,
@@ -805,7 +642,7 @@ function svgPathCommandsAddToPath2D(commands, path) {
       );
     } else if (cmd.type === "z" || cmd.type === "Z") {
       if (path.startPoint) {
-        current.copy(path.startPoint);
+        current.copyFrom(path.startPoint);
       }
       path.closePath();
     } else {
@@ -1105,25 +942,20 @@ function parseFloatWithUnits(string) {
   return scale * Number.parseFloat(string);
 }
 
-const tempTransform0$1 = new Matrix3();
-const tempTransform1$1 = new Matrix3();
-const tempTransform2$1 = new Matrix3();
-const tempTransform3 = new Matrix3();
 function getNodeTransform(node, currentTransform, transformStack) {
   if (!(node.hasAttribute("transform") || node.nodeName === "use" && (node.hasAttribute("x") || node.hasAttribute("y")))) {
     return null;
   }
   const transform = parseNodeTransform(node);
   if (transformStack.length > 0) {
-    transform.premultiply(transformStack[transformStack.length - 1]);
+    transform.prepend(transformStack[transformStack.length - 1]);
   }
-  currentTransform.copy(transform);
+  currentTransform.copyFrom(transform);
   transformStack.push(transform);
   return transform;
 }
 function parseNodeTransform(node) {
-  const transform = new Matrix3();
-  const currentTransform = tempTransform0$1;
+  const transform = new Transform2D();
   if (node.nodeName === "use" && (node.hasAttribute("x") || node.hasAttribute("y"))) {
     transform.translate(
       parseFloatWithUnits(node.getAttribute("x")),
@@ -1131,102 +963,7 @@ function parseNodeTransform(node) {
     );
   }
   if (node.hasAttribute("transform")) {
-    const transformsTexts = node.getAttribute("transform").split(")");
-    for (let tIndex = transformsTexts.length - 1; tIndex >= 0; tIndex--) {
-      const transformText = transformsTexts[tIndex].trim();
-      if (transformText === "")
-        continue;
-      const openParPos = transformText.indexOf("(");
-      const closeParPos = transformText.length;
-      if (openParPos > 0 && openParPos < closeParPos) {
-        const transformType = transformText.slice(0, openParPos);
-        const array = parsePathDataArgs(transformText.slice(openParPos + 1));
-        currentTransform.identity();
-        switch (transformType) {
-          case "translate":
-            if (array.length >= 1) {
-              const tx = array[0];
-              let ty = 0;
-              if (array.length >= 2) {
-                ty = array[1];
-              }
-              currentTransform.translate(tx, ty);
-            }
-            break;
-          case "rotate":
-            if (array.length >= 1) {
-              let angle = 0;
-              let cx = 0;
-              let cy = 0;
-              angle = array[0] * Math.PI / 180;
-              if (array.length >= 3) {
-                cx = array[1];
-                cy = array[2];
-              }
-              tempTransform1$1.makeTranslation(-cx, -cy);
-              tempTransform2$1.makeRotation(angle);
-              tempTransform3.multiplyMatrices(tempTransform2$1, tempTransform1$1);
-              tempTransform1$1.makeTranslation(cx, cy);
-              currentTransform.multiplyMatrices(tempTransform1$1, tempTransform3);
-            }
-            break;
-          case "scale":
-            if (array.length >= 1) {
-              currentTransform.scale(
-                array[0],
-                array[1] ?? array[0]
-              );
-            }
-            break;
-          case "skewX":
-            if (array.length === 1) {
-              currentTransform.set(
-                1,
-                Math.tan(array[0] * Math.PI / 180),
-                0,
-                0,
-                1,
-                0,
-                0,
-                0,
-                1
-              );
-            }
-            break;
-          case "skewY":
-            if (array.length === 1) {
-              currentTransform.set(
-                1,
-                0,
-                0,
-                Math.tan(array[0] * Math.PI / 180),
-                1,
-                0,
-                0,
-                0,
-                1
-              );
-            }
-            break;
-          case "matrix":
-            if (array.length === 6) {
-              currentTransform.set(
-                array[0],
-                array[2],
-                array[4],
-                array[1],
-                array[3],
-                array[5],
-                0,
-                0,
-                1
-              );
-            }
-            break;
-        }
-      }
-      transform.premultiply(currentTransform);
-    }
+    transform.appendCssTransform(node.getAttribute("transform"));
   }
   return transform;
 }
@@ -1503,7 +1240,7 @@ function parseNode(node, style, paths = [], stylesheets = {}) {
   if (_style.display === "none") {
     return paths;
   }
-  const currentTransform = new Matrix3();
+  const currentTransform = new Transform2D();
   const transformStack = [];
   const transform = getNodeTransform(node, currentTransform, transformStack);
   if (path) {
@@ -1521,7 +1258,7 @@ function parseNode(node, style, paths = [], stylesheets = {}) {
   if (transform) {
     transformStack.pop();
     if (transformStack.length > 0) {
-      currentTransform.copy(transformStack[transformStack.length - 1]);
+      currentTransform.copyFrom(transformStack[transformStack.length - 1]);
     } else {
       currentTransform.identity();
     }
@@ -1537,6 +1274,440 @@ function svgToPath2DSet(svg) {
   );
 }
 
+const PI = Math.PI;
+const PI_2 = PI * 2;
+
+class Transform2D {
+  constructor(a = 1, b = 0, c = 0, d = 1, tx = 0, ty = 0) {
+    this.a = a;
+    this.b = b;
+    this.c = c;
+    this.d = d;
+    this.tx = tx;
+    this.ty = ty;
+  }
+  _array;
+  set(a, b, c, d, tx, ty) {
+    this.a = a;
+    this.b = b;
+    this.c = c;
+    this.d = d;
+    this.tx = tx;
+    this.ty = ty;
+    return this;
+  }
+  append(t2d) {
+    const a1 = this.a;
+    const b1 = this.b;
+    const c1 = this.c;
+    const d1 = this.d;
+    this.a = t2d.a * a1 + t2d.b * c1;
+    this.b = t2d.a * b1 + t2d.b * d1;
+    this.c = t2d.c * a1 + t2d.d * c1;
+    this.d = t2d.c * b1 + t2d.d * d1;
+    this.tx = t2d.tx * a1 + t2d.ty * c1 + this.tx;
+    this.ty = t2d.tx * b1 + t2d.ty * d1 + this.ty;
+    return this;
+  }
+  appendFrom(a, b) {
+    const a1 = a.a;
+    const b1 = a.b;
+    const c1 = a.c;
+    const d1 = a.d;
+    const tx = a.tx;
+    const ty = a.ty;
+    const a2 = b.a;
+    const b2 = b.b;
+    const c2 = b.c;
+    const d2 = b.d;
+    this.a = a1 * a2 + b1 * c2;
+    this.b = a1 * b2 + b1 * d2;
+    this.c = c1 * a2 + d1 * c2;
+    this.d = c1 * b2 + d1 * d2;
+    this.tx = tx * a2 + ty * c2 + b.tx;
+    this.ty = tx * b2 + ty * d2 + b.ty;
+    return this;
+  }
+  setTransform(x, y, pivotX, pivotY, scaleX, scaleY, rotation, skewX, skewY) {
+    this.a = Math.cos(rotation + skewY) * scaleX;
+    this.b = Math.sin(rotation + skewY) * scaleX;
+    this.c = -Math.sin(rotation - skewX) * scaleY;
+    this.d = Math.cos(rotation - skewX) * scaleY;
+    this.tx = x - (pivotX * this.a + pivotY * this.c);
+    this.ty = y - (pivotX * this.b + pivotY * this.d);
+    return this;
+  }
+  prepend(t2d) {
+    const tx1 = this.tx;
+    if (t2d.a !== 1 || t2d.b !== 0 || t2d.c !== 0 || t2d.d !== 1) {
+      const a1 = this.a;
+      const c1 = this.c;
+      this.a = a1 * t2d.a + this.b * t2d.c;
+      this.b = a1 * t2d.b + this.b * t2d.d;
+      this.c = c1 * t2d.a + this.d * t2d.c;
+      this.d = c1 * t2d.b + this.d * t2d.d;
+    }
+    this.tx = tx1 * t2d.a + this.ty * t2d.c + t2d.tx;
+    this.ty = tx1 * t2d.b + this.ty * t2d.d + t2d.ty;
+    return this;
+  }
+  _skewX;
+  _skewY;
+  _skewXTan = 1;
+  _skewYTan = 1;
+  skewX(x) {
+    return this.skew(x, 0);
+  }
+  skewY(y) {
+    return this.skew(0, y);
+  }
+  skew(x, y) {
+    if (x !== this._skewX) {
+      this._skewX = x;
+      this._skewXTan = Math.tan(x);
+    }
+    if (y !== this._skewY) {
+      this._skewY = y;
+      this._skewYTan = Math.tan(y);
+    }
+    this.b *= this._skewXTan;
+    this.c *= this._skewYTan;
+    return this;
+  }
+  translateX(x) {
+    return this.translate(x, 0);
+  }
+  translateY(y) {
+    return this.translate(0, y);
+  }
+  translateZ(z) {
+    return this.translate(0, 0, z);
+  }
+  translate3d(x, y, z) {
+    return this.translate(x, y, z);
+  }
+  translate(x, y, _z = 0) {
+    this.tx += x;
+    this.ty += y;
+    return this;
+  }
+  scaleX(x) {
+    return this.scale(x, 1);
+  }
+  scaleY(y) {
+    return this.scale(1, y);
+  }
+  scale3d(x, y, z = 1) {
+    return this.scale(x, y, z);
+  }
+  scale(x, y, _z = 1) {
+    this.a *= x;
+    this.d *= y;
+    this.c *= x;
+    this.b *= y;
+    this.tx *= x;
+    this.ty *= y;
+    return this;
+  }
+  rotateX(x) {
+    return this.scaleY(this._rotateToScale(x));
+  }
+  rotateY(y) {
+    return this.scaleX(this._rotateToScale(y));
+  }
+  rotateZ(z) {
+    return this.rotate(z);
+  }
+  rotate(angle) {
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const a1 = this.a;
+    const c1 = this.c;
+    const tx1 = this.tx;
+    this.a = a1 * cos - this.b * sin;
+    this.b = a1 * sin + this.b * cos;
+    this.c = c1 * cos - this.d * sin;
+    this.d = c1 * sin + this.d * cos;
+    this.tx = tx1 * cos - this.ty * sin;
+    this.ty = tx1 * sin + this.ty * cos;
+    return this;
+  }
+  rotate3d(x, y, z, rad) {
+    const [rx, ry, rz] = this._rotate3d(x, y, z, rad);
+    rx && this.rotateX(rx);
+    ry && this.rotateY(ry);
+    rz && this.rotateZ(rz);
+    return this;
+  }
+  _rotateToScale(rad) {
+    const val = rad / PI_2;
+    return val <= 0.5 ? val * -4 + 1 : (val - 1) * 4 + 1;
+  }
+  _rotate3d(x, y, z, rad) {
+    if (x === 1 && y === 0 && z === 0) {
+      return [rad, 0, 0];
+    } else if (x === 0 && y === 1 && z === 0) {
+      return [0, rad, 0];
+    } else if (x === 0 && y === 0) {
+      return [0, 0, rad];
+    } else {
+      const cos = Math.cos(rad);
+      const sin = Math.sin(rad);
+      const m11 = cos + x * x * (1 - cos);
+      const m12 = x * y * (1 - cos) - z * sin;
+      const m13 = x * z * (1 - cos) + y * sin;
+      const m22 = cos + y * y * (1 - cos);
+      const m23 = y * z * (1 - cos) - x * sin;
+      const m33 = cos + z * z * (1 - cos);
+      const rotateX = -Math.atan2(-m23, m22);
+      const rotateY = -Math.atan2(m13, Math.sqrt(m23 * m23 + m33 * m33));
+      const rotateZ = -Math.atan2(-m12, m11);
+      return [rotateX, rotateY, rotateZ];
+    }
+  }
+  decompose(pivot = { x: 0, y: 0 }, output = {
+    position: { x: 0, y: 0 },
+    scale: { x: 0, y: 0 },
+    skew: { x: 0, y: 0 },
+    rotation: 0
+  }) {
+    const { a, b, c, d, tx, ty } = this;
+    const skewX = -Math.atan2(-c, d);
+    const skewY = Math.atan2(b, a);
+    const delta = Math.abs(skewX + skewY);
+    if (delta < 1e-5 || Math.abs(PI_2 - delta) < 1e-5) {
+      output.rotation = skewY;
+      output.skew.x = output.skew.y = 0;
+    } else {
+      output.rotation = 0;
+      output.skew.x = skewX;
+      output.skew.y = skewY;
+    }
+    output.scale.x = Math.sqrt(a * a + b * b);
+    output.scale.y = Math.sqrt(c * c + d * d);
+    output.position.x = tx + (pivot.x * a + pivot.y * c);
+    output.position.y = ty + (pivot.x * b + pivot.y * d);
+    return output;
+  }
+  apply(pos, newPos) {
+    newPos = newPos || new Vector2();
+    const { x, y } = pos;
+    newPos.x = this.a * x + this.c * y + this.tx;
+    newPos.y = this.b * x + this.d * y + this.ty;
+    return newPos;
+  }
+  affineInvert() {
+    const a1 = this.a;
+    const b1 = this.b;
+    const c1 = this.c;
+    const d1 = this.d;
+    const tx1 = this.tx;
+    const n = a1 * d1 - b1 * c1;
+    this.a = d1 / n;
+    this.b = -b1 / n;
+    this.c = -c1 / n;
+    this.d = a1 / n;
+    this.tx = (c1 * this.ty - d1 * tx1) / n;
+    this.ty = -(a1 * this.ty - b1 * tx1) / n;
+    return this;
+  }
+  affineInverse() {
+    return this.clone().affineInvert();
+  }
+  applyAffineInverse(pos, newPos) {
+    newPos = newPos || new Vector2();
+    const { a, b, c, d, tx, ty } = this;
+    const id = 1 / (a * d + c * -b);
+    const x = pos.x;
+    const y = pos.y;
+    newPos.x = d * id * x + -c * id * y + (ty * c - tx * d) * id;
+    newPos.y = a * id * y + -b * id * x + (-ty * a + tx * b) * id;
+    return newPos;
+  }
+  identity() {
+    this.a = 1;
+    this.b = 0;
+    this.c = 0;
+    this.d = 1;
+    this.tx = 0;
+    this.ty = 0;
+    return this;
+  }
+  isIdentity() {
+    const { a, b, c, d, tx, ty } = this;
+    return a === 1 && b === 0 && c === 0 && d === 1 && tx === 0 && ty === 0;
+  }
+  copyTo(t2d) {
+    t2d.a = this.a;
+    t2d.b = this.b;
+    t2d.c = this.c;
+    t2d.d = this.d;
+    t2d.tx = this.tx;
+    t2d.ty = this.ty;
+    return t2d;
+  }
+  copyFrom(t2d) {
+    this.a = t2d.a;
+    this.b = t2d.b;
+    this.c = t2d.c;
+    this.d = t2d.d;
+    this.tx = t2d.tx;
+    this.ty = t2d.ty;
+    return this;
+  }
+  equals(t2d) {
+    return t2d.a === this.a && t2d.b === this.b && t2d.c === this.c && t2d.d === this.d && t2d.tx === this.tx && t2d.ty === this.ty;
+  }
+  appendCssTransform(cssTransform) {
+    const transformsTexts = cssTransform.split(")");
+    const transform = new Transform2D();
+    for (let tIndex = transformsTexts.length - 1; tIndex >= 0; tIndex--) {
+      const transformText = transformsTexts[tIndex].trim();
+      if (transformText === "")
+        continue;
+      const openParPos = transformText.indexOf("(");
+      const closeParPos = transformText.length;
+      if (openParPos > 0 && openParPos < closeParPos) {
+        const transformType = transformText.slice(0, openParPos);
+        const array = parsePathDataArgs(transformText.slice(openParPos + 1));
+        transform.identity();
+        switch (transformType) {
+          case "translateX":
+            transform.translateX(array[0]);
+            break;
+          case "translateY":
+            transform.translateY(array[0]);
+            break;
+          case "translateZ":
+            transform.translateZ(array[0]);
+            break;
+          case "translate":
+            transform.translate(
+              array[0],
+              array[1] ?? array[0]
+            );
+            break;
+          case "translate3d":
+            transform.translate3d(
+              array[0],
+              array[1] ?? array[0],
+              array[2] ?? array[1] ?? array[0]
+            );
+            break;
+          case "scaleX":
+            transform.scaleX(array[0]);
+            break;
+          case "scaleY":
+            transform.scaleY(array[0]);
+            break;
+          case "scale":
+            transform.scale(
+              array[0],
+              array[1] ?? array[0]
+            );
+            break;
+          case "scale3d":
+            transform.scale3d(
+              array[0],
+              array[1] ?? array[0],
+              array[2] ?? array[1] ?? array[0]
+            );
+            break;
+          case "rotate": {
+            const rad = array[0] * Math.PI / 180;
+            if (array.length >= 3) {
+              const cx = array[1];
+              const cy = array[2];
+              transform.translate(-cx, -cy).rotate(rad).translate(cx, cy);
+            } else {
+              transform.rotate(rad);
+            }
+            break;
+          }
+          case "rotateX":
+            transform.rotateX(array[0] * Math.PI / 180);
+            break;
+          case "rotateY":
+            transform.rotateY(array[0] * Math.PI / 180);
+            break;
+          case "rotateZ":
+            transform.rotateZ(array[0] * Math.PI / 180);
+            break;
+          case "rotate3d":
+            transform.rotate3d(
+              array[0] * Math.PI / 180,
+              (array[1] ?? array[0]) * Math.PI / 180,
+              (array[2] ?? array[1] ?? array[0]) * Math.PI / 180,
+              (array[3] ?? array[2] ?? array[1] ?? array[0]) * Math.PI / 180
+            );
+            break;
+          case "skewX":
+            transform.set(1, 0, Math.tan(array[0] * Math.PI / 180), 1, 0, 0);
+            break;
+          case "skewY":
+            transform.set(1, Math.tan(array[0] * Math.PI / 180), 0, 1, 0, 0);
+            break;
+          case "skew": {
+            const ax = array[0];
+            const ay = array[1] ?? 0;
+            transform.set(1, Math.tan(ay * Math.PI / 180), Math.tan(ax * Math.PI / 180), 1, 0, 0);
+            break;
+          }
+          case "matrix":
+            transform.set(
+              array[0],
+              array[1],
+              array[2],
+              array[3],
+              array[4],
+              array[5]
+            );
+            break;
+        }
+      }
+      this.prepend(transform);
+    }
+    return this;
+  }
+  clone() {
+    return new Transform2D(this.a, this.b, this.c, this.d, this.tx, this.ty);
+  }
+  toArray(transpose, out) {
+    if (!this._array) {
+      this._array = new Float32Array(9);
+    }
+    const array = out || this._array;
+    if (transpose) {
+      array[0] = this.a;
+      array[1] = this.b;
+      array[2] = 0;
+      array[3] = this.c;
+      array[4] = this.d;
+      array[5] = 0;
+      array[6] = this.tx;
+      array[7] = this.ty;
+      array[8] = 1;
+    } else {
+      array[0] = this.a;
+      array[1] = this.c;
+      array[2] = this.tx;
+      array[3] = this.b;
+      array[4] = this.d;
+      array[5] = this.ty;
+      array[6] = 0;
+      array[7] = 0;
+      array[8] = 1;
+    }
+    return array;
+  }
+  toString() {
+    return `[Transform2D a=${this.a} b=${this.b} c=${this.c} d=${this.d} tx=${this.tx} ty=${this.ty}]`;
+  }
+  destroy() {
+    this._array = void 0;
+  }
+}
+
 function catmullRom(t, p0, p1, p2, p3) {
   const v0 = (p2 - p0) * 0.5;
   const v1 = (p3 - p1) * 0.5;
@@ -2300,7 +2471,7 @@ class Curve {
       if (isFunction) {
         transform(p);
       } else {
-        p.applyMatrix3(transform);
+        transform.apply(p, p);
       }
     });
     return this;
@@ -2415,7 +2586,7 @@ class Curve {
     const delta = 1e-4;
     const t1 = Math.max(0, t - delta);
     const t2 = Math.min(1, t + delta);
-    return output.copy(this.getPoint(t2).sub(this.getPoint(t1)).normalize());
+    return output.copyFrom(this.getPoint(t2).sub(this.getPoint(t1)).normalize());
   }
   getTangentAt(u, output) {
     return this.getTangent(this.getUToTMapping(u), output);
@@ -2450,8 +2621,8 @@ class Curve {
     const potins = this.getPoints();
     for (let i = 0, len = potins.length; i < len; i++) {
       const p = potins[i];
-      min.min(p);
-      max.max(p);
+      min.clampMin(p);
+      max.clampMax(p);
     }
     return { min: min.finite(), max: max.finite() };
   }
@@ -2503,18 +2674,18 @@ class Curve {
     });
     return this;
   }
-  copy(source) {
+  copyFrom(source) {
     this.arcLengthDivision = source.arcLengthDivision;
     return this;
   }
   clone() {
-    return new this.constructor().copy(this);
+    return new this.constructor().copyFrom(this);
   }
 }
 
-const tempTransform0 = new Matrix3();
-const tempTransform1 = new Matrix3();
-const tempTransform2 = new Matrix3();
+const tempTransform0 = new Transform2D();
+const tempTransform1 = new Transform2D();
+const tempTransform2 = new Transform2D();
 const tempV2 = new Vector2();
 class RoundCurve extends Curve {
   constructor(_center = new Vector2(), _radius = new Vector2(), _diff = new Vector2(), rotate = 0, startAngle = 0, endAngle = Math.PI * 2, clockwise = false) {
@@ -2633,15 +2804,15 @@ class RoundCurve extends Curve {
     );
     return this;
   }
-  applyTransform(matrix) {
+  applyTransform(transform) {
     tempV2.set(this.cx, this.cy);
-    tempV2.applyMatrix3(matrix);
+    transform.apply(tempV2, tempV2);
     this.cx = tempV2.x;
     this.cy = tempV2.y;
-    if (isTransformSkewed(matrix)) {
-      transfEllipseGeneric(this, matrix);
+    if (isTransformSkewed(transform)) {
+      transfEllipseGeneric(this, transform);
     } else {
-      transfEllipseNoSkew(this, matrix);
+      transfEllipseNoSkew(this, transform);
     }
     return this;
   }
@@ -2768,8 +2939,8 @@ class RoundCurve extends Curve {
     }
     return this._getAdaptiveVerticesByArc(output);
   }
-  copy(source) {
-    super.copy(source);
+  copyFrom(source) {
+    super.copyFrom(source);
     this.cx = source.cx;
     this.cy = source.cy;
     this.rx = source.rx;
@@ -2790,24 +2961,17 @@ function transfEllipseGeneric(curve, m) {
   const sinTheta = Math.sin(curve.rotate);
   const v1 = new Vector2(a * cosTheta, a * sinTheta);
   const v2 = new Vector2(-b * sinTheta, b * cosTheta);
-  const f1 = v1.applyMatrix3(m);
-  const f2 = v2.applyMatrix3(m);
-  const mF = tempTransform0.set(
-    f1.x,
-    f2.x,
-    0,
-    f1.y,
-    f2.y,
-    0,
-    0,
-    0,
-    1
-  );
-  const mFInv = tempTransform1.copy(mF).invert();
-  const mFInvT = tempTransform2.copy(mFInv).transpose();
-  const mQ = mFInvT.multiply(mFInv);
-  const mQe = mQ.elements;
-  const ed = eigenDecomposition(mQe[0], mQe[1], mQe[4]);
+  const f1x = m.a * v1.x + m.c * v1.y;
+  const f1y = m.b * v1.x + m.d * v1.y;
+  const f2x = m.a * v2.x + m.c * v2.y;
+  const f2y = m.b * v2.x + m.d * v2.y;
+  const mF = tempTransform0.set(f1x, f1y, f2x, f2y, 0, 0);
+  const mFInv = tempTransform1.copyFrom(mF).affineInvert();
+  const { a: ia, b: ib, c: ic, d: id } = mFInv;
+  const qA = ia * ia + ib * ib;
+  const qB = ic * ia + id * ib;
+  const qD = ic * ic + id * id;
+  const ed = eigenDecomposition(qA, qB, qD);
   const rt1sqrt = Math.sqrt(ed.rt1);
   const rt2sqrt = Math.sqrt(ed.rt2);
   curve.rx = 1 / rt1sqrt;
@@ -2819,27 +2983,21 @@ function transfEllipseGeneric(curve, m) {
       rt1sqrt,
       0,
       0,
-      0,
       rt2sqrt,
       0,
-      0,
-      0,
-      1
+      0
     );
     const mRT = tempTransform2.set(
       ed.cs,
       ed.sn,
-      0,
       -ed.sn,
       ed.cs,
       0,
-      0,
-      0,
-      1
+      0
     );
-    const mDRF = mDsqrt.multiply(mRT).multiply(mF);
+    const mDRF = mDsqrt.append(mRT).append(mF);
     const transformAngle = (phi) => {
-      const { x: cosR, y: sinR } = new Vector2(Math.cos(phi), Math.sin(phi)).applyMatrix3(mDRF);
+      const { x: cosR, y: sinR } = mDRF.apply({ x: Math.cos(phi), y: Math.sin(phi) });
       return Math.atan2(sinR, cosR);
     };
     curve.startAngle = transformAngle(curve.startAngle);
@@ -2850,11 +3008,10 @@ function transfEllipseGeneric(curve, m) {
   }
 }
 function transfEllipseNoSkew(curve, m) {
-  const sx = getTransformScaleX(m);
-  const sy = getTransformScaleY(m);
-  curve.rx *= sx;
-  curve.ry *= sy;
-  const theta = sx > Number.EPSILON ? Math.atan2(m.elements[1], m.elements[0]) : Math.atan2(-m.elements[3], m.elements[4]);
+  const { scale } = m.decompose();
+  curve.rx *= scale.x;
+  curve.ry *= scale.y;
+  const theta = scale.x > Number.EPSILON ? Math.atan2(m.b, m.a) : Math.atan2(-m.c, m.d);
   curve.rotate += theta;
   if (isTransformFlipped(m)) {
     curve.startAngle *= -1;
@@ -2863,25 +3020,14 @@ function transfEllipseNoSkew(curve, m) {
   }
 }
 function isTransformFlipped(m) {
-  const te = m.elements;
-  return te[0] * te[4] - te[1] * te[3] < 0;
+  return m.a * m.d - m.c * m.b < 0;
 }
 function isTransformSkewed(m) {
-  const te = m.elements;
-  const basisDot = te[0] * te[3] + te[1] * te[4];
+  const basisDot = m.a * m.c + m.b * m.d;
   if (basisDot === 0)
     return false;
-  const sx = getTransformScaleX(m);
-  const sy = getTransformScaleY(m);
-  return Math.abs(basisDot / (sx * sy)) > Number.EPSILON;
-}
-function getTransformScaleX(m) {
-  const te = m.elements;
-  return Math.sqrt(te[0] * te[0] + te[1] * te[1]);
-}
-function getTransformScaleY(m) {
-  const te = m.elements;
-  return Math.sqrt(te[3] * te[3] + te[4] * te[4]);
+  const { scale } = m.decompose();
+  return Math.abs(basisDot / (scale.x * scale.y)) > Number.EPSILON;
 }
 function eigenDecomposition(A, B, C) {
   let rt1, rt2, cs, sn, t;
@@ -2963,9 +3109,9 @@ class LineCurve extends Curve {
   }
   getPoint(t, output = new Vector2()) {
     if (t === 1) {
-      output.copy(this.p2);
+      output.copyFrom(this.p2);
     } else {
-      output.copy(this.p2).sub(this.p1).scale(t).add(this.p1);
+      output.copyFrom(this.p2).sub(this.p1).scale(t).add(this.p1);
     }
     return output;
   }
@@ -3031,10 +3177,10 @@ class LineCurve extends Curve {
     ctx.lineTo(p2.x, p2.y);
     return this;
   }
-  copy(source) {
-    super.copy(source);
-    this.p1.copy(source.p1);
-    this.p2.copy(source.p2);
+  copyFrom(source) {
+    super.copyFrom(source);
+    this.p1.copyFrom(source.p1);
+    this.p2.copyFrom(source.p2);
     return this;
   }
 }
@@ -3173,8 +3319,8 @@ class CompositeCurve extends Curve {
     this.curves.forEach((curve) => curve.drawTo(ctx));
     return this;
   }
-  copy(source) {
-    super.copy(source);
+  copyFrom(source) {
+    super.copyFrom(source);
     this.curves = source.curves.map((curve) => curve.clone());
     return this;
   }
@@ -3271,12 +3417,12 @@ class CubicBezierCurve extends Curve {
     ctx.bezierCurveTo(cp1.x, cp1.y, cp2.x, cp2.y, p2.x, p2.y);
     return this;
   }
-  copy(source) {
-    super.copy(source);
-    this.p1.copy(source.p1);
-    this.cp1.copy(source.cp1);
-    this.cp2.copy(source.cp2);
-    this.p2.copy(source.p2);
+  copyFrom(source) {
+    super.copyFrom(source);
+    this.p1.copyFrom(source.p1);
+    this.cp1.copyFrom(source.cp1);
+    this.cp2.copyFrom(source.cp2);
+    this.p2.copyFrom(source.p2);
     return this;
   }
 }
@@ -3345,8 +3491,8 @@ class EquilateralPloygonCurve extends PloygonCurve {
     this.curves = curves;
     return this;
   }
-  copy(source) {
-    super.copy(source);
+  copyFrom(source) {
+    super.copyFrom(source);
     this.cx = source.cx;
     this.cy = source.cy;
     this.radius = source.radius;
@@ -3418,11 +3564,11 @@ class QuadraticBezierCurve extends Curve {
     ctx.quadraticCurveTo(cp.x, cp.y, p2.x, p2.y);
     return this;
   }
-  copy(source) {
-    super.copy(source);
-    this.p1.copy(source.p1);
-    this.cp.copy(source.cp);
-    this.p2.copy(source.p2);
+  copyFrom(source) {
+    super.copyFrom(source);
+    this.p1.copyFrom(source.p1);
+    this.cp.copyFrom(source.cp);
+    this.p2.copyFrom(source.p2);
     return this;
   }
 }
@@ -3469,8 +3615,8 @@ class RectangleCurve extends PloygonCurve {
       y + height
     ];
   }
-  copy(source) {
-    super.copy(source);
+  copyFrom(source) {
+    super.copyFrom(source);
     this.x = source.x;
     this.y = source.y;
     this.width = source.width;
@@ -3508,8 +3654,8 @@ class RoundRectangleCurve extends RoundCurve {
     ctx.roundRect(x, y, width, height, radius);
     return this;
   }
-  copy(source) {
-    super.copy(source);
+  copyFrom(source) {
+    super.copyFrom(source);
     this.x = source.x;
     this.y = source.y;
     this.width = source.width;
@@ -3543,8 +3689,8 @@ class SplineCurve extends Curve {
   getControlPointRefs() {
     return this.points;
   }
-  copy(source) {
-    super.copy(source);
+  copyFrom(source) {
+    super.copyFrom(source);
     this.points = [];
     for (let i = 0, len = source.points.length; i < len; i++) {
       this.points.push(source.points[i].clone());
@@ -3627,7 +3773,7 @@ class CurvePath extends CompositeCurve {
       const end = this.currentPoint;
       if (end && !start.equals(end)) {
         this.curves.push(new LineCurve(end.clone(), start.clone()));
-        end.copy(start);
+        end.copyFrom(start);
       }
       this.startPoint = void 0;
     }
@@ -3768,8 +3914,8 @@ class CurvePath extends CompositeCurve {
     }
     return this;
   }
-  copy(source) {
-    super.copy(source);
+  copyFrom(source) {
+    super.copyFrom(source);
     this.autoClose = source.autoClose;
     this.currentPoint = source.currentPoint?.clone();
     return this;
@@ -3963,8 +4109,8 @@ class Path2D extends CompositeCurve {
           pointsB[1] ?? pointsB[0]
         );
         if (point) {
-          pointsA[pointsA.length - 1].copy(point);
-          pointsB[0].copy(point);
+          pointsA[pointsA.length - 1].copyFrom(point);
+          pointsB[0].copyFrom(point);
         }
       });
     });
@@ -3995,8 +4141,8 @@ class Path2D extends CompositeCurve {
               point.clone().add({ x: -halfStrokeWidth, y: -halfStrokeWidth })
             );
           }
-          min.min(...points);
-          max.max(...points);
+          min.clampMin(...points);
+          max.clampMax(...points);
         }
       }
     });
@@ -4134,8 +4280,8 @@ class Path2D extends CompositeCurve {
     }
     return `<path d="${this.toData()}" style="${cssText}"></path>`;
   }
-  copy(source) {
-    super.copy(source);
+  copyFrom(source) {
+    super.copyFrom(source);
     this.currentCurve = source.currentCurve.clone();
     this.style = { ...source.style };
     return this;
@@ -4312,7 +4458,8 @@ exports.EllipseCurve = EllipseCurve;
 exports.EquilateralPloygonCurve = EquilateralPloygonCurve;
 exports.FFDControlGrid = FFDControlGrid;
 exports.LineCurve = LineCurve;
-exports.Matrix3 = Matrix3;
+exports.PI = PI;
+exports.PI_2 = PI_2;
 exports.Path2D = Path2D;
 exports.Path2DSet = Path2DSet;
 exports.PloygonCurve = PloygonCurve;
@@ -4320,6 +4467,7 @@ exports.QuadraticBezierCurve = QuadraticBezierCurve;
 exports.RectangleCurve = RectangleCurve;
 exports.RoundRectangleCurve = RoundRectangleCurve;
 exports.SplineCurve = SplineCurve;
+exports.Transform2D = Transform2D;
 exports.Vector2 = Vector2;
 exports.applyFFD = applyFFD;
 exports.catmullRom = catmullRom;