toosoon-utils 4.2.3 → 4.3.0

package/lib/extras/geometry/Vector2.js

@@ -18,6 +18,10 @@ export default class Vector2 {
      * Y-axis value of this vector
      */
     y;
+    *[Symbol.iterator]() {
+        yield this.x;
+        yield this.y;
+    }
     /**
      * @param {number} [x=0] X-axis value
      * @param {number} [y=0] Y-axis value
@@ -41,7 +45,7 @@ export default class Vector2 {
     /**
      * Set a given scalar value to all values of this vector
      *
-     * @param {number} scalar Value to set for all vector values
+     * @param {number} scalar Value to set for all values
      * @returns {this}
      */
     setScalar(scalar) {
@@ -306,13 +310,13 @@ export default class Vector2 {
         return this.set(...Vector2.rotate(this, center, angle));
     }
     /**
-     * Interpolate this vector values between a given vector and this vector
+     * Linearly interpolate this vector values towards a given vector values
      *
-     * @param {Vector2|Point2} vector Vector to interpolate values towards
      * @param {number} t Normalized time value to interpolate
+     * @param {Vector2|Point2} vector Vector to interpolate values towards
      * @returns {this}
      */
-    lerp([x, y], t) {
+    lerp(t, [x, y]) {
         this.x += (x - this.x) * t;
         this.y += (y - this.y) * t;
         return this;
@@ -467,7 +471,7 @@ export default class Vector2 {
      * Set this vector values from a given array
      *
      * @param {number[]} values Values to set
-     * @returns
+     * @returns {this}
      */
     fromArray([x, y]) {
         this.x = x;
@@ -503,6 +507,24 @@ export default class Vector2 {
     clone() {
         return new Vector2(this.x, this.y);
     }
+    /**
+     * X-axis value of this vector
+     */
+    set width(width) {
+        this.x = width;
+    }
+    get width() {
+        return this.x;
+    }
+    /**
+     * Y-axis value of this vector
+     */
+    set height(height) {
+        this.y = height;
+    }
+    get height() {
+        return this.y;
+    }
     /**
      * Add two vectors
      *
@@ -569,7 +591,7 @@ export default class Vector2 {
         return [x, y];
     }
     /**
-     * Interpolate a point between two vectors
+     * Linearly interpolate a point between two vectors
      *
      * @param {number} t Normalized time value to interpolate
      * @param {Vector2|Point2} min Minimum boundaries
@@ -639,7 +661,7 @@ export default class Vector2 {
      * @returns {number} Computed Euclidean distance
      */
     static distance(vector1, vector2) {
-        return Math.sqrt(Vector2.squaredDistance(vector1, vector2));
+        return Math.sqrt(this.squaredDistance(vector1, vector2));
     }
     /**
      * Calculate the squared distance between two vectors
@@ -702,20 +724,4 @@ export default class Vector2 {
         const y = radius * Math.sin(angle);
         return [x, y];
     }
-    set width(width) {
-        this.x = width;
-    }
-    get width() {
-        return this.x;
-    }
-    set height(height) {
-        this.y = height;
-    }
-    get height() {
-        return this.y;
-    }
-    *[Symbol.iterator]() {
-        yield this.x;
-        yield this.y;
-    }
 }

package/lib/extras/geometry/Vector3.d.ts

@@ -23,6 +23,7 @@ export default class Vector3 implements Vector<Vec3> {
      * Z-axis value of this vector
      */
     z: number;
+    [Symbol.iterator](): Iterator<number>;
     /**
      * @param {number} [x=0] X-axis value
      * @param {number} [y=0] Y-axis value
@@ -198,13 +199,13 @@ export default class Vector3 implements Vector<Vec3> {
      */
     negate(): this;
     /**
-     * Interpolate this vector values between a given vector and this vector
+     * Linearly interpolate this vector values towards a given vector values
      *
-     * @param {Vector3|Point3} vector Vector to interpolate values towards
      * @param {number} t Normalized time value to interpolate
+     * @param {Vector3|Point3} vector Vector to interpolate values towards
      * @returns {this}
      */
-    lerp([x, y, z]: Vec3, t: number): this;
+    lerp(t: number, [x, y, z]: Vec3): this;
     /**
      * Convert this vector to a unit vector
      *
@@ -384,7 +385,7 @@ export default class Vector3 implements Vector<Vec3> {
      */
     static divide([x1, y1, z1]: Vec3, [x2, y2, z2]: Vec3): Point3;
     /**
-     * Interpolate a point between two vectors
+     * Linearly interpolate a point between two vectors
      *
      * @param {number} t Normalized time value to interpolate
      * @param {Vector3|Point3} min Minimum boundaries
@@ -488,6 +489,5 @@ export default class Vector3 implements Vector<Vec3> {
      * @returns {Point3}
      */
     static fromCylindricalCoords(theta: number, y: number, radius?: number): Point3;
-    [Symbol.iterator](): Iterator<number>;
 }
 export {};

package/lib/extras/geometry/Vector3.js

@@ -22,6 +22,11 @@ export default class Vector3 {
      * Z-axis value of this vector
      */
     z;
+    *[Symbol.iterator]() {
+        yield this.x;
+        yield this.y;
+        yield this.z;
+    }
     /**
      * @param {number} [x=0] X-axis value
      * @param {number} [y=0] Y-axis value
@@ -339,13 +344,13 @@ export default class Vector3 {
         return this;
     }
     /**
-     * Interpolate this vector values between a given vector and this vector
+     * Linearly interpolate this vector values towards a given vector values
      *
-     * @param {Vector3|Point3} vector Vector to interpolate values towards
      * @param {number} t Normalized time value to interpolate
+     * @param {Vector3|Point3} vector Vector to interpolate values towards
      * @returns {this}
      */
-    lerp([x, y, z], t) {
+    lerp(t, [x, y, z]) {
         this.x += (x - this.x) * t;
         this.y += (y - this.y) * t;
         this.z += (z - this.z) * t;
@@ -618,7 +623,7 @@ export default class Vector3 {
         return [x, y, z];
     }
     /**
-     * Interpolate a point between two vectors
+     * Linearly interpolate a point between two vectors
      *
      * @param {number} t Normalized time value to interpolate
      * @param {Vector3|Point3} min Minimum boundaries
@@ -691,7 +696,7 @@ export default class Vector3 {
      * @returns {number} Computed Euclidean distance
      */
     static distance(vector1, vector2) {
-        return Math.sqrt(Vector3.squaredDistance(vector1, vector2));
+        return Math.sqrt(this.squaredDistance(vector1, vector2));
     }
     /**
      * Calculate the squared distance between two vectors
@@ -770,9 +775,4 @@ export default class Vector3 {
         const z = radius * Math.cos(theta);
         return [x, y, z];
     }
-    *[Symbol.iterator]() {
-        yield this.x;
-        yield this.y;
-        yield this.z;
-    }
 }

package/lib/extras/paths/Path.d.ts

@@ -7,13 +7,13 @@ import { type Vector, Vector2, Vector3 } from '../geometry';
  * @class Path
  * @extends Curve
  */
-export default class Path<V extends Vector = Vector2 | Vector3, S extends Curve<V> = Curve<V>> extends Curve<V> {
+export default class Path<V extends Vector = Vector2 | Vector3, C extends Curve<V> = Curve<V>> extends Curve<V> {
     readonly isPath = true;
     readonly type: string;
     /**
      * Array of curves composing this path
      */
-    subpaths: S[];
+    curves: C[];
     /**
      * Array of points composing this path
      */
@@ -30,7 +30,7 @@ export default class Path<V extends Vector = Vector2 | Vector3, S extends Curve<
      *
      * @param {Curve} curve Curve to add
      */
-    add(curve: S): void;
+    add(curve: C): void;
     /**
      * Interpolate a point on this path
      *

package/lib/extras/paths/Path.js

@@ -12,7 +12,7 @@ export default class Path extends Curve {
     /**
      * Array of curves composing this path
      */
-    subpaths = [];
+    curves = [];
     /**
      * Array of points composing this path
      */
@@ -31,7 +31,7 @@ export default class Path extends Curve {
      * @param {Curve} curve Curve to add
      */
     add(curve) {
-        this.subpaths.push(curve);
+        this.curves.push(curve);
     }
     /**
      * Interpolate a point on this path
@@ -46,7 +46,7 @@ export default class Path extends Curve {
         while (i < curveLengths.length) {
             if (curveLengths[i] >= d) {
                 const delta = curveLengths[i] - d;
-                const curve = this.subpaths[i];
+                const curve = this.curves[i];
                 const segmentLength = curve.getLength();
                 const u = segmentLength === 0 ? 0 : 1 - delta / segmentLength;
                 return curve.getPointAt(u);
@@ -54,7 +54,7 @@ export default class Path extends Curve {
             i++;
         }
         console.warn(`Path.getPoint()`, `No point found in curve.`, this);
-        return this.subpaths[0].getPoint(0);
+        return this.curves[0].getPoint(0);
     }
     /**
      * Compute the curve shape into an array of points
@@ -65,8 +65,8 @@ export default class Path extends Curve {
     getPoints(divisions = 40) {
         const points = [];
         let lastPoint = null;
-        for (let i = 0; i < this.subpaths.length; i++) {
-            const curve = this.subpaths[i];
+        for (let i = 0; i < this.curves.length; i++) {
+            const curve = this.curves[i];
             let resolution = divisions;
             if (curve instanceof LineCurve || curve instanceof LineCurve3) {
                 resolution = 1;
@@ -80,7 +80,7 @@ export default class Path extends Curve {
             else if (curve instanceof EllipseCurve) {
                 resolution *= 2;
             }
-            const pts = this.subpaths[i].getPoints(resolution);
+            const pts = this.curves[i].getPoints(resolution);
             for (let j = 0; j < pts.length; j++) {
                 const point = pts[j];
                 if (point?.equals(lastPoint))
@@ -127,13 +127,13 @@ export default class Path extends Curve {
      * @returns {number[]}
      */
     getCurveLengths() {
-        if (this._cacheArcLengths.length === this.subpaths.length) {
+        if (this._cacheArcLengths.length === this.curves.length) {
             return this._cacheArcLengths;
         }
         const lengths = [];
         let sums = 0;
-        for (let i = 0, j = this.subpaths.length; i < j; i++) {
-            sums += this.subpaths[i].getLength();
+        for (let i = 0, j = this.curves.length; i < j; i++) {
+            sums += this.curves[i].getLength();
             lengths.push(sums);
         }
         this._cacheArcLengths = lengths;

package/lib/extras/paths/PathContext.d.ts

@@ -12,7 +12,6 @@ import Path from './Path';
 export default class PathContext extends Path<Vector2> implements CanvasRenderingContext2D {
     protected _currentPosition: Vector2;
     protected _currentTransform: DOMMatrix;
-    protected _positionTransform: DOMMatrix;
     private _transformStack;
     /**
      * Create a path from a given list of points
@@ -134,7 +133,7 @@ export default class PathContext extends Path<Vector2> implements CanvasRenderin
     arc(cx: number, cy: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): this;
     /**
      * Draw an Arc curve from the current position, tangential to the 2 segments created by both control points
-     * Add an instance of {@link ArcCurve} to this path
+     * Add an instance of {@link EllipseCurve} to this path
      *
      * @param {number} x1 X-axis coordinate of the first control point
      * @param {number} y1 Y-axis coordinate of the first control point
@@ -180,22 +179,18 @@ export default class PathContext extends Path<Vector2> implements CanvasRenderin
     reset(): void;
     protected _hasCurrentPosition(): boolean;
     protected _setCurrentPosition(x: number, y: number): this;
-    protected _transformPoint(point: Point2, matrix?: DOMMatrix): Point2;
-    protected _transformPoints(points: Point2[], matrix?: DOMMatrix): Point2[];
-    protected _transformVector(vector: Point2, matrix?: DOMMatrix): Point2;
-    protected _transformEllipse(cx: number, cy: number, rx: number, ry: number, rotation: number, matrix?: DOMMatrix): [number, number, number, number, number];
-    protected _inversePoint(point: Point2, matrix?: DOMMatrix): Point2;
+    protected _transformPoint(point: Point2): Point2;
+    protected _transformPoints(points: Point2[]): Point2[];
+    protected _transformVector(vector: Point2): Point2;
+    protected _transformEllipse(cx: number, cy: number, rx: number, ry: number, rotation: number): [number, number, number, number, number];
     protected get _translateX(): number;
     protected get _translateY(): number;
     protected get _scaleX(): number;
     protected get _scaleY(): number;
     protected get _rotation(): number;
-    protected get _skewX(): number;
-    protected get _skewY(): number;
     protected get _isTranslated(): boolean;
     protected get _isScaled(): boolean;
     protected get _isRotated(): boolean;
-    protected get _isSkewed(): boolean;
     protected get _isUniform(): boolean;
     protected get _isIdentity(): boolean;
     canvas: CanvasRenderingContext2D['canvas'];

package/lib/extras/paths/PathContext.js

@@ -14,7 +14,6 @@ import Path from './Path';
 export default class PathContext extends Path {
     _currentPosition = new Vector2(NaN, NaN);
     _currentTransform = new DOMMatrix();
-    _positionTransform = new DOMMatrix();
     _transformStack = [];
     /**
      * Create a path from a given list of points
@@ -45,8 +44,8 @@ export default class PathContext extends Path {
      * @return {this}
      */
     closePath() {
-        const startPoint = this.subpaths[0]?.getPoint(0);
-        const endPoint = this.subpaths[this.subpaths.length - 1]?.getPoint(1);
+        const startPoint = this.curves[0]?.getPoint(0);
+        const endPoint = this.curves[this.curves.length - 1]?.getPoint(1);
         if (!startPoint.equals(endPoint)) {
             const curve = new LineCurve(endPoint.x, endPoint.y, startPoint.x, startPoint.y);
             this.add(curve);
@@ -61,8 +60,8 @@ export default class PathContext extends Path {
      * @return {this}
      */
     moveTo(x, y) {
-        const [tX, tY] = this._transformPoint([x, y]);
-        this._setCurrentPosition(tX, tY);
+        [x, y] = this._transformPoint([x, y]);
+        this._setCurrentPosition(x, y);
         return this;
     }
     /**
@@ -74,12 +73,12 @@ export default class PathContext extends Path {
      * @return {this}
      */
     lineTo(x, y) {
-        const [tX, tY] = this._transformPoint([x, y]);
+        [x, y] = this._transformPoint([x, y]);
         if (!this._hasCurrentPosition())
-            return this._setCurrentPosition(tX, tY);
-        const curve = new LineCurve(this._currentPosition.x, this._currentPosition.y, tX, tY);
+            return this._setCurrentPosition(x, y);
+        const curve = new LineCurve(this._currentPosition.x, this._currentPosition.y, x, y);
         this.add(curve);
-        this._setCurrentPosition(tX, tY);
+        this._setCurrentPosition(x, y);
         return this;
     }
     /**
@@ -90,12 +89,12 @@ export default class PathContext extends Path {
      * @returns {this}
      */
     polylineTo(points) {
-        const tPoints = this._transformPoints(points);
+        points = this._transformPoints(points);
         if (!this._hasCurrentPosition())
-            this._setCurrentPosition(...tPoints[0]);
-        const curve = new PolylineCurve([this._currentPosition.toArray()].concat(tPoints));
+            this._setCurrentPosition(...points[0]);
+        const curve = new PolylineCurve([this._currentPosition.toArray()].concat(points));
         this.add(curve);
-        this._setCurrentPosition(...tPoints[tPoints.length - 1]);
+        this._setCurrentPosition(...points[points.length - 1]);
         return this;
     }
     /**
@@ -109,13 +108,13 @@ export default class PathContext extends Path {
      * @return {this}
      */
     quadraticCurveTo(cpx, cpy, x2, y2) {
-        const [tCpx, tCpy] = this._transformPoint([cpx, cpy]);
-        const [tX2, tY2] = this._transformPoint([x2, y2]);
+        [cpx, cpy] = this._transformPoint([cpx, cpy]);
+        [x2, y2] = this._transformPoint([x2, y2]);
         if (!this._hasCurrentPosition())
-            this._setCurrentPosition(tCpx, tCpy);
-        const curve = new QuadraticBezierCurve(this._currentPosition.x, this._currentPosition.y, tCpx, tCpy, tX2, tY2);
+            this._setCurrentPosition(cpx, cpy);
+        const curve = new QuadraticBezierCurve(this._currentPosition.x, this._currentPosition.y, cpx, cpy, x2, y2);
         this.add(curve);
-        this._setCurrentPosition(tX2, tY2);
+        this._setCurrentPosition(x2, y2);
         return this;
     }
     /**
@@ -131,14 +130,14 @@ export default class PathContext extends Path {
      * @return {this}
      */
     bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x2, y2) {
-        const [tCp1x, tCp1y] = this._transformPoint([cp1x, cp1y]);
-        const [tCp2x, tCp2y] = this._transformPoint([cp2x, cp2y]);
-        const [tX2, tY2] = this._transformPoint([x2, y2]);
+        [cp1x, cp1y] = this._transformPoint([cp1x, cp1y]);
+        [cp2x, cp2y] = this._transformPoint([cp2x, cp2y]);
+        [x2, y2] = this._transformPoint([x2, y2]);
         if (!this._hasCurrentPosition())
-            this._setCurrentPosition(tCp1x, tCp1y);
-        const curve = new CubicBezierCurve(this._currentPosition.x, this._currentPosition.y, tCp1x, tCp1y, tCp2x, tCp2y, tX2, tY2);
+            this._setCurrentPosition(cp1x, cp1y);
+        const curve = new CubicBezierCurve(this._currentPosition.x, this._currentPosition.y, cp1x, cp1y, cp2x, cp2y, x2, y2);
         this.add(curve);
-        this._setCurrentPosition(tX2, tY2);
+        this._setCurrentPosition(x2, y2);
         return this;
     }
     /**
@@ -154,14 +153,14 @@ export default class PathContext extends Path {
      * @return {this}
      */
     catmullRomCurveTo(cp1x, cp1y, cp2x, cp2y, x2, y2) {
-        const [tCp1x, tCp1y] = this._transformPoint([cp1x, cp1y]);
-        const [tCp2x, tCp2y] = this._transformPoint([cp2x, cp2y]);
-        const [tX2, tY2] = this._transformPoint([x2, y2]);
+        [cp1x, cp1y] = this._transformPoint([cp1x, cp1y]);
+        [cp2x, cp2y] = this._transformPoint([cp2x, cp2y]);
+        [x2, y2] = this._transformPoint([x2, y2]);
         if (!this._hasCurrentPosition())
-            this._setCurrentPosition(tCp1x, tCp1y);
-        const curve = new CatmullRomCurve(this._currentPosition.x, this._currentPosition.y, tCp1x, tCp1y, tCp2x, tCp2y, tX2, tY2);
+            this._setCurrentPosition(cp1x, cp1y);
+        const curve = new CatmullRomCurve(this._currentPosition.x, this._currentPosition.y, cp1x, cp1y, cp2x, cp2y, x2, y2);
         this.add(curve);
-        this._setCurrentPosition(tX2, tY2);
+        this._setCurrentPosition(x2, y2);
         return this;
     }
     /**
@@ -172,12 +171,12 @@ export default class PathContext extends Path {
      * @return {this}
      */
     splineTo(points) {
-        const tPoints = this._transformPoints(points);
+        points = this._transformPoints(points);
         if (!this._hasCurrentPosition())
-            this._setCurrentPosition(...tPoints[0]);
-        const curve = new SplineCurve([this._currentPosition.toArray()].concat(tPoints));
+            this._setCurrentPosition(...points[0]);
+        const curve = new SplineCurve([this._currentPosition.toArray()].concat(points));
         this.add(curve);
-        this._setCurrentPosition(...tPoints[tPoints.length - 1]);
+        this._setCurrentPosition(...points[points.length - 1]);
         return this;
     }
     /**
@@ -195,18 +194,16 @@ export default class PathContext extends Path {
      * @return {this}
      */
     ellipse(cx, cy, rx, ry, rotation, startAngle, endAngle, counterclockwise) {
-        const [tCx, tCy, tRx, tRy, tRotation] = this._transformEllipse(cx, cy, rx, ry, rotation);
-        const start = EllipseCurve.interpolate(0, tCx, tCy, tRx, tRy, tRotation, startAngle, endAngle, counterclockwise);
-        const end = EllipseCurve.interpolate(1, tCx, tCy, tRx, tRy, tRotation, startAngle, endAngle, counterclockwise);
-        if (!this._hasCurrentPosition())
-            this._setCurrentPosition(...start);
-        else if (!this._currentPosition.equals(start)) {
-            const curve = new LineCurve(this._currentPosition.x, this._currentPosition.y, ...start);
-            this.add(curve);
+        [cx, cy, rx, ry, rotation] = this._transformEllipse(cx, cy, rx, ry, rotation);
+        const start = EllipseCurve.interpolate(0, cx, cy, rx, ry, rotation, startAngle, endAngle, counterclockwise);
+        const end = EllipseCurve.interpolate(1, cx, cy, rx, ry, rotation, startAngle, endAngle, counterclockwise);
+        if (this._hasCurrentPosition() && !this._currentPosition.equals(start)) {
+            const line = new LineCurve(this._currentPosition.x, this._currentPosition.y, ...start);
+            this.add(line);
         }
-        if (tRx <= EPSILON && tRy <= EPSILON)
+        if (rx <= EPSILON && ry <= EPSILON)
             return this;
-        const curve = new EllipseCurve(tCx, tCy, tRx, tRy, tRotation, startAngle, endAngle, counterclockwise);
+        const curve = new EllipseCurve(cx, cy, rx, ry, rotation, startAngle, endAngle, counterclockwise);
         this.add(curve);
         this._setCurrentPosition(...end);
         return this;
@@ -227,25 +224,23 @@ export default class PathContext extends Path {
         if (!this._isUniform || this._isRotated) {
             return this.ellipse(cx, cy, radius, radius, 0, startAngle, endAngle, counterclockwise);
         }
-        const [tCx, tCy, tRadius] = this._transformEllipse(cx, cy, radius, radius, 0);
-        const start = EllipseCurve.interpolate(0, tCx, tCy, tRadius, tRadius, 0, startAngle, endAngle, counterclockwise);
-        const end = EllipseCurve.interpolate(1, tCx, tCy, tRadius, tRadius, 0, startAngle, endAngle, counterclockwise);
-        if (!this._hasCurrentPosition())
-            this._setCurrentPosition(...start);
-        else if (!this._currentPosition.equals(start)) {
-            const curve = new LineCurve(this._currentPosition.x, this._currentPosition.y, ...start);
-            this.add(curve);
+        [cx, cy, radius] = this._transformEllipse(cx, cy, radius, radius, 0);
+        const start = EllipseCurve.interpolate(0, cx, cy, radius, radius, 0, startAngle, endAngle, counterclockwise);
+        const end = EllipseCurve.interpolate(1, cx, cy, radius, radius, 0, startAngle, endAngle, counterclockwise);
+        if (this._hasCurrentPosition() && !this._currentPosition.equals(start)) {
+            const line = new LineCurve(this._currentPosition.x, this._currentPosition.y, ...start);
+            this.add(line);
         }
-        if (tRadius <= EPSILON)
+        if (radius <= EPSILON)
             return this;
-        const curve = new ArcCurve(tCx, tCy, tRadius, startAngle, endAngle, counterclockwise);
+        const curve = new ArcCurve(cx, cy, radius, startAngle, endAngle, counterclockwise);
         this.add(curve);
         this._setCurrentPosition(...end);
         return this;
     }
     /**
      * Draw an Arc curve from the current position, tangential to the 2 segments created by both control points
-     * Add an instance of {@link ArcCurve} to this path
+     * Add an instance of {@link EllipseCurve} to this path
      *
      * @param {number} x1 X-axis coordinate of the first control point
      * @param {number} y1 Y-axis coordinate of the first control point
@@ -345,7 +340,6 @@ export default class PathContext extends Path {
         bottomLeftRadius = Math.min(bottomLeftRadius, maxRadius);
         const curve = new PathContext({ autoClose: true });
         curve.setTransform(this.getTransform());
-        this.add(curve);
         // Top-Right corner
         if (topRightRadius > 0) {
             curve.lineTo(x + width - topRightRadius, y);
@@ -378,6 +372,7 @@ export default class PathContext extends Path {
         else {
             curve.lineTo(x, y);
         }
+        this.add(curve);
         return this;
     }
     setTransform(a, b, c, d, e, f) {
@@ -426,43 +421,39 @@ export default class PathContext extends Path {
     }
     _setCurrentPosition(x, y) {
         this._currentPosition.set(x, y);
-        this._positionTransform = this.getTransform();
         return this;
     }
     // ****************************
     // Matrix transformations
     // ****************************
-    _transformPoint(point, matrix = this._currentTransform) {
-        if (matrix.isIdentity)
+    _transformPoint(point) {
+        if (this._isIdentity)
             return point;
-        const { x, y } = matrix.transformPoint({ x: point[0], y: point[1] });
+        const { x, y } = this._currentTransform.transformPoint({ x: point[0], y: point[1] });
         return [x, y];
     }
-    _transformPoints(points, matrix = this._currentTransform) {
-        if (matrix.isIdentity)
+    _transformPoints(points) {
+        if (this._isIdentity)
             return points;
-        return points.map((point) => this._transformPoint(point, matrix));
+        return points.map((point) => this._transformPoint(point));
     }
-    _transformVector(vector, matrix = this._currentTransform) {
-        if (matrix.isIdentity)
+    _transformVector(vector) {
+        if (this._isIdentity)
             return vector;
-        const [x0, y0] = this._transformPoint([0, 0], matrix);
-        const [vx, vy] = this._transformPoint(vector, matrix);
+        const [x0, y0] = this._transformPoint([0, 0]);
+        const [vx, vy] = this._transformPoint(vector);
         return [vx - x0, vy - y0];
     }
-    _transformEllipse(cx, cy, rx, ry, rotation, matrix = this._currentTransform) {
-        if (matrix.isIdentity)
+    _transformEllipse(cx, cy, rx, ry, rotation) {
+        if (this._isIdentity)
             return [cx, cy, rx, ry, rotation];
-        const [tCx, tCy] = this._transformPoint([cx, cy], matrix);
-        const [ux1, uy1] = this._transformVector([Math.cos(rotation) * rx, Math.sin(rotation) * rx], matrix);
-        const [ux2, uy2] = this._transformVector([-Math.sin(rotation) * ry, Math.cos(rotation) * ry], matrix);
-        const tRx = Math.hypot(ux1, uy1);
-        const tRy = Math.hypot(ux2, uy2);
-        const tRotation = Math.atan2(uy1, ux1);
-        return [tCx, tCy, tRx, tRy, tRotation];
-    }
-    _inversePoint(point, matrix = this._currentTransform) {
-        return this._transformPoint(point, matrix.inverse());
+        [cx, cy] = this._transformPoint([cx, cy]);
+        const [u1x, u1y] = this._transformVector([Math.cos(rotation) * rx, Math.sin(rotation) * rx]);
+        const [u2x, u2y] = this._transformVector([-Math.sin(rotation) * ry, Math.cos(rotation) * ry]);
+        rx = Math.hypot(u1x, u1y);
+        ry = Math.hypot(u2x, u2y);
+        rotation = Math.atan2(u1y, u1x);
+        return [cx, cy, rx, ry, rotation];
     }
     get _translateX() {
         return this._currentTransform.e;
@@ -482,20 +473,6 @@ export default class PathContext extends Path {
         const { a, b } = this._currentTransform;
         return Math.atan2(b, a);
     }
-    get _skewX() {
-        const { c, d } = this._currentTransform;
-        const cos = Math.cos(this._rotation);
-        const sin = Math.sin(this._rotation);
-        const m11 = c * cos + d * sin;
-        return Math.atan(m11 / this._scaleX);
-    }
-    get _skewY() {
-        const { a, b } = this._currentTransform;
-        const cos = Math.cos(this._rotation);
-        const sin = Math.sin(this._rotation);
-        const m21 = a * sin - b * cos;
-        return Math.atan(m21 / this._scaleY);
-    }
     get _isTranslated() {
         return Math.abs(this._translateX) > EPSILON || Math.abs(this._translateY) > EPSILON;
     }
@@ -506,12 +483,6 @@ export default class PathContext extends Path {
         const { b, c } = this._currentTransform;
         return Math.abs(b) > EPSILON || Math.abs(c) > EPSILON;
     }
-    get _isSkewed() {
-        const { a, b, c, d } = this._currentTransform;
-        const angleX = Math.atan2(b, a);
-        const angleY = Math.atan2(-c, d);
-        return Math.abs(angleX - angleY) > EPSILON;
-    }
     get _isUniform() {
         return Math.abs(this._scaleX - this._scaleY) <= EPSILON;
     }