geometric-library 1.3.0

package/dist/cjs/figures/CubicBezierCurve.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CubicBezierCurve = void 0;
+const Calculator_1 = require("../utilities/Calculator");
+const Point_1 = require("../abstracts/Point");
+const Figure_1 = require("../abstracts/Figure");
+class CubicBezierCurve extends Figure_1.Figure {
+    _criticalPoints;
+    constructor(values) {
+        super(values);
+        this._criticalPoints = this.computeCriticalPoints();
+    }
+    get boundingBox() {
+        const [P0, , , P3] = this.values;
+        const points = [P0, P3, ...this._criticalPoints];
+        return Figure_1.Figure.computeBoundingBox(points);
+    }
+    get criticalPoints() {
+        return this._criticalPoints;
+    }
+    get P0() {
+        return this.points[0];
+    }
+    get P1() {
+        if (this.isRelative) {
+            return this.P0.clone().translate(this.vectors[0]);
+        }
+        return this.points[1];
+    }
+    get P2() {
+        if (this.isRelative) {
+            return this.P0.clone().translate(this.vectors[1]);
+        }
+        return this.points[2];
+    }
+    get P3() {
+        if (this.isRelative) {
+            return this.P0.clone().translate(this.vectors[2]);
+        }
+        return this.points[3];
+    }
+    clone() {
+        const values = this.values.map((value) => value.clone());
+        return new CubicBezierCurve(values);
+    }
+    recompute() {
+        this._criticalPoints = this.computeCriticalPoints();
+    }
+    reflect(about) {
+        super.reflect(about);
+        this.recompute();
+        return this;
+    }
+    rotate(phi, about) {
+        super.rotate(phi, about);
+        this.recompute();
+        return this;
+    }
+    scale(factor, about) {
+        super.scale(factor, about);
+        this.recompute();
+        return this;
+    }
+    translate(vector) {
+        super.translate(vector);
+        this.recompute();
+        return this;
+    }
+    computeCriticalPoints() {
+        const tValues = this.computeCriticalPointsTValues();
+        if (!tValues) {
+            return [];
+        }
+        const criticalPoints = tValues.reduce((criticalPoints, t) => {
+            const criticalPoint = this.getPointAtParameter(t);
+            criticalPoint && criticalPoints.push(criticalPoint);
+            return criticalPoints;
+        }, []);
+        return criticalPoints;
+    }
+    computeCriticalPointsTValues() {
+        const axii = ['x', 'y'];
+        const { P0, P1, P2, P3 } = this;
+        const signs = [1, -1];
+        const tValues = [];
+        for (let i = 0; i < axii.length; i++) {
+            const axis = axii[i];
+            const p0 = new Calculator_1.Calculator(P0[axis]);
+            const p1 = new Calculator_1.Calculator(P1[axis]);
+            const p2 = new Calculator_1.Calculator(P2[axis]);
+            const p3 = new Calculator_1.Calculator(P3[axis]);
+            const a = p3.sub(p2.mul(3)).add(p1.mul(3)).sub(p0).mul(3);
+            const b = p2.sub(p1.mul(2)).add(p0).mul(6);
+            const c = p1.sub(p0).mul(3);
+            for (let n = 0; n < signs.length; n++) {
+                const sign = signs[n];
+                let tValue;
+                if (+a === 0) {
+                    // 1st degree equation to avoid n/0
+                    tValue = c.neg().div(b);
+                }
+                else {
+                    // 2nd degree equation
+                    tValue = b
+                        .neg()
+                        .add(Calculator_1.Calculator.mul(sign, b.pow(2).sub(a.mul(c).mul(4)).sqrt()))
+                        .div(a.mul(2));
+                }
+                if (this.isValidParameter(tValue)) {
+                    tValues.push(tValue);
+                }
+            }
+        }
+        if (!tValues.length) {
+            return;
+        }
+        return tValues.filter((value, index, array) => index === array.findIndex((v) => +value === +v));
+    }
+    getCoordinateAtParameter(t, axis) {
+        const { P0, P1, P2, P3 } = this;
+        const p0 = P0[axis];
+        const p1 = P1[axis];
+        const p2 = P2[axis];
+        const p3 = P3[axis];
+        // parametric cubic bezier equation
+        const coordinate = Calculator_1.Calculator.sub(1, t)
+            .pow(3)
+            .mul(p0)
+            .add(Calculator_1.Calculator.sub(1, t).pow(2).mul(3).mul(t).mul(p1))
+            .add(Calculator_1.Calculator.sub(1, t).mul(3).mul(t.pow(2)).mul(p2))
+            .add(t.pow(3).mul(p3));
+        if (!coordinate.isFinite()) {
+            return;
+        }
+        return coordinate;
+    }
+    getPointAtParameter(t) {
+        const x = this.getCoordinateAtParameter(t, 'x');
+        const y = this.getCoordinateAtParameter(t, 'y');
+        if (typeof x === 'undefined' || typeof y === 'undefined') {
+            return;
+        }
+        return new Point_1.Point([+x, +y]);
+    }
+    isValidParameter(t) {
+        return t.isFinite() && +t > 0 && +t < 1;
+    }
+}
+exports.CubicBezierCurve = CubicBezierCurve;

