geometric-library 1.3.0 → 1.4.0

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

@@ -1,7 +1,5 @@
-import { Calculator } from '../utilities/Calculator';
-import { Magnitude } from './Magnitude';
-import { Point } from './Point';
-import { Vector } from './Vector';
+import { Point, Vector } from '..';
+import { Calculator } from '../../utilities/calculator';
 export class Figure {
     angles = [];
     isRelative = false;
@@ -19,23 +17,22 @@ export 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) {
-                result[0].push(value);
-            }
-            if (value instanceof Vector) {
-                result[1].push(value);
-            }
-            if (value instanceof 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;
         }, [[], [], [], []]);
@@ -74,10 +71,13 @@ export 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 Vector([referencePoint, positionalPoint]);
+                vector.replace(reflectedVector);
             });
             return this;
         }
@@ -130,6 +130,21 @@ export class Figure {
         });
         return this;
     }
+    scaleXY(factorX, factorY, about = new Point([0, 0])) {
+        const { points, vectors } = this;
+        if (!points) {
+            throw new Error(Figure.getNoPointsErrorMessage('scaleXY'));
+        }
+        points.forEach((point) => {
+            const scaledX = +Calculator.add(about.x, Calculator.sub(point.x, about.x).mul(factorX));
+            const scaledY = +Calculator.add(about.y, Calculator.sub(point.y, about.y).mul(factorY));
+            point.replace(new Point([scaledX, scaledY]));
+        });
+        vectors.forEach((vector) => {
+            vector.replace(new Vector([+Calculator.mul(vector.dx, factorX), +Calculator.mul(vector.dy, factorY)]));
+        });
+        return this;
+    }
     translate(vector) {
         const { points } = this;
         if (!points) {

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+export * from './Figure';
+export * from './Figure.types';

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

@@ -1,4 +1,5 @@
 export class Flag {
+    kind = 'flag';
     _value;
     constructor(value) {
         this._value = value;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+export * from './Flag';
+export * from './Flag.types';

package/dist/esm/abstracts/index.js

@@ -0,0 +1,6 @@
+export * from './angle';
+export * from './figure';
+export * from './flag';
+export * from './magnitude';
+export * from './point';
+export * from './vector';

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

@@ -1,9 +1,13 @@
-import { Calculator } from '../utilities/Calculator';
+import { Calculator } from '../../utilities/calculator';
 export class Magnitude {
+    kind = 'magnitude';
     _value;
     constructor(value) {
         this._value = value;
     }
+    get value() {
+        return this._value;
+    }
     clone() {
         return new Magnitude(+this);
     }

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+export * from './Magnitude';
+export * from './Magnitude.types';

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

@@ -1,5 +1,6 @@
-import { Calculator } from '../utilities/Calculator';
+import { Calculator } from '../../utilities/calculator';
 export class Point {
+    kind = 'point';
     _x;
     _y;
     constructor([x, y]) {

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+export * from './Point';
+export * from './Point.types';

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

@@ -1,6 +1,7 @@
-import { Calculator } from '../utilities/Calculator';
-import { Angle } from './Angle';
+import { Angle } from '..';
+import { Calculator } from '../../utilities/calculator';
 export class Vector {
+    kind = 'vector';
     _dx;
     _dy;
     constructor(values) {

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+export * from './Vector';
+export * from './Vector.types';

package/dist/esm/figures/{ArcCurve.js → arc-curve/ArcCurve.js}

@@ -1,7 +1,7 @@
-import { Calculator } from '../utilities/Calculator';
-import { Point } from '../abstracts/Point';
-import { Figure } from '../abstracts/Figure';
-import { Ellipse } from './Ellipse';
+import { Angle, Figure, Point } from '../../abstracts';
+import { CubicBezierCurve } from '../cubic-bezier-curve/CubicBezierCurve';
+import { Ellipse } from '../ellipse/Ellipse';
+import { Calculator } from '../../utilities/calculator';
 export class ArcCurve extends Figure {
     ellipse;
     largeArcFlag;
@@ -34,7 +34,7 @@ export class ArcCurve extends Figure {
         const [minTheta, maxTheta] = this.computeThetaRange();
         return ellipse.criticalPoints.filter((point) => {
             const { P0, P1 } = this;
-            if ((point.x === P0.x && point.y === P0.y) || (point.x === P1.x && point.y === P1.y)) {
+            if ((Calculator.isEqual(point.x, P0.x) && Calculator.isEqual(point.y, P0.y)) || (Calculator.isEqual(point.x, P1.x) && Calculator.isEqual(point.y, P1.y))) {
                 return false;
             }
             const theta = ellipse.computeThetaForPoint(point);
@@ -51,7 +51,7 @@ export class ArcCurve extends Figure {
         return this.points[1];
     }
     clone() {
-        const values = this.values.map((value) => (typeof value === 'object' && 'clone' in value ? value.clone() : value));
+        const values = this.values.map((value) => (typeof value === 'object' && 'clone' in value ? value.clone() : /* v8 ignore next */ value));
         return new ArcCurve(values);
     }
     reflect(about) {
@@ -59,6 +59,30 @@ export class ArcCurve extends Figure {
         this.sweepFlag.invert();
         return this;
     }
+    toCubicBezierCurves() {
+        const [minTheta, maxTheta] = this.computeThetaRange();
+        const p0Theta = this.ellipse.computeThetaForPoint(this.P0);
+        const p0IsMin = Calculator.isEqual(+p0Theta.radians, +minTheta.radians);
+        const span = +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.add(minTheta.radians, Calculator.mul(segmentAngle, i));
+                t2Rad = +Calculator.add(minTheta.radians, Calculator.mul(segmentAngle, i + 1));
+            }
+            else {
+                t1Rad = +Calculator.sub(maxTheta.radians, Calculator.mul(segmentAngle, i));
+                t2Rad = +Calculator.sub(maxTheta.radians, Calculator.mul(segmentAngle, i + 1));
+            }
+            curves.push(this.computeBezierSegment(new Angle(t1Rad, 'radians'), new Angle(t2Rad, 'radians')));
+        }
+        return curves;
+    }
     adjustRadii() {
         const { rx, ry } = this;
         const P0_prime = this.computeP0Prime();
@@ -73,6 +97,18 @@ export class ArcCurve extends Figure {
             ry.replace(+Calculator.mul(+ry, radii_check.sqrt()));
         }
     }
+    computeBezierSegment(theta1, theta2) {
+        const { ellipse } = this;
+        const alpha = +Calculator.sub(theta2.radians, theta1.radians);
+        const k = +Calculator.mul(4, Calculator.tan(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 Point([+Calculator.add(p0.x, Calculator.mul(k, t1x)), +Calculator.add(p0.y, Calculator.mul(k, t1y))]);
+        const p2 = new Point([+Calculator.sub(p3.x, Calculator.mul(k, t2x)), +Calculator.sub(p3.y, Calculator.mul(k, t2y))]);
+        return new CubicBezierCurve([p0, p1, p2, p3]);
+    }
     computeCenter() {
         const { P0, P1, phi } = this;
         const center_prime = this.computeCenterPrime();
@@ -99,7 +135,7 @@ export class ArcCurve extends Figure {
             .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 ? new Calculator(0) : sq;
+        sq = +sq < 0 ? /* v8 ignore next */ new Calculator(0) : sq;
         const coef = sign.mul(sq.sqrt());
         const cx_prime = coef.mul(Calculator.mul(+rx, y1_prime).div(+ry));
         const cy_prime = coef.mul(Calculator.mul(+ry, x1_prime).div(+rx).neg());
@@ -115,11 +151,17 @@ export class ArcCurve extends Figure {
         const y1_prime = Calculator.mul(phi.sin, mx).neg().add(Calculator.mul(phi.cos, my));
         return new Point([+x1_prime, +y1_prime]);
     }
+    computeTangentForTheta(theta) {
+        const { phi, rx, ry } = this.ellipse;
+        const tx = +Calculator.neg(Calculator.mul(+rx, theta.sin).mul(phi.cos)).sub(Calculator.mul(+ry, theta.cos).mul(phi.sin));
+        const ty = +Calculator.neg(Calculator.mul(+rx, theta.sin).mul(phi.sin)).add(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 (+theta2 === 0 && !sweepFlag.value) {
+        if (Calculator.isNearZero(+theta2) && !sweepFlag.value) {
             theta2.replace(360, 'degrees');
         }
         const thetaRange = [theta1, theta2].sort((a, b) => +Calculator.sub(a.radians, b.radians));

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+export * from './ArcCurve';
+export * from './ArcCurve.types';

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

@@ -1,7 +1,6 @@
-import { Calculator } from '../utilities/Calculator';
-import { Ellipse } from './Ellipse';
-import { Point } from '../abstracts/Point';
-import { Angle } from '../abstracts/Angle';
+import { Angle, Point } from '../../abstracts';
+import { Ellipse } from '../ellipse/Ellipse';
+import { Calculator } from '../../utilities/calculator';
 export class Circle extends Ellipse {
     _radius;
     constructor(values) {

package/dist/esm/figures/circle/Circle.types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/figures/circle/index.js

@@ -0,0 +1,2 @@
+export * from './Circle';
+export * from './Circle.types';

package/dist/esm/figures/{CubicBezierCurve.js → cubic-bezier-curve/CubicBezierCurve.js}

@@ -1,6 +1,5 @@
-import { Calculator } from '../utilities/Calculator';
-import { Point } from '../abstracts/Point';
-import { Figure } from '../abstracts/Figure';
+import { Figure, Point } from '../../abstracts';
+import { Calculator } from '../../utilities/calculator';
 export class CubicBezierCurve extends Figure {
     _criticalPoints;
     constructor(values) {
@@ -58,6 +57,11 @@ export class CubicBezierCurve extends Figure {
         this.recompute();
         return this;
     }
+    scaleXY(factorX, factorY, about) {
+        super.scaleXY(factorX, factorY, about);
+        this.recompute();
+        return this;
+    }
     translate(vector) {
         super.translate(vector);
         this.recompute();
@@ -70,7 +74,8 @@ export class CubicBezierCurve extends Figure {
         }
         const criticalPoints = tValues.reduce((criticalPoints, t) => {
             const criticalPoint = this.getPointAtParameter(t);
-            criticalPoint && criticalPoints.push(criticalPoint);
+            if (criticalPoint)
+                criticalPoints.push(criticalPoint);
             return criticalPoints;
         }, []);
         return criticalPoints;
@@ -92,7 +97,7 @@ export class CubicBezierCurve extends Figure {
             for (let n = 0; n < signs.length; n++) {
                 const sign = signs[n];
                 let tValue;
-                if (+a === 0) {
+                if (Calculator.isNearZero(+a)) {
                     // 1st degree equation to avoid n/0
                     tValue = c.neg().div(b);
                 }
@@ -111,7 +116,7 @@ export class CubicBezierCurve extends Figure {
         if (!tValues.length) {
             return;
         }
-        return tValues.filter((value, index, array) => index === array.findIndex((v) => +value === +v));
+        return tValues.filter((value, index, array) => index === array.findIndex((v) => Calculator.isEqual(+value, +v)));
     }
     getCoordinateAtParameter(t, axis) {
         const { P0, P1, P2, P3 } = this;

package/dist/esm/figures/cubic-bezier-curve/CubicBezierCurve.types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/figures/cubic-bezier-curve/index.js

@@ -0,0 +1,2 @@
+export * from './CubicBezierCurve';
+export * from './CubicBezierCurve.types';

package/dist/esm/figures/{Ellipse.js → ellipse/Ellipse.js}

@@ -1,8 +1,15 @@
-import { Calculator } from '../utilities/Calculator';
-import { Angle } from '../abstracts/Angle';
-import { Point } from '../abstracts/Point';
-import { Figure } from '../abstracts/Figure';
-import { xAxis } from '../utilities';
+import { Angle, Figure, Point, Vector } from '../../abstracts';
+import { CubicBezierCurve } from '../cubic-bezier-curve/CubicBezierCurve';
+import { Calculator } from '../../utilities/calculator';
+import { Line } from '../line/Line';
+const KAPPA = 0.5522847498307936;
+const xAxis = new Line([new Point([0, 0]), new Point([1, 0])]);
+const unitCircleCubicBezierCurves = [
+    new CubicBezierCurve([new Point([1, 0]), new Point([1, KAPPA]), new Point([KAPPA, 1]), new Point([0, 1])]),
+    new CubicBezierCurve([new Point([0, 1]), new Point([-KAPPA, 1]), new Point([-1, KAPPA]), new Point([-1, 0])]),
+    new CubicBezierCurve([new Point([-1, 0]), new Point([-1, -KAPPA]), new Point([-KAPPA, -1]), new Point([0, -1])]),
+    new CubicBezierCurve([new Point([0, -1]), new Point([KAPPA, -1]), new Point([1, -KAPPA]), new Point([1, 0])])
+];
 export class Ellipse extends Figure {
     _center;
     _criticalPoints;
@@ -28,7 +35,7 @@ export class Ellipse extends Figure {
         return this._criticalPoints;
     }
     get isCircle() {
-        return +this.rx === +this.ry;
+        return Calculator.isEqual(+this.rx, +this.ry);
     }
     get phi() {
         return this._phi;
@@ -83,6 +90,17 @@ export class Ellipse extends Figure {
         this.recompute();
         return this;
     }
+    toCubicBezierCurves() {
+        const { rx, ry, phi, center } = this;
+        const curves = unitCircleCubicBezierCurves.map((curve) => {
+            return curve
+                .clone()
+                .scaleXY(+rx, +ry)
+                .rotate(phi)
+                .translate(new Vector([center.x, center.y]));
+        });
+        return curves;
+    }
     translate(vector) {
         this._center.translate(vector);
         this.recompute();

package/dist/esm/figures/ellipse/Ellipse.types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/figures/ellipse/index.js

@@ -0,0 +1,2 @@
+export * from './Ellipse';
+export * from './Ellipse.types';

package/dist/esm/figures/index.js

@@ -0,0 +1,7 @@
+export * from './arc-curve';
+export * from './circle';
+export * from './cubic-bezier-curve';
+export * from './ellipse';
+export * from './line';
+export * from './polygon';
+export * from './quadratic-bezier-curve';

package/dist/esm/figures/{Line.js → line/Line.js}

@@ -1,12 +1,10 @@
-import { Calculator } from '../utilities/Calculator';
-import { Angle } from '../abstracts/Angle';
-import { Point } from '../abstracts/Point';
-import { Vector } from '../abstracts/Vector';
-import { Figure } from '../abstracts/Figure';
+import { Angle, Figure, Point, Vector } from '../../abstracts';
+import { Calculator } from '../../utilities/calculator';
 export class Line extends Figure {
     _P0;
     _P1;
     _V;
+    _dirty = true;
     _reciprocal;
     _slope;
     _xIntercept;
@@ -24,10 +22,6 @@ export class Line extends Figure {
             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];
     }
@@ -80,33 +74,41 @@ export class Line extends Figure {
         return typeof slope === 'undefined';
     }
     get reciprocal() {
+        this.ensureComputed();
         return this._reciprocal;
     }
     get slope() {
+        this.ensureComputed();
         return this._slope;
     }
     get xIntercept() {
+        this.ensureComputed();
         return this._xIntercept;
     }
     get yIntercept() {
+        this.ensureComputed();
         return this._yIntercept;
     }
-    angleTo(line) {
-        if (this.isParallelTo(line)) {
-            return new Angle(0, 'radians');
-        }
-        if (this.isPerpendicularTo(line)) {
-            return new Angle(+Calculator.div(Math.PI, 2), 'radians');
-        }
-        if (typeof this.slope === 'undefined') {
-            return new Angle(+Calculator.atan(line.slope), 'radians');
-        }
-        if (typeof line.slope === 'undefined') {
-            return new Angle(+Calculator.atan(this.slope), 'radians');
-        }
-        const thisSlope = new Calculator(this.slope);
-        const lineSlope = new Calculator(line.slope);
-        return new Angle(+lineSlope.sub(thisSlope).div(thisSlope.mul(lineSlope).add(1)).abs().atan(), 'radians');
+    angleTo(reference) {
+        if ('slope' in reference) {
+            const line = reference;
+            if (this.isParallelTo(line)) {
+                return new Angle(0, 'radians');
+            }
+            if (this.isPerpendicularTo(line)) {
+                return new Angle(+Calculator.div(Math.PI, 2), 'radians');
+            }
+            if (typeof this.slope === 'undefined') {
+                return new Angle(+Calculator.atan(line.slope), 'radians');
+            }
+            if (typeof line.slope === 'undefined') {
+                return new Angle(+Calculator.atan(this.slope), 'radians');
+            }
+            const thisSlope = new Calculator(this.slope);
+            const lineSlope = new Calculator(line.slope);
+            return new Angle(+lineSlope.sub(thisSlope).div(thisSlope.mul(lineSlope).add(1)).abs().atan(), 'radians');
+        }
+        return this.V.angleTo(reference);
     }
     clone() {
         const values = this.values.map((value) => value.clone());
@@ -134,9 +136,11 @@ export class Line extends Figure {
             perpendicularProjection = new Point([point.x, P0.y]);
         }
         else {
-            const x = new Calculator(1);
-            const y = x.mul(1).div(slope).neg().add(Calculator.div(point.x, slope)).add(point.y);
-            perpendicularProjection = new Point([+x, +y]);
+            const perpendicularSlope = +Calculator.div(-1, slope);
+            const perpendicularYIntercept = +Calculator.sub(point.y, Calculator.mul(perpendicularSlope, point.x));
+            const x = +Calculator.sub(perpendicularYIntercept, this.yIntercept).div(Calculator.sub(slope, perpendicularSlope));
+            const y = +Calculator.mul(slope, x).add(this.yIntercept);
+            perpendicularProjection = new Point([x, y]);
         }
         return perpendicularProjection;
     }
@@ -174,11 +178,17 @@ export class Line extends Figure {
         return +Calculator.mul(slope, x).add(yIntercept);
     }
     hasPoint(P) {
+        if (this.isVertical) {
+            return Calculator.isEqual(P.x, this.P0.x);
+        }
         const potentialY = this.getYValueAtX(P.x);
-        return typeof potentialY === 'number' && potentialY === P.y;
+        return typeof potentialY === 'number' && Calculator.isEqual(potentialY, P.y);
     }
     isParallelTo(line) {
-        return this.slope == line.slope;
+        if (typeof this.slope === 'undefined' || typeof line.slope === 'undefined') {
+            return typeof this.slope === typeof line.slope;
+        }
+        return Calculator.isEqual(this.slope, line.slope);
     }
     isPerpendicularTo(line) {
         if (this.isVertical) {
@@ -187,34 +197,39 @@ export class Line extends Figure {
         if (this.isHorizontal) {
             return line.isVertical;
         }
+        /* v8 ignore next 3 */
         if (line.isVertical) {
             return this.isHorizontal;
         }
+        /* v8 ignore next 3 */
         if (line.isHorizontal) {
             return this.isVertical;
         }
-        const thisSlope = new Calculator(this.slope);
-        const lineSlope = new Calculator(line.slope);
-        return +thisSlope === +Calculator.div(-1, lineSlope);
+        return Calculator.isEqual(this.slope, +Calculator.div(-1, line.slope));
     }
     reflect(about) {
         super.reflect(about);
-        this.recompute();
+        this._dirty = true;
         return this;
     }
     rotate(phi, about) {
         super.rotate(phi, about);
-        this.recompute();
+        this._dirty = true;
         return this;
     }
     scale(factor, about) {
         super.scale(factor, about);
-        this.recompute();
+        this._dirty = true;
+        return this;
+    }
+    scaleXY(factorX, factorY, about) {
+        super.scaleXY(factorX, factorY, about);
+        this._dirty = true;
         return this;
     }
     translate(vector) {
         super.translate(vector);
-        this.recompute();
+        this._dirty = true;
         return this;
     }
     computeReciprocal() {
@@ -251,7 +266,11 @@ export class Line extends Figure {
         }
         return +Calculator.sub(P0.y, Calculator.mul(slope, P0.x));
     }
-    recompute() {
+    ensureComputed() {
+        if (!this._dirty) {
+            return;
+        }
+        this._dirty = false;
         this._slope = this.computeSlope();
         this._yIntercept = this.computeYIntercept();
         this._reciprocal = this.computeReciprocal();

package/dist/esm/figures/line/Line.types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/figures/line/index.js

@@ -0,0 +1,2 @@
+export * from './Line';
+export * from './Line.types';