@futdevpro/fsm-dynamo 1.16.39 → 1.16.40

package/build/_collections/utils/math/vector2.util.d.ts

@@ -1,446 +1,446 @@
-import { DyFM_Vector2 } from '../../../_models/interfaces/vector2.interface';
-export type DyFM_V2_U = DyFM_Vector2_Util;
-export type DyFM_V2_Util = DyFM_Vector2_Util;
-export type DyFM_Vector2_U = DyFM_Vector2_Util;
-/**
- * The main difference between static class functions and instance functions
- * is that static functions return new Vector2,
- * while instance functions change the current Vector2 and returns itself.
- * (if this is not true, report it as a bug)
- *
- * @example
- * ```ts
- * const vector2 = new DyFM_Vector2_Util(1);
- * const vector2 = new DyFM_Vector2_Util(1, 2);
- * const vector2 = new DyFM_Vector2_Util({ x: 1, y: 2 });
- * ```
- */
-export declare class DyFM_Vector2_Util implements DyFM_Vector2 {
-    readonly isVector2Util: boolean;
-    private _x;
-    /**
-     * if you are setting both x and y,
-     * use newValues() or newXY() to avoid multiple magnitude calculation
-     * */
-    set x(value: number);
-    get x(): number;
-    private _y;
-    /**
-     * if you are setting both x and y,
-     * use newValues() or newXY() to avoid multiple magnitude calculation
-     * */
-    set y(value: number);
-    get y(): number;
-    private _magintude;
-    get magintude(): number;
-    /**
-     * zero vector
-     */
-    static readonly zero: DyFM_Vector2;
-    /**
-     * up vector
-     */
-    static readonly up: DyFM_Vector2;
-    /**
-     * down vector
-     */
-    static readonly down: DyFM_Vector2;
-    /**
-     * right vector
-     */
-    static readonly right: DyFM_Vector2;
-    /**
-     * left vector
-     */
-    static readonly left: DyFM_Vector2;
-    constructor(xOrXyOrVector?: number | DyFM_Vector2, y?: number);
-    /**
-     * returns true if the vector is constructed
-     */
-    constructed?(): boolean;
-    /**
-     * returns the distance between two vectors
-     *
-     * @example
-     * ```ts
-     * const distance = DyFM_Vector2_Util.distance({ x: 1, y: 2 }, { x: 3, y: 4 });
-     * console.log(distance); // 2.8284271247461903
-     * ```
-     */
-    static distance(a: DyFM_Vector2, b: DyFM_Vector2): number;
-    distance(to: DyFM_Vector2): number;
-    /**
-     * returns a new vector with the subtraction of two vectors
-     *
-     * @example
-     * ```ts
-     * const minus = DyFM_Vector2_Util.minus({ x: 1, y: 2 }, { x: 3, y: 4 });
-     * console.log(minus); // { x: -2, y: -2 }
-     * ```
-     */
-    static minus(a: DyFM_Vector2, minusB: DyFM_Vector2): DyFM_Vector2_Util;
-    minus(vector: DyFM_Vector2): this;
-    /**
-     * returns a new vector with the sum of two vectors
-     *
-     * @example
-     * ```ts
-     * const plus = DyFM_Vector2_Util.plus({ x: 1, y: 2 }, { x: 3, y: 4 });
-     * console.log(plus); // { x: 4, y: 6 }
-     * ```
-     */
-    static plus(a: DyFM_Vector2, plusB: DyFM_Vector2): DyFM_Vector2_Util;
-    plus(vector: DyFM_Vector2): this;
-    static readonly add: typeof DyFM_Vector2_Util.plus;
-    readonly add: (vector: DyFM_Vector2) => this;
-    /** returns a new vector with the multiplication of two vectors
-     * @example
-     * ```ts
-     * const multiply = DyFM_Vector2_Util.multiply({ x: 1, y: 2 }, 2);
-     * console.log(multiply); // { x: 2, y: 4 }
-     * ```
-     */
-    static multiply(v: DyFM_Vector2, n: number): DyFM_Vector2_Util;
-    multiply(n: number): this;
-    /** returns a new vector with the division of two vectors
-     * @example
-     * ```ts
-     * const divide = DyFM_Vector2_Util.divide({ x: 1, y: 2 }, 2);
-     * console.log(divide); // { x: 0.5, y: 1 }
-     * ```
-     */
-    static divide(v: DyFM_Vector2, divideBy: number): DyFM_Vector2_Util;
-    divide(n: number): this;
-    /** returns the negative value of the original vector at new vector
-     * @example
-     * ```ts
-     * const negative = DyFM_Vector2_Util.negative({ x: 1, y: 2 });
-     * console.log(negative); // { x: -1, y: -2 }
-     * ```
-     */
-    static negative(v: DyFM_Vector2): DyFM_Vector2_Util;
-    /** this returns a new instance */
-    getNegative(): DyFM_Vector2_Util;
-    negate(): this;
-    /**
-     * returns a new vector with the rebase of the original vector
-     *
-     * @example
-     * ```ts
-     * const rebase = DyFM_Vector2_Util.rebase({ x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 });
-     * console.log(rebase); // { x: 4, y: 6 }
-     * ```
-     */
-    static rebase(v: DyFM_Vector2, baseFrom: DyFM_Vector2, baseTo: DyFM_Vector2): DyFM_Vector2_Util;
-    rebase(baseFrom: DyFM_Vector2, baseTo: DyFM_Vector2): this;
-    /**
-     * returns a new vector with the rotation of the original vector by degrees
-     *
-     * @example
-     * ```ts
-     * const rotate = DyFM_Vector2_Util.rotate({ x: 1, y: 2 }, 30);
-     * console.log(rotate); // { x: 0.8660254037844386, y: 1.5 }
-     * ```
-     */
-    static rotate(vector: DyFM_Vector2, angle: number): DyFM_Vector2_Util;
-    /**
-     * returns a new vector with the rotation of the original vector by radians
-     *
-     * @example
-     * ```ts
-     * const rotateRad = DyFM_Vector2_Util.rotateRad({ x: 1, y: 2 }, 3.141592653589793);
-     * console.log(rotateRad); // { x: -1, y: 2 }
-     * ```
-     */
-    static rotateRad(vector: DyFM_Vector2, rad: number): DyFM_Vector2_Util;
-    /**
-     * returns a new vector with the rotation of the original vector by degrees
-     *
-     * @example
-     * ```ts
-     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
-     * vector.rotate(30);
-     * ```
-     */
-    rotate(angle: number): this;
-    /**
-     * returns a new vector with the rotation of the original vector by radians
-     *
-     * @example
-     * ```ts
-     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
-     * vector.rotateRad(3.141592653589793);
-     * ```
-     */
-    rotateRad(rad: number): this;
-    /**
-     * returns a new DyFM_Vector2_Util with the new values
-     *
-     * @example
-     * ```ts
-     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
-     * vector.newValues({ x: 3, y: 4 });
-     * ```
-     */
-    newValues(newV: DyFM_Vector2): this;
-    /**
-     * returns a new vector with the sum of a vector and the difference of two vectors
-     *
-     * @example
-     * ```ts
-     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
-     * vector.newXY(3, 4);
-     * ```
-     */
-    newXY(newX: number, newY: number): this;
-    /**
-     * returns a new DyFM_Vector2_Util with the new values
-     *
-     * @example
-     * ```ts
-     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
-     * DyFM_Vector2_Util.newValues(vector, { x: 3, y: 4 });
-     * ```
-     */
-    static newValues(to: DyFM_Vector2, newV: DyFM_Vector2): DyFM_Vector2;
-    static readonly newXY: typeof DyFM_Vector2_Util.newValues;
-    /**
-     * returns the angle between two vectors
-     *
-     * @example
-     * ```ts
-     * const angle = DyFM_Vector2_Util.angle({ x: 1, y: 2 }, { x: 3, y: 4 });
-     * console.log(angle); // 45
-     * ```
-     */
-    static angle(from: DyFM_Vector2, to: DyFM_Vector2): number;
-    /**
-     * returns the angle between two vectors in radians
-     *
-     * @example
-     * ```ts
-     * const angleRad = DyFM_Vector2_Util.angleRad({ x: 1, y: 2 }, { x: 3, y: 4 });
-     * console.log(angleRad); // 0.7853981633974483
-     * ```
-     */
-    static angleRad(from: DyFM_Vector2, to: DyFM_Vector2): number;
-    /**
-     * returns the angle between two vectors
-     *
-     * @example
-     * ```ts
-     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
-     * const angle = vector.angle({ x: 3, y: 4 });
-     * console.log(angle); // 45
-     * ```
-     */
-    angle(from: DyFM_Vector2, to: DyFM_Vector2): number;
-    /**
-     * returns the angle between two vectors in degrees
-     *
-     * @example
-     * ```ts
-     * const angle = DyFM_Vector2_Util.deg({ x: 1, y: 2 });
-     * console.log(angle); // 45
-     */
-    static deg(vector: DyFM_Vector2): number;
-    /**
-     * returns the angle between two vectors in radians
-     *
-     * @example
-     * ```ts
-     * const angleRad = DyFM_Vector2_Util.rad({ x: 1, y: 2 });
-     * console.log(angleRad); // 0.7853981633974483
-     * ```
-     */
-    static rad(vector: DyFM_Vector2): number;
-    /**
-     * returns the vector angle in degrees
-     *
-     * @example
-     * ```ts
-     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
-     * const deg = vector.deg();
-     * console.log(deg); // 45
-     * ```
-     */
-    deg(): number;
-    /**
-     * returns math floor of the vector
-     *
-     * @example
-     * ```ts
-     * const vector = DyFM_Vector2_Util.floor({ x: 1.5, y: 2.5 });
-     * console.log(vector); // { x: 1, y: 2 }
-     * ```
-     */
-    static floor(v: DyFM_Vector2): DyFM_Vector2_Util;
-    /**
-     * returns math floor of the vector
-     *
-     * @example
-     * ```ts
-     * const vector = new DyFM_Vector2_Util({ x: 1.5, y: 2.5 });
-     * const floor = vector.floor();
-     * console.log(floor); // { x: 1, y: 2 }
-     * ```
-     */
-    floor(): DyFM_Vector2_Util;
-    /**
-     * returns the direction vector from one point to another
-     *
-     * @example
-     * ```ts
-     * const direction = DyFM_Vector2_Util.direction({ x: 1, y: 2 }, { x: 3, y: 4 });
-     * console.log(direction); // { x: 2, y: 2 }
-     * ```
-     */
-    static direction(from: DyFM_Vector2, to: DyFM_Vector2): DyFM_Vector2_Util;
-    /**
-     * returns the direction vector from one point to another
-     *
-     * @example
-     * ```ts
-     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
-     * const direction = vector.direction({ x: 3, y: 4 });
-     * console.log(direction); // { x: 2, y: 2 }
-     * ```
-     */
-    direction(to: DyFM_Vector2): DyFM_Vector2_Util;
-    /**
-     * returns a normalized vector
-     *
-     * @example
-     * ```ts
-     * const vector = DyFM_Vector2_Util.normalize({ x: 1, y: 2 });
-     * console.log(vector); // { x: 0.4472135954999579, y: 0.8944271909999159 }
-     * ```
-     */
-    static normalize(v: DyFM_Vector2): DyFM_Vector2_Util;
-    /**
-     * returns a normalized vector
-     *
-     * @example
-     * ```ts
-     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
-     * vector.normalize();
-     * console.log(vector); // { x: 0.4472135954999579, y: 0.8944271909999159 }
-     * ```
-     */
-    normalize(): void;
-    /**
-     * this will return a new instance,
-     * if you want to change the current instance, use normalize()
-     *
-     * @example
-     * ```ts
-     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
-     * const normalized = vector.normalized();
-     * console.log(normalized); // { x: 0.4472135954999579, y: 0.8944271909999159 }
-     * ```
-     */
-    normalized(): DyFM_Vector2_Util;
-    /**
-     * returns the magnitude of the vector
-     *
-     * @example
-     * ```ts
-     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
-     * const magnitude = vector.magnitude();
-     * console.log(magnitude); // 2.23606797749979
-     * ```
-     */
-    private calcMagnitude;
-    /**
-     * returns a new vector with the same values
-     *
-     * @example
-     * ```ts
-     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
-     * const clone = vector.clone();
-     * console.log(clone); // { x: 1, y: 2 }
-     * ```
-     */
-    clone(): DyFM_Vector2_Util;
-    /**
-     * returns true if the vector has changed
-     *
-     * @example
-     * ```ts
-     * const vector1 = new DyFM_Vector2_Util({ x: 1, y: 2 });
-     * const vector2 = new DyFM_Vector2_Util({ x: 3, y: 4 });
-     * const isChanged = DyFM_Vector2_Util.isChanged(vector1, vector2);
-     * console.log(isChanged); // true
-     * ```
-     */
-    static isChanged(a: DyFM_Vector2_Util, b: DyFM_Vector2_Util): boolean;
-    /**
-     * returns true if the vectors are equal
-     *
-     * @example
-     * ```ts
-     * const vector1 = new DyFM_Vector2_Util({ x: 1, y: 2 });
-     * const vector2 = new DyFM_Vector2_Util({ x: 1, y: 2 });
-     * const isEqual = DyFM_Vector2_Util.isEqual(vector1, vector2);
-     * console.log(isEqual); // true
-     * ```
-     */
-    static isEqual(a: DyFM_Vector2, b: DyFM_Vector2): boolean;
-    /**
-     * returns true if the vectors have changed
-     *
-     * @example
-     * ```ts
-     * const vector1 = new DyFM_Vector2_Util({ x: 1, y: 2 });
-     * const vector2 = new DyFM_Vector2_Util({ x: 1, y: 2 });
-     * const isVectorChanged = DyFM_Vector2_Util.vectorChanged(vector1, vector2);
-     * console.log(isVectorChanged); // false
-     * ```
-     */
-    static vectorChanged(a: DyFM_Vector2, b: DyFM_Vector2): boolean;
-    /**
-     * returns a new vector with the absolute values of the original vector
-     *
-     * @example
-     * ```ts
-     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
-     * const vector = DyFM_Vector2_Util.abs(vector);
-     * console.log(vector);
-     * ```
-     */
-    static abs(v: DyFM_Vector2): DyFM_Vector2_Util;
-    abs(): this;
-    /**
-     * returns a new vector with the rounded values of the original vector
-     *
-     * @example
-     * ```ts
-     * const vector = new DyFM_Vector2_Util({ x: 1.5, y: 2.5 });
-     * const rounded = DyFM_Vector2_Util.round(vector);
-     * const rounded2 = DyFM_Vector2_Util.round(vector,3);
-     * ```
-     */
-    static round(v: DyFM_Vector2, decimals?: number): DyFM_Vector2_Util;
-    /**
-     * returns a instance of DyFM_Vector2 from a DyFM_Vector2_Util
-     *
-     * @example
-     * ```ts
-     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
-     * const vector2 = DyFM_Vector2_Util.toVector2(vector);
-     * console.log(vector2);
-     * ```
-     */
-    static toVector2(v: DyFM_Vector2_Util): DyFM_Vector2;
-    /**
-     * returns a instance of DyFM_Vector2 from a DyFM_Vector2_Util
-     */
-    get(): DyFM_Vector2;
-    getVector2: () => DyFM_Vector2;
-    toVector2: () => DyFM_Vector2;
-    /**
-     * returns a new vector with the same values
-     */
-    static clone(v: DyFM_Vector2): DyFM_Vector2;
-}
+import { DyFM_Vector2 } from '../../../_models/interfaces/vector2.interface';
+export type DyFM_V2_U = DyFM_Vector2_Util;
+export type DyFM_V2_Util = DyFM_Vector2_Util;
+export type DyFM_Vector2_U = DyFM_Vector2_Util;
+/**
+ * The main difference between static class functions and instance functions
+ * is that static functions return new Vector2,
+ * while instance functions change the current Vector2 and returns itself.
+ * (if this is not true, report it as a bug)
+ *
+ * @example
+ * ```ts
+ * const vector2 = new DyFM_Vector2_Util(1);
+ * const vector2 = new DyFM_Vector2_Util(1, 2);
+ * const vector2 = new DyFM_Vector2_Util({ x: 1, y: 2 });
+ * ```
+ */
+export declare class DyFM_Vector2_Util implements DyFM_Vector2 {
+    readonly isVector2Util: boolean;
+    private _x;
+    /**
+     * if you are setting both x and y,
+     * use newValues() or newXY() to avoid multiple magnitude calculation
+     * */
+    set x(value: number);
+    get x(): number;
+    private _y;
+    /**
+     * if you are setting both x and y,
+     * use newValues() or newXY() to avoid multiple magnitude calculation
+     * */
+    set y(value: number);
+    get y(): number;
+    private _magintude;
+    get magintude(): number;
+    /**
+     * zero vector
+     */
+    static readonly zero: DyFM_Vector2;
+    /**
+     * up vector
+     */
+    static readonly up: DyFM_Vector2;
+    /**
+     * down vector
+     */
+    static readonly down: DyFM_Vector2;
+    /**
+     * right vector
+     */
+    static readonly right: DyFM_Vector2;
+    /**
+     * left vector
+     */
+    static readonly left: DyFM_Vector2;
+    constructor(xOrXyOrVector?: number | DyFM_Vector2, y?: number);
+    /**
+     * returns true if the vector is constructed
+     */
+    constructed?(): boolean;
+    /**
+     * returns the distance between two vectors
+     *
+     * @example
+     * ```ts
+     * const distance = DyFM_Vector2_Util.distance({ x: 1, y: 2 }, { x: 3, y: 4 });
+     * console.log(distance); // 2.8284271247461903
+     * ```
+     */
+    static distance(a: DyFM_Vector2, b: DyFM_Vector2): number;
+    distance(to: DyFM_Vector2): number;
+    /**
+     * returns a new vector with the subtraction of two vectors
+     *
+     * @example
+     * ```ts
+     * const minus = DyFM_Vector2_Util.minus({ x: 1, y: 2 }, { x: 3, y: 4 });
+     * console.log(minus); // { x: -2, y: -2 }
+     * ```
+     */
+    static minus(a: DyFM_Vector2, minusB: DyFM_Vector2): DyFM_Vector2_Util;
+    minus(vector: DyFM_Vector2): this;
+    /**
+     * returns a new vector with the sum of two vectors
+     *
+     * @example
+     * ```ts
+     * const plus = DyFM_Vector2_Util.plus({ x: 1, y: 2 }, { x: 3, y: 4 });
+     * console.log(plus); // { x: 4, y: 6 }
+     * ```
+     */
+    static plus(a: DyFM_Vector2, plusB: DyFM_Vector2): DyFM_Vector2_Util;
+    plus(vector: DyFM_Vector2): this;
+    static readonly add: typeof DyFM_Vector2_Util.plus;
+    readonly add: (vector: DyFM_Vector2) => this;
+    /** returns a new vector with the multiplication of two vectors
+     * @example
+     * ```ts
+     * const multiply = DyFM_Vector2_Util.multiply({ x: 1, y: 2 }, 2);
+     * console.log(multiply); // { x: 2, y: 4 }
+     * ```
+     */
+    static multiply(v: DyFM_Vector2, n: number): DyFM_Vector2_Util;
+    multiply(n: number): this;
+    /** returns a new vector with the division of two vectors
+     * @example
+     * ```ts
+     * const divide = DyFM_Vector2_Util.divide({ x: 1, y: 2 }, 2);
+     * console.log(divide); // { x: 0.5, y: 1 }
+     * ```
+     */
+    static divide(v: DyFM_Vector2, divideBy: number): DyFM_Vector2_Util;
+    divide(n: number): this;
+    /** returns the negative value of the original vector at new vector
+     * @example
+     * ```ts
+     * const negative = DyFM_Vector2_Util.negative({ x: 1, y: 2 });
+     * console.log(negative); // { x: -1, y: -2 }
+     * ```
+     */
+    static negative(v: DyFM_Vector2): DyFM_Vector2_Util;
+    /** this returns a new instance */
+    getNegative(): DyFM_Vector2_Util;
+    negate(): this;
+    /**
+     * returns a new vector with the rebase of the original vector
+     *
+     * @example
+     * ```ts
+     * const rebase = DyFM_Vector2_Util.rebase({ x: 1, y: 2 }, { x: 3, y: 4 }, { x: 5, y: 6 });
+     * console.log(rebase); // { x: 4, y: 6 }
+     * ```
+     */
+    static rebase(v: DyFM_Vector2, baseFrom: DyFM_Vector2, baseTo: DyFM_Vector2): DyFM_Vector2_Util;
+    rebase(baseFrom: DyFM_Vector2, baseTo: DyFM_Vector2): this;
+    /**
+     * returns a new vector with the rotation of the original vector by degrees
+     *
+     * @example
+     * ```ts
+     * const rotate = DyFM_Vector2_Util.rotate({ x: 1, y: 2 }, 30);
+     * console.log(rotate); // { x: 0.8660254037844386, y: 1.5 }
+     * ```
+     */
+    static rotate(vector: DyFM_Vector2, angle: number): DyFM_Vector2_Util;
+    /**
+     * returns a new vector with the rotation of the original vector by radians
+     *
+     * @example
+     * ```ts
+     * const rotateRad = DyFM_Vector2_Util.rotateRad({ x: 1, y: 2 }, 3.141592653589793);
+     * console.log(rotateRad); // { x: -1, y: 2 }
+     * ```
+     */
+    static rotateRad(vector: DyFM_Vector2, rad: number): DyFM_Vector2_Util;
+    /**
+     * returns a new vector with the rotation of the original vector by degrees
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * vector.rotate(30);
+     * ```
+     */
+    rotate(angle: number): this;
+    /**
+     * returns a new vector with the rotation of the original vector by radians
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * vector.rotateRad(3.141592653589793);
+     * ```
+     */
+    rotateRad(rad: number): this;
+    /**
+     * returns a new DyFM_Vector2_Util with the new values
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * vector.newValues({ x: 3, y: 4 });
+     * ```
+     */
+    newValues(newV: DyFM_Vector2): this;
+    /**
+     * returns a new vector with the sum of a vector and the difference of two vectors
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * vector.newXY(3, 4);
+     * ```
+     */
+    newXY(newX: number, newY: number): this;
+    /**
+     * returns a new DyFM_Vector2_Util with the new values
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * DyFM_Vector2_Util.newValues(vector, { x: 3, y: 4 });
+     * ```
+     */
+    static newValues(to: DyFM_Vector2, newV: DyFM_Vector2): DyFM_Vector2;
+    static readonly newXY: typeof DyFM_Vector2_Util.newValues;
+    /**
+     * returns the angle between two vectors
+     *
+     * @example
+     * ```ts
+     * const angle = DyFM_Vector2_Util.angle({ x: 1, y: 2 }, { x: 3, y: 4 });
+     * console.log(angle); // 45
+     * ```
+     */
+    static angle(from: DyFM_Vector2, to: DyFM_Vector2): number;
+    /**
+     * returns the angle between two vectors in radians
+     *
+     * @example
+     * ```ts
+     * const angleRad = DyFM_Vector2_Util.angleRad({ x: 1, y: 2 }, { x: 3, y: 4 });
+     * console.log(angleRad); // 0.7853981633974483
+     * ```
+     */
+    static angleRad(from: DyFM_Vector2, to: DyFM_Vector2): number;
+    /**
+     * returns the angle between two vectors
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const angle = vector.angle({ x: 3, y: 4 });
+     * console.log(angle); // 45
+     * ```
+     */
+    angle(from: DyFM_Vector2, to: DyFM_Vector2): number;
+    /**
+     * returns the angle between two vectors in degrees
+     *
+     * @example
+     * ```ts
+     * const angle = DyFM_Vector2_Util.deg({ x: 1, y: 2 });
+     * console.log(angle); // 45
+     */
+    static deg(vector: DyFM_Vector2): number;
+    /**
+     * returns the angle between two vectors in radians
+     *
+     * @example
+     * ```ts
+     * const angleRad = DyFM_Vector2_Util.rad({ x: 1, y: 2 });
+     * console.log(angleRad); // 0.7853981633974483
+     * ```
+     */
+    static rad(vector: DyFM_Vector2): number;
+    /**
+     * returns the vector angle in degrees
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const deg = vector.deg();
+     * console.log(deg); // 45
+     * ```
+     */
+    deg(): number;
+    /**
+     * returns math floor of the vector
+     *
+     * @example
+     * ```ts
+     * const vector = DyFM_Vector2_Util.floor({ x: 1.5, y: 2.5 });
+     * console.log(vector); // { x: 1, y: 2 }
+     * ```
+     */
+    static floor(v: DyFM_Vector2): DyFM_Vector2_Util;
+    /**
+     * returns math floor of the vector
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1.5, y: 2.5 });
+     * const floor = vector.floor();
+     * console.log(floor); // { x: 1, y: 2 }
+     * ```
+     */
+    floor(): DyFM_Vector2_Util;
+    /**
+     * returns the direction vector from one point to another
+     *
+     * @example
+     * ```ts
+     * const direction = DyFM_Vector2_Util.direction({ x: 1, y: 2 }, { x: 3, y: 4 });
+     * console.log(direction); // { x: 2, y: 2 }
+     * ```
+     */
+    static direction(from: DyFM_Vector2, to: DyFM_Vector2): DyFM_Vector2_Util;
+    /**
+     * returns the direction vector from one point to another
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const direction = vector.direction({ x: 3, y: 4 });
+     * console.log(direction); // { x: 2, y: 2 }
+     * ```
+     */
+    direction(to: DyFM_Vector2): DyFM_Vector2_Util;
+    /**
+     * returns a normalized vector
+     *
+     * @example
+     * ```ts
+     * const vector = DyFM_Vector2_Util.normalize({ x: 1, y: 2 });
+     * console.log(vector); // { x: 0.4472135954999579, y: 0.8944271909999159 }
+     * ```
+     */
+    static normalize(v: DyFM_Vector2): DyFM_Vector2_Util;
+    /**
+     * returns a normalized vector
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * vector.normalize();
+     * console.log(vector); // { x: 0.4472135954999579, y: 0.8944271909999159 }
+     * ```
+     */
+    normalize(): void;
+    /**
+     * this will return a new instance,
+     * if you want to change the current instance, use normalize()
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const normalized = vector.normalized();
+     * console.log(normalized); // { x: 0.4472135954999579, y: 0.8944271909999159 }
+     * ```
+     */
+    normalized(): DyFM_Vector2_Util;
+    /**
+     * returns the magnitude of the vector
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const magnitude = vector.magnitude();
+     * console.log(magnitude); // 2.23606797749979
+     * ```
+     */
+    private calcMagnitude;
+    /**
+     * returns a new vector with the same values
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const clone = vector.clone();
+     * console.log(clone); // { x: 1, y: 2 }
+     * ```
+     */
+    clone(): DyFM_Vector2_Util;
+    /**
+     * returns true if the vector has changed
+     *
+     * @example
+     * ```ts
+     * const vector1 = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const vector2 = new DyFM_Vector2_Util({ x: 3, y: 4 });
+     * const isChanged = DyFM_Vector2_Util.isChanged(vector1, vector2);
+     * console.log(isChanged); // true
+     * ```
+     */
+    static isChanged(a: DyFM_Vector2_Util, b: DyFM_Vector2_Util): boolean;
+    /**
+     * returns true if the vectors are equal
+     *
+     * @example
+     * ```ts
+     * const vector1 = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const vector2 = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const isEqual = DyFM_Vector2_Util.isEqual(vector1, vector2);
+     * console.log(isEqual); // true
+     * ```
+     */
+    static isEqual(a: DyFM_Vector2, b: DyFM_Vector2): boolean;
+    /**
+     * returns true if the vectors have changed
+     *
+     * @example
+     * ```ts
+     * const vector1 = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const vector2 = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const isVectorChanged = DyFM_Vector2_Util.vectorChanged(vector1, vector2);
+     * console.log(isVectorChanged); // false
+     * ```
+     */
+    static vectorChanged(a: DyFM_Vector2, b: DyFM_Vector2): boolean;
+    /**
+     * returns a new vector with the absolute values of the original vector
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const vector = DyFM_Vector2_Util.abs(vector);
+     * console.log(vector);
+     * ```
+     */
+    static abs(v: DyFM_Vector2): DyFM_Vector2_Util;
+    abs(): this;
+    /**
+     * returns a new vector with the rounded values of the original vector
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1.5, y: 2.5 });
+     * const rounded = DyFM_Vector2_Util.round(vector);
+     * const rounded2 = DyFM_Vector2_Util.round(vector,3);
+     * ```
+     */
+    static round(v: DyFM_Vector2, decimals?: number): DyFM_Vector2_Util;
+    /**
+     * returns a instance of DyFM_Vector2 from a DyFM_Vector2_Util
+     *
+     * @example
+     * ```ts
+     * const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+     * const vector2 = DyFM_Vector2_Util.toVector2(vector);
+     * console.log(vector2);
+     * ```
+     */
+    static toVector2(v: DyFM_Vector2_Util): DyFM_Vector2;
+    /**
+     * returns a instance of DyFM_Vector2 from a DyFM_Vector2_Util
+     */
+    get(): DyFM_Vector2;
+    getVector2: () => DyFM_Vector2;
+    toVector2: () => DyFM_Vector2;
+    /**
+     * returns a new vector with the same values
+     */
+    static clone(v: DyFM_Vector2): DyFM_Vector2;
+}
 //# sourceMappingURL=vector2.util.d.ts.map