package/dist/cjs/figures/Ellipse.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ellipse = void 0;
+const Calculator_1 = require("../utilities/Calculator");
+const Angle_1 = require("../abstracts/Angle");
+const Point_1 = require("../abstracts/Point");
+const Figure_1 = require("../abstracts/Figure");
+const utilities_1 = require("../utilities");
+class Ellipse extends Figure_1.Figure {
+    _center;
+    _criticalPoints;
+    _phi;
+    _rx;
+    _ry;
+    constructor(values) {
+        super(values);
+        const [center, rx, ry, phi] = values;
+        this._center = center;
+        this._rx = rx;
+        this._ry = ry;
+        this._phi = phi;
+        this._criticalPoints = this.computeCriticalPoints({ center, rx, ry, phi });
+    }
+    get boundingBox() {
+        return Figure_1.Figure.computeBoundingBox(this.criticalPoints);
+    }
+    get center() {
+        return this._center;
+    }
+    get criticalPoints() {
+        return this._criticalPoints;
+    }
+    get isCircle() {
+        return +this.rx === +this.ry;
+    }
+    get phi() {
+        return this._phi;
+    }
+    get rx() {
+        return this._rx;
+    }
+    get ry() {
+        return this._ry;
+    }
+    clone() {
+        const values = this.values.map((value) => value.clone());
+        return new Ellipse(values);
+    }
+    computePointForTheta(theta, ellipse = this) {
+        const { center, rx, ry, phi } = ellipse;
+        const x = +Calculator_1.Calculator.mul(+rx, phi.cos).mul(theta.cos).sub(Calculator_1.Calculator.mul(+ry, phi.sin).mul(theta.sin)).add(center.x);
+        const y = +Calculator_1.Calculator.mul(+rx, phi.sin).mul(theta.cos).add(Calculator_1.Calculator.mul(+ry, phi.cos).mul(theta.sin)).add(center.y);
+        return new Point_1.Point([x, y]);
+    }
+    computeThetaForPoint({ x, y }) {
+        const { center, phi, rx, ry } = this;
+        const { x: cx, y: cy } = center;
+        const dy = Calculator_1.Calculator.sub(y, cy);
+        const dx = Calculator_1.Calculator.sub(x, cx);
+        const sinTheta = dy.mul(phi.cos).sub(dx.mul(phi.sin)).div(+ry);
+        const cosTheta = dx.mul(phi.cos).add(dy.mul(phi.sin)).div(+rx);
+        const theta = new Angle_1.Angle(+Calculator_1.Calculator.atan2(sinTheta, cosTheta), 'radians').normalize();
+        return theta;
+    }
+    reflect(about) {
+        super.reflect(about);
+        if (!this.isCircle && 'V' in about) {
+            const alpha = about.angleTo(utilities_1.xAxis);
+            this._phi.replace(+Calculator_1.Calculator.mul(2, alpha.radians).sub(this.phi.radians), 'radians');
+            this._phi.normalize();
+        }
+        this.recompute();
+        return this;
+    }
+    rotate(alpha, about) {
+        this._center.rotate(alpha, about);
+        if (!this.isCircle) {
+            this._phi.replace(+Calculator_1.Calculator.add(this.phi.radians, alpha.radians), 'radians');
+            this._phi.normalize();
+        }
+        this.recompute();
+        return this;
+    }
+    scale(factor, about = new Point_1.Point([0, 0])) {
+        super.scale(factor, about);
+        this.recompute();
+        return this;
+    }
+    translate(vector) {
+        this._center.translate(vector);
+        this.recompute();
+        return this;
+    }
+    computeCriticalPoints(ellipse = this) {
+        const { rx, ry, phi } = ellipse;
+        const { computePointForTheta } = this;
+        const xThetaPrincipal = new Angle_1.Angle(+Calculator_1.Calculator.neg(+ry).mul(phi.tan).div(+rx).atan(), 'radians');
+        const yThetaPrincipal = new Angle_1.Angle(+Calculator_1.Calculator.mul(+ry, phi.cot).div(+rx).atan(), 'radians');
+        const xThetaSecondary = new Angle_1.Angle(+Calculator_1.Calculator.add(+xThetaPrincipal, Math.PI), 'radians');
+        const yThetaSecondary = new Angle_1.Angle(+Calculator_1.Calculator.add(+yThetaPrincipal, Math.PI), 'radians');
+        const firstPoint = computePointForTheta(xThetaPrincipal, ellipse);
+        const secondPoint = computePointForTheta(yThetaPrincipal, ellipse);
+        const thirdPoint = computePointForTheta(xThetaSecondary, ellipse);
+        const fourthPoint = computePointForTheta(yThetaSecondary, ellipse);
+        return [firstPoint, secondPoint, thirdPoint, fourthPoint];
+    }
+    recompute() {
+        this._criticalPoints = this.computeCriticalPoints();
+    }
+}
+exports.Ellipse = Ellipse;

