geometric-library 1.3.1 → 1.4.0

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';

package/dist/esm/figures/polygon/Polygon.js

@@ -0,0 +1,47 @@
+import { Figure } from '../../abstracts';
+import { Line } from '../line/Line';
+export class Polygon extends Figure {
+    _lines;
+    constructor(values) {
+        super(values);
+        this._lines = this.computeLines();
+    }
+    get lines() {
+        return this._lines;
+    }
+    get sides() {
+        return this.points.length;
+    }
+    clone() {
+        const values = this.values.map((value) => value.clone());
+        return new Polygon(values);
+    }
+    reflect(about) {
+        super.reflect(about);
+        this._lines = this.computeLines();
+        return this;
+    }
+    rotate(phi, about) {
+        super.rotate(phi, about);
+        this._lines = this.computeLines();
+        return this;
+    }
+    scale(factor, about) {
+        super.scale(factor, about);
+        this._lines = this.computeLines();
+        return this;
+    }
+    scaleXY(factorX, factorY, about) {
+        super.scaleXY(factorX, factorY, about);
+        this._lines = this.computeLines();
+        return this;
+    }
+    translate(vector) {
+        super.translate(vector);
+        this._lines = this.computeLines();
+        return this;
+    }
+    computeLines() {
+        return this.points.map((point, i) => new Line([point, this.points[(i + 1) % this.points.length]]));
+    }
+}

package/dist/esm/figures/polygon/Polygon.types.js

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

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

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

