geometric-library 1.3.0 → 1.4.0

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,7 +1,9 @@
-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;
     clone(): IMagnitude;
     replace(value: number): this;
     scale(factor: number): this;

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

package/dist/types/figures/{ArcCurve.d.ts → arc-curve/ArcCurve.d.ts}

@@ -1,5 +1,7 @@
-import { IArcCurve, IBoundingBox, ILine, IPoint, TArcValues } from '../types';
-import { Figure } from '../abstracts/Figure';
+import { Figure, IPoint } from '../../abstracts';
+import { CubicBezierCurve } from '../cubic-bezier-curve/CubicBezierCurve';
+import type { IArcCurve, ILine, TArcValues } from '..';
+import { IBoundingBox } from '../../types';
 export declare class ArcCurve extends Figure implements IArcCurve {
     private ellipse;
     private largeArcFlag;
@@ -15,9 +17,12 @@ export declare class ArcCurve extends Figure implements IArcCurve {
     private get P1();
     clone(): ArcCurve;
     reflect(about: IPoint | ILine): this;
+    toCubicBezierCurves(): CubicBezierCurve[];
     private adjustRadii;
+    private computeBezierSegment;
     private computeCenter;
     private computeCenterPrime;
     private computeP0Prime;
+    private computeTangentForTheta;
     private computeThetaRange;
 }

package/dist/types/figures/arc-curve/ArcCurve.types.d.ts

@@ -0,0 +1,11 @@
+import { IAngle, IFigure, IFlag, IMagnitude, IPoint, IVector } from '../../abstracts';
+import type { CubicBezierCurve } from '../cubic-bezier-curve/CubicBezierCurve';
+import { IClonable } from '../../types';
+export type TArcAbsoluteValues = [IPoint, IMagnitude, IMagnitude, IAngle, IFlag, IFlag, IPoint];
+export type TArcRelativeValues = [IPoint, IMagnitude, IMagnitude, IAngle, IFlag, IFlag, IVector];
+export type TArcValues = TArcAbsoluteValues | TArcRelativeValues;
+export interface IArcCurve extends IFigure, IClonable<IArcCurve> {
+    readonly center: IPoint;
+    readonly criticalPoints: IPoint[];
+    toCubicBezierCurves(): CubicBezierCurve[];
+}

package/dist/types/figures/arc-curve/index.d.ts

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

package/dist/types/figures/{Circle.d.ts → circle/Circle.d.ts}

@@ -1,5 +1,6 @@
-import { ICircle, IEllipse, IMagnitude, TCircleValues, TEllipseCriticalPoints, TFigureValues } from '../types';
-import { Ellipse } from './Ellipse';
+import { IMagnitude, TFigureValues } from '../../abstracts';
+import { Ellipse } from '../ellipse/Ellipse';
+import type { ICircle, IEllipse, TCircleValues, TEllipseCriticalPoints } from '..';
 export declare class Circle extends Ellipse implements ICircle {
     private _radius;
     constructor(values: TCircleValues);

package/dist/types/figures/circle/Circle.types.d.ts

@@ -0,0 +1,9 @@
+import { IFigure, IMagnitude, IPoint } from '../../abstracts';
+import { TEllipseCriticalPoints } from '..';
+import { IClonable } from '../../types';
+export type TCircleValues = [IPoint, IMagnitude];
+export interface ICircle extends IFigure, IClonable<ICircle> {
+    readonly center: IPoint;
+    readonly criticalPoints: TEllipseCriticalPoints;
+    readonly radius: IMagnitude;
+}

package/dist/types/figures/circle/index.d.ts

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

package/dist/types/figures/{CubicBezierCurve.d.ts → cubic-bezier-curve/CubicBezierCurve.d.ts}

@@ -1,5 +1,6 @@
-import { IAngle, IBoundingBox, ICubicBezierCurve, ILine, IPoint, IVector, TCubicBezierValues } from '../types';
-import { Figure } from '../abstracts/Figure';
+import { Figure, IAngle, IPoint, IVector } from '../../abstracts';
+import type { ICubicBezierCurve, ILine, TCubicBezierValues } from '..';
+import { IBoundingBox } from '../../types';
 export declare class CubicBezierCurve extends Figure implements ICubicBezierCurve {
     private _criticalPoints;
     constructor(values: TCubicBezierValues);
@@ -14,6 +15,7 @@ export declare class CubicBezierCurve extends Figure implements ICubicBezierCurv
     reflect(about: IPoint | ILine): this;
     rotate(phi: IAngle, about?: IPoint | undefined): this;
     scale(factor: number, about?: IPoint): this;
+    scaleXY(factorX: number, factorY: number, about?: IPoint): this;
     translate(vector: IVector): this;
     private computeCriticalPoints;
     private computeCriticalPointsTValues;

package/dist/types/figures/cubic-bezier-curve/CubicBezierCurve.types.d.ts

@@ -0,0 +1,8 @@
+import { IFigure, IPoint, IVector } from '../../abstracts';
+import { IClonable } from '../../types';
+export type TCubicBezierAbsoluteValues = [IPoint, IPoint, IPoint, IPoint];
+export type TCubicBezierRelativeValues = [IPoint, IVector, IVector, IVector];
+export type TCubicBezierValues = TCubicBezierAbsoluteValues | TCubicBezierRelativeValues;
+export interface ICubicBezierCurve extends IFigure, IClonable<ICubicBezierCurve> {
+    readonly criticalPoints: IPoint[];
+}

package/dist/types/figures/cubic-bezier-curve/index.d.ts

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

package/dist/types/figures/{Ellipse.d.ts → ellipse/Ellipse.d.ts}

@@ -1,5 +1,7 @@
-import { TEllipseValues, IBoundingBox, IPoint, IEllipse, TEllipseCriticalPoints, IMagnitude, IVector, ILine, IAngle } from '../types';
-import { Figure } from '../abstracts/Figure';
+import { Figure, IAngle, IMagnitude, IPoint, IVector } from '../../abstracts';
+import type { IEllipse, ILine, TEllipseCriticalPoints, TEllipseValues } from '..';
+import type { TEllipseCubicBezierCurves } from './Ellipse.types';
+import { IBoundingBox } from '../../types';
 export declare class Ellipse extends Figure implements IEllipse {
     private _center;
     private _criticalPoints;
@@ -20,6 +22,7 @@ export declare class Ellipse extends Figure implements IEllipse {
     reflect(about: IPoint | ILine): this;
     rotate(alpha: IAngle, about?: IPoint | undefined): this;
     scale(factor: number, about?: IPoint): this;
+    toCubicBezierCurves(): TEllipseCubicBezierCurves;
     translate(vector: IVector): this;
     protected computeCriticalPoints(ellipse?: IEllipse): TEllipseCriticalPoints;
     private recompute;

package/dist/types/figures/ellipse/Ellipse.types.d.ts

@@ -0,0 +1,16 @@
+import { IAngle, IFigure, IMagnitude, IPoint } from '../../abstracts';
+import { CubicBezierCurve } from '../cubic-bezier-curve';
+import { IClonable } from '../../types';
+export type TEllipseValues = [IPoint, IMagnitude, IMagnitude, IAngle];
+export type TEllipseCriticalPoints = [IPoint, IPoint, IPoint, IPoint];
+export type TEllipseCubicBezierCurves = [CubicBezierCurve, CubicBezierCurve, CubicBezierCurve, CubicBezierCurve];
+export interface IEllipse extends IFigure, IClonable<IEllipse> {
+    readonly center: IPoint;
+    readonly criticalPoints: TEllipseCriticalPoints;
+    readonly phi: IAngle;
+    readonly rx: IMagnitude;
+    readonly ry: IMagnitude;
+    computePointForTheta(theta: IAngle): IPoint;
+    computeThetaForPoint(point: IPoint): IAngle;
+    toCubicBezierCurves(): TEllipseCubicBezierCurves;
+}

package/dist/types/figures/ellipse/index.d.ts

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

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

@@ -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/types/figures/{Line.d.ts → line/Line.d.ts}

@@ -1,9 +1,10 @@
-import { IAngle, ILine, IPoint, IVector, TLineValues } from '../types';
-import { Figure } from '../abstracts/Figure';
+import { Figure, IAngle, IPoint, IVector } from '../../abstracts';
+import type { ILine, TLineValues } from '..';
 export declare class Line extends Figure implements ILine {
     private _P0;
     private _P1;
     private _V;
+    private _dirty;
     private _reciprocal;
     private _slope;
     private _xIntercept;
@@ -21,7 +22,7 @@ export declare class Line extends Figure implements ILine {
     get slope(): number | undefined;
     get xIntercept(): number | undefined;
     get yIntercept(): number | undefined;
-    angleTo(line: ILine): IAngle;
+    angleTo(reference: ILine | IVector): IAngle;
     clone(): Line;
     getIntersectionPoint(line: ILine): IPoint | undefined;
     getPerpendicularProjection(point: IPoint): IPoint;
@@ -35,10 +36,11 @@ export declare class Line extends Figure implements ILine {
     reflect(about: ILine | IPoint): this;
     rotate(phi: IAngle, about?: IPoint | undefined): this;
     scale(factor: number, about?: IPoint): this;
+    scaleXY(factorX: number, factorY: number, about?: IPoint): this;
     translate(vector: IVector): this;
     private computeReciprocal;
     private computeSlope;
     private computeXIntercept;
     private computeYIntercept;
-    private recompute;
+    private ensureComputed;
 }

package/dist/types/figures/line/Line.types.d.ts

@@ -0,0 +1,30 @@
+import { IAngle, IFigure, IPoint, IVector } from '../../abstracts';
+import { IClonable } from '../../types';
+export type TSegment = [IPoint, IPoint];
+export type TLineRelativeValues = [IPoint, IVector];
+export type TLineAbsoluteValues = [IPoint, IPoint];
+export type TLineValues = TLineAbsoluteValues | TLineRelativeValues;
+export interface ILine extends IFigure, IClonable<ILine> {
+    readonly P0: IPoint;
+    readonly P1: IPoint;
+    readonly V: IVector;
+    readonly a: number;
+    readonly b: number;
+    readonly c: number;
+    readonly isHorizontal: boolean;
+    readonly isVertical: boolean;
+    readonly reciprocal: number | undefined;
+    readonly slope: number | undefined;
+    readonly xIntercept: number | undefined;
+    readonly yIntercept: number | undefined;
+    angleTo(reference: ILine | IVector): IAngle;
+    getIntersectionPoint(line: ILine): IPoint | undefined;
+    getPerpendicularProjection(point: IPoint): IPoint;
+    getPerpendicularThrough(point: IPoint): ILine;
+    getPointAtParameter(t: number): IPoint;
+    getXValueAtY(y: number): number | undefined;
+    getYValueAtX(x: number): number | undefined;
+    hasPoint(point: IPoint): boolean;
+    isParallelTo(line: ILine): boolean;
+    isPerpendicularTo(line: ILine): boolean;
+}

package/dist/types/figures/line/index.d.ts

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

package/dist/types/figures/polygon/Polygon.d.ts

@@ -0,0 +1,17 @@
+import type { IPolygon, TPolygonValues } from '..';
+import { Figure, IAngle, IPoint, IVector } from '../../abstracts';
+import type { ILine } from '../line/Line.types';
+import { Line } from '../line/Line';
+export declare class Polygon extends Figure implements IPolygon {
+    private _lines;
+    constructor(values: TPolygonValues);
+    get lines(): Line[];
+    get sides(): number;
+    clone(): Polygon;
+    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;
+    private computeLines;
+}

package/dist/types/figures/polygon/Polygon.types.d.ts

@@ -0,0 +1,8 @@
+import { IFigure, IPoint } from '../../abstracts';
+import type { ILine } from '../line/Line.types';
+import { IClonable } from '../../types';
+export type TPolygonValues = [IPoint, IPoint, IPoint, ...IPoint[]];
+export interface IPolygon extends IFigure, IClonable<IPolygon> {
+    readonly lines: ILine[];
+    readonly sides: number;
+}

package/dist/types/figures/polygon/index.d.ts

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

package/dist/types/figures/{QuadraticBezierCurve.d.ts → quadratic-bezier-curve/QuadraticBezierCurve.d.ts}

@@ -1,5 +1,6 @@
-import { IAngle, IBoundingBox, ILine, IPoint, IQuadraticBezierCurve, IVector, TQuadraticBezierValues } from '../types';
-import { Figure } from '../abstracts/Figure';
+import { Figure, IAngle, IPoint, IVector } from '../../abstracts';
+import type { ILine, IQuadraticBezierCurve, TQuadraticBezierValues } from '..';
+import { IBoundingBox } from '../../types';
 export declare class QuadraticBezierCurve extends Figure implements IQuadraticBezierCurve {
     private _criticalPoints;
     constructor(values: TQuadraticBezierValues);
@@ -13,6 +14,7 @@ export declare class QuadraticBezierCurve extends Figure implements IQuadraticBe
     reflect(about: IPoint | ILine): this;
     rotate(phi: IAngle, about?: IPoint | undefined): this;
     scale(factor: number, about?: IPoint): this;
+    scaleXY(factorX: number, factorY: number, about?: IPoint): this;
     translate(vector: IVector): this;
     private computeCriticalPoints;
     private getCoordinateAtParameter;

package/dist/types/figures/quadratic-bezier-curve/QuadraticBezierCurve.types.d.ts

@@ -0,0 +1,8 @@
+import { IFigure, IPoint, IVector } from '../../abstracts';
+import { IClonable } from '../../types';
+export type TQuadraticBezierAbsoluteValues = [IPoint, IPoint, IPoint];
+export type TQuadraticBezierRelativeValues = [IPoint, IVector, IVector];
+export type TQuadraticBezierValues = TQuadraticBezierAbsoluteValues | TQuadraticBezierRelativeValues;
+export interface IQuadraticBezierCurve extends IFigure, IClonable<IQuadraticBezierCurve> {
+    readonly criticalPoints: IPoint[];
+}

package/dist/types/figures/quadratic-bezier-curve/index.d.ts

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