package/dist/cjs/figures/Line.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Line = void 0;
+const Calculator_1 = require("../utilities/Calculator");
+const Angle_1 = require("../abstracts/Angle");
+const Point_1 = require("../abstracts/Point");
+const Vector_1 = require("../abstracts/Vector");
+const Figure_1 = require("../abstracts/Figure");
+class Line extends Figure_1.Figure {
+    _P0;
+    _P1;
+    _V;
+    _reciprocal;
+    _slope;
+    _xIntercept;
+    _yIntercept;
+    constructor(values) {
+        super(values);
+        const [P0, anchor] = values;
+        if (anchor instanceof Vector_1.Vector) {
+            this._V = anchor;
+            this._P1 = P0.clone().translate(anchor);
+            // anchor instanceof Point
+        }
+        else {
+            this._V = new Vector_1.Vector([P0, anchor]);
+            this._P1 = anchor;
+        }
+        this._P0 = P0;
+        this._slope = this.computeSlope();
+        this._yIntercept = this.computeYIntercept();
+        this._reciprocal = this.computeReciprocal();
+        this._xIntercept = this.computeXIntercept();
+        this.points = [this.P0, this.P1];
+        this.vectors = [this.V];
+    }
+    get P0() {
+        return this._P0;
+    }
+    get P1() {
+        return this._P1;
+    }
+    get V() {
+        return this._V;
+    }
+    // STANDARD EQUATION PARAMETERS (ax + by - c = 0)
+    get a() {
+        const { slope, isVertical, isHorizontal } = this;
+        if (isVertical) {
+            return 1;
+        }
+        if (isHorizontal) {
+            return 0;
+        }
+        return slope >= 0 ? slope : -slope;
+    }
+    get b() {
+        const { slope, isVertical, isHorizontal } = this;
+        if (isVertical) {
+            return 0;
+        }
+        if (isHorizontal) {
+            return 1;
+        }
+        return slope >= 0 ? -1 : 1;
+    }
+    get c() {
+        const { slope, isVertical, isHorizontal, yIntercept, xIntercept } = this;
+        if (isVertical) {
+            return xIntercept;
+        }
+        if (isHorizontal) {
+            return yIntercept;
+        }
+        return slope >= 0 ? -yIntercept : yIntercept;
+    }
+    get isHorizontal() {
+        const { slope, isVertical } = this;
+        return !isVertical && slope === 0;
+    }
+    get isVertical() {
+        const { slope } = this;
+        return typeof slope === 'undefined';
+    }
+    get reciprocal() {
+        return this._reciprocal;
+    }
+    get slope() {
+        return this._slope;
+    }
+    get xIntercept() {
+        return this._xIntercept;
+    }
+    get yIntercept() {
+        return this._yIntercept;
+    }
+    angleTo(line) {
+        if (this.isParallelTo(line)) {
+            return new Angle_1.Angle(0, 'radians');
+        }
+        if (this.isPerpendicularTo(line)) {
+            return new Angle_1.Angle(+Calculator_1.Calculator.div(Math.PI, 2), 'radians');
+        }
+        if (typeof this.slope === 'undefined') {
+            return new Angle_1.Angle(+Calculator_1.Calculator.atan(line.slope), 'radians');
+        }
+        if (typeof line.slope === 'undefined') {
+            return new Angle_1.Angle(+Calculator_1.Calculator.atan(this.slope), 'radians');
+        }
+        const thisSlope = new Calculator_1.Calculator(this.slope);
+        const lineSlope = new Calculator_1.Calculator(line.slope);
+        return new Angle_1.Angle(+lineSlope.sub(thisSlope).div(thisSlope.mul(lineSlope).add(1)).abs().atan(), 'radians');
+    }
+    clone() {
+        const values = this.values.map((value) => value.clone());
+        return new Line(values);
+    }
+    getIntersectionPoint(line) {
+        if (this.isParallelTo(line)) {
+            return;
+        }
+        const denominator = Calculator_1.Calculator.mul(this.a, line.b).sub(Calculator_1.Calculator.mul(line.a, this.b));
+        const x = +Calculator_1.Calculator.mul(this.b, line.c).sub(Calculator_1.Calculator.mul(line.b, this.c)).div(denominator);
+        const y = +Calculator_1.Calculator.mul(this.c, line.a).sub(Calculator_1.Calculator.mul(line.c, this.a)).div(denominator);
+        return new Point_1.Point([x, y]);
+    }
+    getPerpendicularProjection(point) {
+        const { P0, slope, isVertical, isHorizontal } = this;
+        let perpendicularProjection;
+        if (this.hasPoint(point)) {
+            return point.clone();
+        }
+        if (isVertical) {
+            perpendicularProjection = new Point_1.Point([P0.x, point.y]);
+        }
+        else if (isHorizontal) {
+            perpendicularProjection = new Point_1.Point([point.x, P0.y]);
+        }
+        else {
+            const x = new Calculator_1.Calculator(1);
+            const y = x.mul(1).div(slope).neg().add(Calculator_1.Calculator.div(point.x, slope)).add(point.y);
+            perpendicularProjection = new Point_1.Point([+x, +y]);
+        }
+        return perpendicularProjection;
+    }
+    getPerpendicularThrough(point) {
+        if (this.hasPoint(point)) {
+            const phi = new Angle_1.Angle(+Calculator_1.Calculator.div(Math.PI, 2), 'radians');
+            return this.clone().rotate(phi, point);
+        }
+        return new Line([point, this.getPerpendicularProjection(point)]);
+    }
+    getPointAtParameter(t) {
+        const { P0, V } = this;
+        const x = +Calculator_1.Calculator.add(P0.x, Calculator_1.Calculator.mul(V.dx, t));
+        const y = +Calculator_1.Calculator.add(P0.y, Calculator_1.Calculator.mul(V.dy, t));
+        return new Point_1.Point([x, y]);
+    }
+    getXValueAtY(y) {
+        const { reciprocal, xIntercept } = this;
+        if (typeof reciprocal === 'undefined') {
+            return;
+        }
+        if (typeof xIntercept === 'undefined') {
+            return +Calculator_1.Calculator.mul(reciprocal, y);
+        }
+        return +Calculator_1.Calculator.mul(reciprocal, y).add(xIntercept);
+    }
+    getYValueAtX(x) {
+        const { slope, yIntercept } = this;
+        if (typeof slope === 'undefined') {
+            return;
+        }
+        if (typeof yIntercept === 'undefined') {
+            return +Calculator_1.Calculator.mul(slope, x);
+        }
+        return +Calculator_1.Calculator.mul(slope, x).add(yIntercept);
+    }
+    hasPoint(P) {
+        const potentialY = this.getYValueAtX(P.x);
+        return typeof potentialY === 'number' && potentialY === P.y;
+    }
+    isParallelTo(line) {
+        return this.slope == line.slope;
+    }
+    isPerpendicularTo(line) {
+        if (this.isVertical) {
+            return line.isHorizontal;
+        }
+        if (this.isHorizontal) {
+            return line.isVertical;
+        }
+        if (line.isVertical) {
+            return this.isHorizontal;
+        }
+        if (line.isHorizontal) {
+            return this.isVertical;
+        }
+        const thisSlope = new Calculator_1.Calculator(this.slope);
+        const lineSlope = new Calculator_1.Calculator(line.slope);
+        return +thisSlope === +Calculator_1.Calculator.div(-1, lineSlope);
+    }
+    reflect(about) {
+        super.reflect(about);
+        this.recompute();
+        return this;
+    }
+    rotate(phi, about) {
+        super.rotate(phi, about);
+        this.recompute();
+        return this;
+    }
+    scale(factor, about) {
+        super.scale(factor, about);
+        this.recompute();
+        return this;
+    }
+    translate(vector) {
+        super.translate(vector);
+        this.recompute();
+        return this;
+    }
+    computeReciprocal() {
+        const { P0, P1 } = this;
+        const reciprocal = Calculator_1.Calculator.sub(P1.x, P0.x).div(Calculator_1.Calculator.sub(P1.y, P0.y));
+        if (reciprocal.isFinite()) {
+            return +reciprocal;
+        }
+    }
+    computeSlope() {
+        const { P0, P1 } = this;
+        const slope = Calculator_1.Calculator.sub(P1.y, P0.y).div(Calculator_1.Calculator.sub(P1.x, P0.x));
+        if (slope.isFinite()) {
+            return +slope;
+        }
+    }
+    computeXIntercept() {
+        const { P0, reciprocal, isHorizontal, isVertical } = this;
+        if (isVertical) {
+            return P0.x;
+        }
+        if (isHorizontal) {
+            return;
+        }
+        return +Calculator_1.Calculator.sub(P0.x, Calculator_1.Calculator.mul(reciprocal, P0.y));
+    }
+    computeYIntercept() {
+        const { P0, slope, isVertical, isHorizontal } = this;
+        if (isVertical) {
+            return;
+        }
+        if (isHorizontal) {
+            return P0.y;
+        }
+        return +Calculator_1.Calculator.sub(P0.y, Calculator_1.Calculator.mul(slope, P0.x));
+    }
+    recompute() {
+        this._slope = this.computeSlope();
+        this._yIntercept = this.computeYIntercept();
+        this._reciprocal = this.computeReciprocal();
+        this._xIntercept = this.computeXIntercept();
+    }
+}
+exports.Line = Line;