package/dist/esm/figures/{QuadraticBezierCurve.js → quadratic-bezier-curve/QuadraticBezierCurve.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 QuadraticBezierCurve extends Figure {
     _criticalPoints;
     constructor(values) {
@@ -52,6 +51,11 @@ export class QuadraticBezierCurve 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();

package/dist/esm/figures/quadratic-bezier-curve/QuadraticBezierCurve.types.js

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

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

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

package/dist/esm/index.js

@@ -1,17 +1,5 @@
 /* v8 ignore */
-export { Angle } from './abstracts/Angle';
-export { Figure } from './abstracts/Figure';
-export { Flag } from './abstracts/Flag';
-export { Magnitude } from './abstracts/Magnitude';
-export { Point } from './abstracts/Point';
-export { Vector } from './abstracts/Vector.js';
-export { ArcCurve } from './figures/ArcCurve';
-export { Circle } from './figures/Circle';
-export { CubicBezierCurve } from './figures/CubicBezierCurve';
-export { Ellipse } from './figures/Ellipse';
-export { Line } from './figures/Line';
-export { Polygon } from './figures/Polygon';
-export { QuadraticBezierCurve } from './figures/QuadraticBezierCurve';
-export { Calculator } from './utilities/Calculator';
+export * from './abstracts';
+export * from './figures';
 export * from './utilities';
 export * from './types';

package/dist/esm/utilities/{Calculator.js → calculator/Calculator.js}

@@ -1,5 +1,7 @@
 import { Decimal } from 'decimal.js';
 export class Calculator {
+    static EPSILON = 1e-8;
+    static PI2 = +Calculator.mul(Math.PI, 2);
     _instance;
     constructor(arg) {
         this._instance = new Decimal(arg);
@@ -26,6 +28,12 @@ export class Calculator {
     static div(first, second) {
         return Calculator.computeBinaryOperation('div', [first, second]);
     }
+    static isEqual(a, b) {
+        return Math.abs(a - b) <= Calculator.EPSILON;
+    }
+    static isNearZero(a) {
+        return Math.abs(a) <= Calculator.EPSILON;
+    }
     static max(args) {
         return Calculator.computeIndefiniteOperation('max', args);
     }
@@ -80,7 +88,7 @@ export class Calculator {
      * than epsilon, and then to round up to that point instead of choosing an arbitrary precision.
      */
     static roundDecimalWithPrecision(value) {
-        const epsilon = new Decimal('1e-8');
+        const epsilon = new Decimal(Calculator.EPSILON);
         const distanceToLowerInt = value.sub(value.floor());
         const distanceToUpperInt = value.ceil().sub(value);
         if (distanceToLowerInt.lte(epsilon)) {

package/dist/esm/utilities/calculator/index.js

@@ -0,0 +1 @@
+export * from './Calculator';

package/dist/esm/utilities/index.js

@@ -1,7 +1,5 @@
-import { Calculator } from './Calculator';
-import { Point } from '../abstracts/Point';
-import { Line } from '../figures/Line';
+import { Calculator } from './calculator';
+import { Point } from '../abstracts';
+export * from './calculator';
 export const coordinateOrigin = new Point([0, 0]);
-export const xAxis = new Line([coordinateOrigin, new Point([1, 0])]);
-export const yAxis = new Line([coordinateOrigin, new Point([0, 1])]);
-export const PI2 = +Calculator.mul(Math.PI, 2); // 360 degrees
+export const PI2 = Calculator.PI2;

package/dist/types/abstracts/{Angle.d.ts → angle/Angle.d.ts}

@@ -1,5 +1,6 @@
-import { IAngle, TAngleUnit } from '../types';
+import { IAngle, TAngleUnit } from './Angle.types';
 export declare class Angle implements IAngle {
+    readonly kind: "angle";
     private _radians;
     constructor(value: number, unit: TAngleUnit);
     get cos(): number;

package/dist/types/abstracts/angle/Angle.types.d.ts

@@ -0,0 +1,16 @@
+import { IClonable } from '../../types';
+export type TAngleUnit = 'radians' | 'degrees';
+export interface IAngle extends IClonable<IAngle> {
+    readonly cos: number;
+    readonly cot: number;
+    readonly degrees: number;
+    readonly kind: 'angle';
+    readonly radians: number;
+    readonly sin: number;
+    readonly tan: number;
+    normalize(): this;
+    replace(value: number, unit: TAngleUnit): this;
+    scale(factor: number): this;
+    valueOf(): number;
+}
+export type TAngleRange = [IAngle, IAngle];

package/dist/types/abstracts/angle/index.d.ts

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

package/dist/types/abstracts/{Figure.d.ts → figure/Figure.d.ts}

@@ -1,4 +1,6 @@
-import { IAngle, IBoundingBox, IFigure, ILine, IMagnitude, IPoint, IVector, TFigureValues } from '../types';
+import { IAngle, IFigure, IMagnitude, IPoint, IVector, TFigureValues } from '..';
+import type { ILine } from '../../figures';
+import { IBoundingBox } from '../../types';
 export declare abstract class Figure implements IFigure {
     protected angles: IAngle[];
     protected isRelative: boolean;
@@ -9,14 +11,12 @@ export declare abstract class Figure implements IFigure {
     constructor(values: TFigureValues);
     get boundingBox(): IBoundingBox;
     get values(): TFigureValues;
-    /**
-     * @todo Figure out a better way to type narrow than iterating again.
-     */
     protected set values(values: TFigureValues);
     protected static computeBoundingBox(points: IPoint[]): IBoundingBox;
     private static getNoPointsErrorMessage;
     reflect(about: IPoint | ILine): this;
     rotate(phi: IAngle, about?: IPoint): this;
     scale(factor: number, about?: IPoint): this;
+    scaleXY(factorX: number, factorY: number, about?: IPoint): this;
     translate(vector: IVector): this;
 }

package/dist/types/abstracts/figure/Figure.types.d.ts

@@ -0,0 +1,14 @@
+import { IAngle, IFlag, IMagnitude, IPoint, IVector } from '..';
+import { ILine } from '../../figures';
+import { IBoundingBox } from '../../types';
+export type TFigureValue = IFlag | IMagnitude | IAngle | IPoint | IVector;
+export type TFigureValues = [IPoint, ...TFigureValue[]];
+export interface IFigure {
+    readonly boundingBox: IBoundingBox;
+    readonly values: TFigureValues;
+    reflect(about: IPoint | ILine): this;
+    rotate(phi: IAngle, about?: IPoint): this;
+    scale(factor: number, about?: IPoint): this;
+    scaleXY(factorX: number, factorY: number, about?: IPoint): this;
+    translate(vector: IVector): this;
+}

package/dist/types/abstracts/figure/index.d.ts

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

package/dist/types/abstracts/{Flag.d.ts → flag/Flag.d.ts}

@@ -1,5 +1,6 @@
-import { IFlag } from '../types';
+import { IFlag } from './Flag.types';
 export declare class Flag implements IFlag {
+    readonly kind: "flag";
     private _value;
     constructor(value: boolean);
     get value(): boolean;

package/dist/types/abstracts/flag/Flag.types.d.ts

@@ -0,0 +1,8 @@
+import { IClonable } from '../../types';
+export interface IFlag extends IClonable<IFlag> {
+    readonly kind: 'flag';
+    readonly value: boolean;
+    invert(): this;
+    replace(value: boolean): this;
+    valueOf(): number;
+}

package/dist/types/abstracts/flag/index.d.ts

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

package/dist/types/abstracts/index.d.ts

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

package/dist/types/abstracts/{Magnitude.d.ts → magnitude/Magnitude.d.ts}

@@ -1,5 +1,6 @@
-import { IMagnitude } from '../types';
+import { IMagnitude } from './Magnitude.types';
 export declare class Magnitude implements IMagnitude {
+    readonly kind: "magnitude";
     private _value;
     constructor(value: number);
     get value(): number;

package/dist/types/abstracts/magnitude/Magnitude.types.d.ts

@@ -0,0 +1,8 @@
+import { IClonable } from '../../types';
+export interface IMagnitude extends IClonable<IMagnitude> {
+    readonly kind: 'magnitude';
+    readonly value: number;
+    replace(value: number): this;
+    scale(factor: number): this;
+    valueOf(): number;
+}

package/dist/types/abstracts/magnitude/index.d.ts

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

package/dist/types/abstracts/{Point.d.ts → point/Point.d.ts}

@@ -1,5 +1,6 @@
-import { IAngle, IPoint, IVector, TPointValues } from '../types';
+import { IAngle, IPoint, IVector, TPointValues } from '..';
 export declare class Point implements IPoint {
+    readonly kind: "point";
     private _x;
     private _y;
     constructor([x, y]: TPointValues);

package/dist/types/abstracts/point/Point.types.d.ts

@@ -0,0 +1,13 @@
+import { IAngle, IVector } from '..';
+import { IClonable } from '../../types';
+export type TPointValues = [number, number];
+export interface IPoint extends IClonable<IPoint> {
+    readonly kind: 'point';
+    readonly values: TPointValues;
+    readonly x: number;
+    readonly y: number;
+    reflect(about: IPoint): this;
+    replace(point: IPoint): this;
+    rotate(phi: IAngle, about?: IPoint): this;
+    translate(vector: IVector): this;
+}

package/dist/types/abstracts/point/index.d.ts

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

package/dist/types/abstracts/{Vector.d.ts → vector/Vector.d.ts}

@@ -1,5 +1,7 @@
-import { IVector, TVectorValues, TSegment, IAngle } from '../types';
+import { IVector, TVectorValues, IAngle } from '..';
+import type { TSegment } from '../../figures';
 export declare class Vector implements IVector {
+    readonly kind: "vector";
     private _dx;
     private _dy;
     constructor(values: TVectorValues | TSegment);

package/dist/types/abstracts/vector/Vector.types.d.ts

@@ -0,0 +1,19 @@
+import { IAngle } from '..';
+import { IClonable } from '../../types';
+export type TVectorValues = [number, number];
+export interface IVector extends IClonable<IVector> {
+    readonly dx: number;
+    readonly dy: number;
+    readonly kind: 'vector';
+    readonly magnitude: number;
+    readonly values: TVectorValues;
+    angleTo(vector: IVector): IAngle;
+    dotProduct(vector: IVector): number;
+    reflect(about: {
+        x: boolean;
+        y: boolean;
+    }): this;
+    replace(vector: IVector): this;
+    rotate(phi: IAngle): this;
+    scale(factor: number): this;
+}

package/dist/types/abstracts/vector/index.d.ts

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