geometric-library 1.3.1 → 1.4.0

package/dist/cjs/abstracts/{Figure.js → figure/Figure.js}

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Figure = void 0;
-const Calculator_1 = require("../utilities/Calculator");
-const Magnitude_1 = require("./Magnitude");
-const Point_1 = require("./Point");
-const Vector_1 = require("./Vector");
+const _abstracts_1 = require("..");
+const calculator_1 = require("../../utilities/calculator");
 class Figure {
     angles = [];
     isRelative = false;
@@ -22,23 +20,22 @@ class Figure {
     get values() {
         return this._values;
     }
-    /**
-     * @todo Figure out a better way to type narrow than iterating again.
-     */
     set values(values) {
         this._values = values;
         const [points, vectors, magnitudes, angles] = values.reduce((result, value) => {
-            if (value instanceof Point_1.Point) {
-                result[0].push(value);
-            }
-            if (value instanceof Vector_1.Vector) {
-                result[1].push(value);
-            }
-            if (value instanceof Magnitude_1.Magnitude) {
-                result[2].push(value);
-            }
-            if (typeof value === 'object' && 'radians' in value) {
-                result[3].push(value);
+            switch (value.kind) {
+                case 'point':
+                    result[0].push(value);
+                    break;
+                case 'vector':
+                    result[1].push(value);
+                    break;
+                case 'magnitude':
+                    result[2].push(value);
+                    break;
+                case 'angle':
+                    result[3].push(value);
+                    break;
             }
             return result;
         }, [[], [], [], []]);
@@ -57,10 +54,10 @@ class Figure {
             values[1].push(point.y);
             return values;
         }, [[], []]);
-        const xMax = +Calculator_1.Calculator.max(xValues);
-        const xMin = +Calculator_1.Calculator.min(xValues);
-        const yMax = +Calculator_1.Calculator.max(yValues);
-        const yMin = +Calculator_1.Calculator.min(yValues);
+        const xMax = +calculator_1.Calculator.max(xValues);
+        const xMin = +calculator_1.Calculator.min(xValues);
+        const yMax = +calculator_1.Calculator.max(yValues);
+        const yMin = +calculator_1.Calculator.min(yValues);
         return { xMax, xMin, yMax, yMin };
     }
     static getNoPointsErrorMessage(name, property = false) {
@@ -77,10 +74,13 @@ class Figure {
                 point.reflect(perpendicularRoot);
             });
             vectors.forEach((vector) => {
-                vector.reflect({
-                    x: !about.isHorizontal,
-                    y: !about.isVertical
-                });
+                const referenceProjection = about.getPerpendicularProjection(points[0]);
+                const referencePoint = points[0].clone().reflect(referenceProjection);
+                const endPoint = points[0].clone().translate(vector);
+                const endProjection = about.getPerpendicularProjection(endPoint);
+                const positionalPoint = endPoint.reflect(endProjection);
+                const reflectedVector = new _abstracts_1.Vector([referencePoint, positionalPoint]);
+                vector.replace(reflectedVector);
             });
             return this;
         }
@@ -106,21 +106,21 @@ class Figure {
         vectors.forEach((vector) => {
             const referencePoint = points[0].clone().rotate(phi, about);
             const positionalPoint = points[0].clone().translate(vector).rotate(phi, about);
-            const rotatedVector = new Vector_1.Vector([referencePoint, positionalPoint]);
+            const rotatedVector = new _abstracts_1.Vector([referencePoint, positionalPoint]);
             vector.replace(rotatedVector);
         });
         angles.forEach((angle) => {
-            angle.replace(+Calculator_1.Calculator.add(+angle, +phi), 'radians').normalize();
+            angle.replace(+calculator_1.Calculator.add(+angle, +phi), 'radians').normalize();
         });
         return this;
     }
-    scale(factor, about = new Point_1.Point([0, 0])) {
+    scale(factor, about = new _abstracts_1.Point([0, 0])) {
         const { points, vectors, magnitudes } = this;
         if (!points) {
             throw new Error(Figure.getNoPointsErrorMessage('scale'));
         }
         points.forEach((point) => {
-            const positionalVector = new Vector_1.Vector([about, point]);
+            const positionalVector = new _abstracts_1.Vector([about, point]);
             const scaledPositionalVector = positionalVector.clone().scale(factor);
             const scaledPoint = about.clone().translate(scaledPositionalVector);
             point.replace(scaledPoint);
@@ -133,6 +133,21 @@ class Figure {
         });
         return this;
     }
+    scaleXY(factorX, factorY, about = new _abstracts_1.Point([0, 0])) {
+        const { points, vectors } = this;
+        if (!points) {
+            throw new Error(Figure.getNoPointsErrorMessage('scaleXY'));
+        }
+        points.forEach((point) => {
+            const scaledX = +calculator_1.Calculator.add(about.x, calculator_1.Calculator.sub(point.x, about.x).mul(factorX));
+            const scaledY = +calculator_1.Calculator.add(about.y, calculator_1.Calculator.sub(point.y, about.y).mul(factorY));
+            point.replace(new _abstracts_1.Point([scaledX, scaledY]));
+        });
+        vectors.forEach((vector) => {
+            vector.replace(new _abstracts_1.Vector([+calculator_1.Calculator.mul(vector.dx, factorX), +calculator_1.Calculator.mul(vector.dy, factorY)]));
+        });
+        return this;
+    }
     translate(vector) {
         const { points } = this;
         if (!points) {

package/dist/cjs/abstracts/figure/Figure.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/abstracts/figure/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Figure"), exports);
+__exportStar(require("./Figure.types"), exports);

package/dist/cjs/abstracts/{Flag.js → flag/Flag.js}

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Flag = void 0;
 class Flag {
+    kind = 'flag';
     _value;
     constructor(value) {
         this._value = value;

package/dist/cjs/abstracts/flag/Flag.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/abstracts/flag/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Flag"), exports);
+__exportStar(require("./Flag.types"), exports);

package/dist/cjs/abstracts/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./angle"), exports);
+__exportStar(require("./figure"), exports);
+__exportStar(require("./flag"), exports);
+__exportStar(require("./magnitude"), exports);
+__exportStar(require("./point"), exports);
+__exportStar(require("./vector"), exports);

package/dist/cjs/abstracts/{Magnitude.js → magnitude/Magnitude.js}

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Magnitude = void 0;
-const Calculator_1 = require("../utilities/Calculator");
+const calculator_1 = require("../../utilities/calculator");
 class Magnitude {
+    kind = 'magnitude';
     _value;
     constructor(value) {
         this._value = value;
@@ -18,7 +19,7 @@ class Magnitude {
         return this;
     }
     scale(factor) {
-        this._value = +Calculator_1.Calculator.mul(+this, factor);
+        this._value = +calculator_1.Calculator.mul(+this, factor);
         return this;
     }
     valueOf() {

package/dist/cjs/abstracts/magnitude/Magnitude.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/abstracts/magnitude/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Magnitude"), exports);
+__exportStar(require("./Magnitude.types"), exports);

package/dist/cjs/abstracts/{Point.js → point/Point.js}

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Point = void 0;
-const Calculator_1 = require("../utilities/Calculator");
+const calculator_1 = require("../../utilities/calculator");
 class Point {
+    kind = 'point';
     _x;
     _y;
     constructor([x, y]) {
@@ -24,8 +25,8 @@ class Point {
     }
     reflect(about) {
         const { x, y } = this;
-        this._x = +Calculator_1.Calculator.sub(about.x, x).mul(2).add(x);
-        this._y = +Calculator_1.Calculator.sub(about.y, y).mul(2).add(y);
+        this._x = +calculator_1.Calculator.sub(about.x, x).mul(2).add(x);
+        this._y = +calculator_1.Calculator.sub(about.y, y).mul(2).add(y);
         return this;
     }
     replace(point) {
@@ -34,16 +35,16 @@ class Point {
         return this;
     }
     rotate(phi, about = new Point([0, 0])) {
-        const dx = Calculator_1.Calculator.sub(this.x, about.x);
-        const dy = Calculator_1.Calculator.sub(this.y, about.y);
+        const dx = calculator_1.Calculator.sub(this.x, about.x);
+        const dy = calculator_1.Calculator.sub(this.y, about.y);
         this._x = +dx.mul(phi.cos).sub(dy.mul(phi.sin)).add(about.x);
         this._y = +dy.mul(phi.cos).add(dx.mul(phi.sin)).add(about.y);
         return this;
     }
     translate(vector) {
         const { x, y } = this;
-        this._x = +Calculator_1.Calculator.add(x, vector.dx);
-        this._y = +Calculator_1.Calculator.add(y, vector.dy);
+        this._x = +calculator_1.Calculator.add(x, vector.dx);
+        this._y = +calculator_1.Calculator.add(y, vector.dy);
         return this;
     }
 }

package/dist/cjs/abstracts/point/Point.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/abstracts/point/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Point"), exports);
+__exportStar(require("./Point.types"), exports);

package/dist/cjs/abstracts/{Vector.js → vector/Vector.js}

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Vector = void 0;
-const Calculator_1 = require("../utilities/Calculator");
-const Angle_1 = require("./Angle");
+const _abstracts_1 = require("..");
+const calculator_1 = require("../../utilities/calculator");
 class Vector {
+    kind = 'vector';
     _dx;
     _dy;
     constructor(values) {
         const fromPoints = values.some((value) => typeof value !== 'number');
         if (fromPoints) {
             const [P1, P2] = values;
-            this._dx = +Calculator_1.Calculator.sub(P2.x, P1.x);
-            this._dy = +Calculator_1.Calculator.sub(P2.y, P1.y);
+            this._dx = +calculator_1.Calculator.sub(P2.x, P1.x);
+            this._dy = +calculator_1.Calculator.sub(P2.y, P1.y);
             return;
         }
         const [dx, dy] = values;
@@ -26,7 +27,7 @@ class Vector {
     }
     get magnitude() {
         const { dx, dy } = this;
-        return +Calculator_1.Calculator.pow(dx, 2).add(Calculator_1.Calculator.pow(dy, 2)).sqrt();
+        return +calculator_1.Calculator.pow(dx, 2).add(calculator_1.Calculator.pow(dy, 2)).sqrt();
     }
     get values() {
         return [this.dx, this.dy];
@@ -35,10 +36,10 @@ class Vector {
         const dotProd = this.dotProduct(vector);
         const magV1 = this.magnitude;
         const magV2 = vector.magnitude;
-        const magProd = Calculator_1.Calculator.mul(magV1, magV2);
-        const cosAngle = Calculator_1.Calculator.div(dotProd, magProd);
+        const magProd = calculator_1.Calculator.mul(magV1, magV2);
+        const cosAngle = calculator_1.Calculator.div(dotProd, magProd);
         const angle = cosAngle.acos();
-        return new Angle_1.Angle(+angle, 'radians');
+        return new _abstracts_1.Angle(+angle, 'radians');
     }
     clone() {
         const { dx, dy } = this;
@@ -46,11 +47,11 @@ class Vector {
     }
     dotProduct(vector) {
         const { dx, dy } = this;
-        return +Calculator_1.Calculator.mul(dx, vector.dx).add(Calculator_1.Calculator.mul(dy, vector.dy));
+        return +calculator_1.Calculator.mul(dx, vector.dx).add(calculator_1.Calculator.mul(dy, vector.dy));
     }
     reflect({ x, y }) {
-        this._dx = x ? +Calculator_1.Calculator.neg(this.dx) : this.dx;
-        this._dy = y ? +Calculator_1.Calculator.neg(this.dy) : this.dy;
+        this._dx = x ? +calculator_1.Calculator.neg(this.dx) : this.dx;
+        this._dy = y ? +calculator_1.Calculator.neg(this.dy) : this.dy;
         return this;
     }
     replace(vector) {
@@ -60,14 +61,14 @@ class Vector {
     }
     rotate(phi) {
         const { dx, dy } = this;
-        this._dx = +Calculator_1.Calculator.mul(phi.cos, dx).sub(Calculator_1.Calculator.mul(phi.sin, dy));
-        this._dy = +Calculator_1.Calculator.mul(phi.sin, dx).add(Calculator_1.Calculator.mul(phi.cos, dy));
+        this._dx = +calculator_1.Calculator.mul(phi.cos, dx).sub(calculator_1.Calculator.mul(phi.sin, dy));
+        this._dy = +calculator_1.Calculator.mul(phi.sin, dx).add(calculator_1.Calculator.mul(phi.cos, dy));
         return this;
     }
     scale(factor) {
         const { dx, dy } = this;
-        this._dx = +Calculator_1.Calculator.mul(dx, factor);
-        this._dy = +Calculator_1.Calculator.mul(dy, factor);
+        this._dx = +calculator_1.Calculator.mul(dx, factor);
+        this._dy = +calculator_1.Calculator.mul(dy, factor);
         return this;
     }
 }

package/dist/cjs/abstracts/vector/Vector.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/abstracts/vector/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Vector"), exports);
+__exportStar(require("./Vector.types"), exports);

package/dist/cjs/figures/arc-curve/ArcCurve.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArcCurve = void 0;
+const _abstracts_1 = require("../../abstracts");
+const CubicBezierCurve_1 = require("../cubic-bezier-curve/CubicBezierCurve");
+const Ellipse_1 = require("../ellipse/Ellipse");
+const calculator_1 = require("../../utilities/calculator");
+class ArcCurve extends _abstracts_1.Figure {
+    ellipse;
+    largeArcFlag;
+    phi;
+    rx;
+    ry;
+    sweepFlag;
+    constructor(values) {
+        super(values);
+        const [, rx, ry, phi, largeArcFlag, sweepFlag] = values;
+        this.rx = rx;
+        this.ry = ry;
+        this.phi = phi;
+        this.largeArcFlag = largeArcFlag;
+        this.sweepFlag = sweepFlag;
+        this.adjustRadii();
+        const center = this.computeCenter();
+        this.ellipse = new Ellipse_1.Ellipse([center, rx, ry, phi]);
+    }
+    get boundingBox() {
+        const { P0, P1 } = this;
+        const points = [P0, P1, ...this.criticalPoints];
+        return _abstracts_1.Figure.computeBoundingBox(points);
+    }
+    get center() {
+        return this.ellipse.center;
+    }
+    get criticalPoints() {
+        const { ellipse } = this;
+        const [minTheta, maxTheta] = this.computeThetaRange();
+        return ellipse.criticalPoints.filter((point) => {
+            const { P0, P1 } = this;
+            if ((calculator_1.Calculator.isEqual(point.x, P0.x) && calculator_1.Calculator.isEqual(point.y, P0.y)) || (calculator_1.Calculator.isEqual(point.x, P1.x) && calculator_1.Calculator.isEqual(point.y, P1.y))) {
+                return false;
+            }
+            const theta = ellipse.computeThetaForPoint(point);
+            return +theta >= +minTheta && +theta <= +maxTheta;
+        });
+    }
+    get P0() {
+        return this.points[0];
+    }
+    get P1() {
+        if (this.isRelative) {
+            return this.P0.clone().translate(this.vectors[0]);
+        }
+        return this.points[1];
+    }
+    clone() {
+        const values = this.values.map((value) => (typeof value === 'object' && 'clone' in value ? value.clone() : /* v8 ignore next */ value));
+        return new ArcCurve(values);
+    }
+    reflect(about) {
+        super.reflect(about);
+        this.sweepFlag.invert();
+        return this;
+    }
+    toCubicBezierCurves() {
+        const [minTheta, maxTheta] = this.computeThetaRange();
+        const p0Theta = this.ellipse.computeThetaForPoint(this.P0);
+        const p0IsMin = calculator_1.Calculator.isEqual(+p0Theta.radians, +minTheta.radians);
+        const span = +calculator_1.Calculator.sub(maxTheta.radians, minTheta.radians);
+        const halfPi = Math.PI / 2;
+        const numSegments = Math.max(1, Math.ceil(span / halfPi));
+        const segmentAngle = span / numSegments;
+        const curves = [];
+        for (let i = 0; i < numSegments; i++) {
+            let t1Rad;
+            let t2Rad;
+            if (p0IsMin) {
+                t1Rad = +calculator_1.Calculator.add(minTheta.radians, calculator_1.Calculator.mul(segmentAngle, i));
+                t2Rad = +calculator_1.Calculator.add(minTheta.radians, calculator_1.Calculator.mul(segmentAngle, i + 1));
+            }
+            else {
+                t1Rad = +calculator_1.Calculator.sub(maxTheta.radians, calculator_1.Calculator.mul(segmentAngle, i));
+                t2Rad = +calculator_1.Calculator.sub(maxTheta.radians, calculator_1.Calculator.mul(segmentAngle, i + 1));
+            }
+            curves.push(this.computeBezierSegment(new _abstracts_1.Angle(t1Rad, 'radians'), new _abstracts_1.Angle(t2Rad, 'radians')));
+        }
+        return curves;
+    }
+    adjustRadii() {
+        const { rx, ry } = this;
+        const P0_prime = this.computeP0Prime();
+        const { x: x1_prime, y: y1_prime } = P0_prime;
+        const rx_sq = calculator_1.Calculator.pow(+rx, 2);
+        const ry_sq = calculator_1.Calculator.pow(+ry, 2);
+        const x1_prime_sq = calculator_1.Calculator.pow(x1_prime, 2);
+        const y1_prime_sq = calculator_1.Calculator.pow(y1_prime, 2);
+        const radii_check = x1_prime_sq.div(rx_sq).add(y1_prime_sq.div(ry_sq));
+        if (+radii_check > 1) {
+            rx.replace(+calculator_1.Calculator.mul(+rx, radii_check.sqrt()));
+            ry.replace(+calculator_1.Calculator.mul(+ry, radii_check.sqrt()));
+        }
+    }
+    computeBezierSegment(theta1, theta2) {
+        const { ellipse } = this;
+        const alpha = +calculator_1.Calculator.sub(theta2.radians, theta1.radians);
+        const k = +calculator_1.Calculator.mul(4, calculator_1.Calculator.tan(calculator_1.Calculator.div(alpha, 4))).div(3);
+        const p0 = ellipse.computePointForTheta(theta1);
+        const p3 = ellipse.computePointForTheta(theta2);
+        const [t1x, t1y] = this.computeTangentForTheta(theta1);
+        const [t2x, t2y] = this.computeTangentForTheta(theta2);
+        const p1 = new _abstracts_1.Point([+calculator_1.Calculator.add(p0.x, calculator_1.Calculator.mul(k, t1x)), +calculator_1.Calculator.add(p0.y, calculator_1.Calculator.mul(k, t1y))]);
+        const p2 = new _abstracts_1.Point([+calculator_1.Calculator.sub(p3.x, calculator_1.Calculator.mul(k, t2x)), +calculator_1.Calculator.sub(p3.y, calculator_1.Calculator.mul(k, t2y))]);
+        return new CubicBezierCurve_1.CubicBezierCurve([p0, p1, p2, p3]);
+    }
+    computeCenter() {
+        const { P0, P1, phi } = this;
+        const center_prime = this.computeCenterPrime();
+        const { x: x1, y: y1 } = P0;
+        const { x: x2, y: y2 } = P1;
+        const { x: cx_prime, y: cy_prime } = center_prime;
+        const dx = calculator_1.Calculator.add(x1, x2).div(2);
+        const dy = calculator_1.Calculator.add(y1, y2).div(2);
+        const cx = calculator_1.Calculator.mul(phi.cos, cx_prime).sub(calculator_1.Calculator.mul(phi.sin, cy_prime)).add(dx);
+        const cy = calculator_1.Calculator.mul(phi.sin, cx_prime).add(calculator_1.Calculator.mul(phi.cos, cy_prime)).add(dy);
+        return new _abstracts_1.Point([+cx, +cy]);
+    }
+    computeCenterPrime() {
+        const { largeArcFlag, sweepFlag, rx, ry } = this;
+        const P0_prime = this.computeP0Prime();
+        const { x: x1_prime, y: y1_prime } = P0_prime;
+        const rx_sq = calculator_1.Calculator.pow(+rx, 2);
+        const ry_sq = calculator_1.Calculator.pow(+ry, 2);
+        const x1_prime_sq = calculator_1.Calculator.pow(x1_prime, 2);
+        const y1_prime_sq = calculator_1.Calculator.pow(y1_prime, 2);
+        const sign = new calculator_1.Calculator(+largeArcFlag === +sweepFlag ? -1 : 1);
+        let sq = rx_sq
+            .mul(ry_sq)
+            .sub(rx_sq.mul(y1_prime_sq))
+            .sub(ry_sq.mul(x1_prime_sq))
+            .div(rx_sq.mul(y1_prime_sq).add(ry_sq.mul(x1_prime_sq)));
+        sq = +sq < 0 ? /* v8 ignore next */ new calculator_1.Calculator(0) : sq;
+        const coef = sign.mul(sq.sqrt());
+        const cx_prime = coef.mul(calculator_1.Calculator.mul(+rx, y1_prime).div(+ry));
+        const cy_prime = coef.mul(calculator_1.Calculator.mul(+ry, x1_prime).div(+rx).neg());
+        return new _abstracts_1.Point([+cx_prime, +cy_prime]);
+    }
+    computeP0Prime() {
+        const { P0, P1, phi } = this;
+        const { x: x1, y: y1 } = P0;
+        const { x: x2, y: y2 } = P1;
+        const mx = calculator_1.Calculator.sub(x1, x2).div(2);
+        const my = calculator_1.Calculator.sub(y1, y2).div(2);
+        const x1_prime = calculator_1.Calculator.mul(phi.cos, mx).add(calculator_1.Calculator.mul(phi.sin, my));
+        const y1_prime = calculator_1.Calculator.mul(phi.sin, mx).neg().add(calculator_1.Calculator.mul(phi.cos, my));
+        return new _abstracts_1.Point([+x1_prime, +y1_prime]);
+    }
+    computeTangentForTheta(theta) {
+        const { phi, rx, ry } = this.ellipse;
+        const tx = +calculator_1.Calculator.neg(calculator_1.Calculator.mul(+rx, theta.sin).mul(phi.cos)).sub(calculator_1.Calculator.mul(+ry, theta.cos).mul(phi.sin));
+        const ty = +calculator_1.Calculator.neg(calculator_1.Calculator.mul(+rx, theta.sin).mul(phi.sin)).add(calculator_1.Calculator.mul(+ry, theta.cos).mul(phi.cos));
+        return [tx, ty];
+    }
+    computeThetaRange() {
+        const { P0, P1, ellipse, sweepFlag } = this;
+        const theta1 = ellipse.computeThetaForPoint(P0);
+        const theta2 = ellipse.computeThetaForPoint(P1);
+        if (calculator_1.Calculator.isNearZero(+theta2) && !sweepFlag.value) {
+            theta2.replace(360, 'degrees');
+        }
+        const thetaRange = [theta1, theta2].sort((a, b) => +calculator_1.Calculator.sub(a.radians, b.radians));
+        return thetaRange;
+    }
+}
+exports.ArcCurve = ArcCurve;

package/dist/cjs/figures/arc-curve/ArcCurve.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/figures/arc-curve/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ArcCurve"), exports);
+__exportStar(require("./ArcCurve.types"), exports);

package/dist/cjs/figures/{Circle.js → circle/Circle.js}

@@ -1,15 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Circle = void 0;
-const Calculator_1 = require("../utilities/Calculator");
-const Ellipse_1 = require("./Ellipse");
-const Point_1 = require("../abstracts/Point");
-const Angle_1 = require("../abstracts/Angle");
+const _abstracts_1 = require("../../abstracts");
+const Ellipse_1 = require("../ellipse/Ellipse");
+const calculator_1 = require("../../utilities/calculator");
 class Circle extends Ellipse_1.Ellipse {
     _radius;
     constructor(values) {
         const [center, radius] = values;
-        const phi = new Angle_1.Angle(0, 'radians'); // Always 0 since circles don't change with rotation.
+        const phi = new _abstracts_1.Angle(0, 'radians'); // Always 0 since circles don't change with rotation.
         super([center, radius, radius.clone(), phi]);
         this._radius = radius;
     }
@@ -33,10 +32,10 @@ class Circle extends Ellipse_1.Ellipse {
     computeCriticalPoints(ellipse = this) {
         const { center, rx } = ellipse;
         const radius = rx;
-        const first = new Point_1.Point([center.x, +Calculator_1.Calculator.add(center.y, +radius)]);
-        const second = new Point_1.Point([+Calculator_1.Calculator.add(center.x, +radius), center.y]);
-        const third = new Point_1.Point([center.x, +Calculator_1.Calculator.sub(center.y, +radius)]);
-        const fourth = new Point_1.Point([+Calculator_1.Calculator.sub(center.x, +radius), center.y]);
+        const first = new _abstracts_1.Point([center.x, +calculator_1.Calculator.add(center.y, +radius)]);
+        const second = new _abstracts_1.Point([+calculator_1.Calculator.add(center.x, +radius), center.y]);
+        const third = new _abstracts_1.Point([center.x, +calculator_1.Calculator.sub(center.y, +radius)]);
+        const fourth = new _abstracts_1.Point([+calculator_1.Calculator.sub(center.x, +radius), center.y]);
         return [first, second, third, fourth];
     }
 }