package/dist/cjs/figures/Polygon.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Polygon = void 0;
+const Figure_1 = require("../abstracts/Figure");
+class Polygon extends Figure_1.Figure {
+    constructor(values) {
+        super(values);
+    }
+    get sides() {
+        return this.points.length;
+    }
+    clone() {
+        const values = this.values.map((value) => value.clone());
+        return new Polygon(values);
+    }
+}
+exports.Polygon = Polygon;

package/dist/cjs/figures/QuadraticBezierCurve.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuadraticBezierCurve = void 0;
+const Calculator_1 = require("../utilities/Calculator");
+const Point_1 = require("../abstracts/Point");
+const Figure_1 = require("../abstracts/Figure");
+class QuadraticBezierCurve extends Figure_1.Figure {
+    _criticalPoints;
+    constructor(values) {
+        super(values);
+        this._criticalPoints = this.computeCriticalPoints();
+    }
+    get boundingBox() {
+        const [P0, , P2] = this.values;
+        const points = [P0, P2, ...this._criticalPoints];
+        return Figure_1.Figure.computeBoundingBox(points);
+    }
+    get criticalPoints() {
+        return this._criticalPoints;
+    }
+    get P0() {
+        return this.points[0];
+    }
+    get P1() {
+        if (this.isRelative) {
+            return this.P0.clone().translate(this.vectors[0]);
+        }
+        return this.points[1];
+    }
+    get P2() {
+        if (this.isRelative) {
+            return this.P0.clone().translate(this.vectors[1]);
+        }
+        return this.points[2];
+    }
+    clone() {
+        const values = this.values.map((value) => value.clone());
+        return new QuadraticBezierCurve(values);
+    }
+    recompute() {
+        this._criticalPoints = this.computeCriticalPoints();
+    }
+    reflect(about) {
+        super.reflect(about);
+        this.recompute();
+        return this;
+    }
+    rotate(phi, about) {
+        super.rotate(phi, about);
+        this.recompute();
+        return this;
+    }
+    scale(factor, about) {
+        super.scale(factor, about);
+        this.recompute();
+        return this;
+    }
+    translate(vector) {
+        super.translate(vector);
+        this.recompute();
+        return this;
+    }
+    computeCriticalPoints() {
+        const t = this.getCriticalPointTValue();
+        if (typeof t === 'undefined') {
+            return [];
+        }
+        const point = this.getPointAtParameter(t);
+        if (!point) {
+            return [];
+        }
+        return [point];
+    }
+    getCoordinateAtParameter(t, axis) {
+        const { P0, P1, P2 } = this;
+        const coordinate = Calculator_1.Calculator.sub(1, t).pow(2).mul(P0[axis]).add(Calculator_1.Calculator.sub(1, t).mul(2).mul(t).mul(P1[axis])).add(t.pow(2).mul(P2[axis]));
+        if (coordinate.isFinite()) {
+            return coordinate;
+        }
+    }
+    getCriticalPointTValue() {
+        const axii = ['x', 'y'];
+        const { P0, P1, P2 } = this;
+        let value;
+        for (let i = 0; i < axii.length; i++) {
+            const axis = axii[i];
+            const potentialValue = Calculator_1.Calculator.sub(P0[axis], P1[axis]).div(Calculator_1.Calculator.sub(P0[axis], Calculator_1.Calculator.mul(P1[axis], 2)).add(P2[axis]));
+            if (+potentialValue > 0 && +potentialValue < 1) {
+                value = potentialValue;
+                break;
+            }
+        }
+        return value;
+    }
+    getPointAtParameter(t) {
+        const x = this.getCoordinateAtParameter(t, 'x');
+        const y = this.getCoordinateAtParameter(t, 'y');
+        if (typeof x === 'undefined' || typeof y === 'undefined') {
+            return;
+        }
+        return new Point_1.Point([+x, +y]);
+    }
+}
+exports.QuadraticBezierCurve = QuadraticBezierCurve;

package/dist/cjs/index.js

@@ -0,0 +1,48 @@
+"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 });
+exports.Calculator = exports.QuadraticBezierCurve = exports.Polygon = exports.Line = exports.Ellipse = exports.CubicBezierCurve = exports.Circle = exports.ArcCurve = exports.Vector = exports.Point = exports.Magnitude = exports.Flag = exports.Figure = exports.Angle = void 0;
+/* v8 ignore */
+var Angle_1 = require("./abstracts/Angle");
+Object.defineProperty(exports, "Angle", { enumerable: true, get: function () { return Angle_1.Angle; } });
+var Figure_1 = require("./abstracts/Figure");
+Object.defineProperty(exports, "Figure", { enumerable: true, get: function () { return Figure_1.Figure; } });
+var Flag_1 = require("./abstracts/Flag");
+Object.defineProperty(exports, "Flag", { enumerable: true, get: function () { return Flag_1.Flag; } });
+var Magnitude_1 = require("./abstracts/Magnitude");
+Object.defineProperty(exports, "Magnitude", { enumerable: true, get: function () { return Magnitude_1.Magnitude; } });
+var Point_1 = require("./abstracts/Point");
+Object.defineProperty(exports, "Point", { enumerable: true, get: function () { return Point_1.Point; } });
+var Vector_js_1 = require("./abstracts/Vector.js");
+Object.defineProperty(exports, "Vector", { enumerable: true, get: function () { return Vector_js_1.Vector; } });
+var ArcCurve_1 = require("./figures/ArcCurve");
+Object.defineProperty(exports, "ArcCurve", { enumerable: true, get: function () { return ArcCurve_1.ArcCurve; } });
+var Circle_1 = require("./figures/Circle");
+Object.defineProperty(exports, "Circle", { enumerable: true, get: function () { return Circle_1.Circle; } });
+var CubicBezierCurve_1 = require("./figures/CubicBezierCurve");
+Object.defineProperty(exports, "CubicBezierCurve", { enumerable: true, get: function () { return CubicBezierCurve_1.CubicBezierCurve; } });
+var Ellipse_1 = require("./figures/Ellipse");
+Object.defineProperty(exports, "Ellipse", { enumerable: true, get: function () { return Ellipse_1.Ellipse; } });
+var Line_1 = require("./figures/Line");
+Object.defineProperty(exports, "Line", { enumerable: true, get: function () { return Line_1.Line; } });
+var Polygon_1 = require("./figures/Polygon");
+Object.defineProperty(exports, "Polygon", { enumerable: true, get: function () { return Polygon_1.Polygon; } });
+var QuadraticBezierCurve_1 = require("./figures/QuadraticBezierCurve");
+Object.defineProperty(exports, "QuadraticBezierCurve", { enumerable: true, get: function () { return QuadraticBezierCurve_1.QuadraticBezierCurve; } });
+var Calculator_1 = require("./utilities/Calculator");
+Object.defineProperty(exports, "Calculator", { enumerable: true, get: function () { return Calculator_1.Calculator; } });
+__exportStar(require("./utilities"), exports);
+__exportStar(require("./types"), exports);

package/dist/cjs/types/index.js

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