@futdevpro/fsm-dynamo 1.16.39 → 1.20.2

package/build/_collections/utils/math/vector2.util.js

@@ -1,592 +1,592 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyFM_Vector2_Util = void 0;
-const math_util_1 = require("./math.util");
-const trigonometry_util_1 = require("./trigonometry.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 });
- * ```
- */
-class DyFM_Vector2_Util {
-    isVector2Util = true;
-    _x = 0;
-    /**
-     * if you are setting both x and y,
-     * use newValues() or newXY() to avoid multiple magnitude calculation
-     * */
-    set x(value) {
-        this._x = value;
-        this.calcMagnitude();
-    }
-    get x() {
-        return this._x;
-    }
-    _y = 0;
-    /**
-     * if you are setting both x and y,
-     * use newValues() or newXY() to avoid multiple magnitude calculation
-     * */
-    set y(value) {
-        this._y = value;
-        this.calcMagnitude();
-    }
-    get y() {
-        return this._y;
-    }
-    _magintude = 0;
-    get magintude() {
-        return this._magintude;
-    }
-    // these are created as soft objects to avoid changing instances with DyFM_Vector2 instance functions
-    /**
-     * zero vector
-     */
-    static zero = { x: 0, y: 0 };
-    /**
-     * up vector
-     */
-    static up = { x: 0, y: 1 };
-    /**
-     * down vector
-     */
-    static down = { x: 0, y: -1 };
-    /**
-     * right vector
-     */
-    static right = { x: 1, y: 0 };
-    /**
-     * left vector
-     */
-    static left = { x: -1, y: 0 };
-    constructor(xOrXyOrVector = 0, y) {
-        if (typeof xOrXyOrVector === 'object' &&
-            xOrXyOrVector.x !== undefined &&
-            xOrXyOrVector.y !== undefined) {
-            this._x = xOrXyOrVector.x;
-            this._y = xOrXyOrVector.y;
-        }
-        else if (y === undefined) {
-            this._x = xOrXyOrVector;
-            this._y = xOrXyOrVector;
-        }
-        else {
-            this._x = xOrXyOrVector;
-            this._y = y;
-        }
-        this.calcMagnitude();
-    }
-    /**
-     * returns true if the vector is constructed
-     */
-    constructed() {
-        return true;
-    }
-    /**
-     * 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, b) {
-        return this.minus(a, b).magintude;
-    }
-    distance(to) {
-        return DyFM_Vector2_Util.distance(this, to);
-    }
-    /**
-     * 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, minusB) {
-        return this.plus(a, this.negative(minusB));
-    }
-    minus(vector) {
-        this.plus(DyFM_Vector2_Util.negative(vector));
-        return 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, plusB) {
-        return new DyFM_Vector2_Util(a.x + plusB.x, a.y + plusB.y);
-    }
-    plus(vector) {
-        this.newValues(DyFM_Vector2_Util.plus(this, vector));
-        return this;
-    }
-    static add = this.plus;
-    add = this.plus;
-    /** 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, n) {
-        return new DyFM_Vector2_Util(v.x * n, v.y * n);
-    }
-    multiply(n) {
-        return this.newValues(DyFM_Vector2_Util.multiply(this, n));
-    }
-    /** 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, divideBy) {
-        return new DyFM_Vector2_Util(v.x / divideBy, v.y / divideBy);
-    }
-    divide(n) {
-        this.newValues(DyFM_Vector2_Util.divide(this, n));
-        return 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) {
-        return new DyFM_Vector2_Util(-v.x, -v.y);
-    }
-    /** this returns a new instance */
-    getNegative() {
-        return DyFM_Vector2_Util.negative(this);
-    }
-    negate() {
-        this.newValues(DyFM_Vector2_Util.negative(this));
-        return 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, baseFrom, baseTo) {
-        return this.plus(v, this.minus(baseTo, baseFrom));
-    }
-    rebase(baseFrom, baseTo) {
-        this.newValues(DyFM_Vector2_Util.rebase(this, baseFrom, baseTo));
-        return 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, angle) {
-        const rad = trigonometry_util_1.DyFM_Trigonometry.angleToRadians(angle);
-        return this.rotateRad(vector, rad);
-    }
-    /**
-     * 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, rad) {
-        const cos = Math.cos(rad);
-        const sin = Math.sin(rad);
-        const newX = (vector.x * cos) - (vector.y * sin);
-        const newY = (vector.x * sin) + (vector.y * cos);
-        return new DyFM_Vector2_Util(newX, newY);
-    }
-    /**
-     * 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) {
-        this.newValues(DyFM_Vector2_Util.rotate(this, angle));
-        return 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) {
-        this.newValues(DyFM_Vector2_Util.rotateRad(this, rad));
-        return 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) {
-        this.newXY(newV.x, newV.y);
-        return 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, newY) {
-        this._x = newX;
-        this._y = newY;
-        this.calcMagnitude();
-        return 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, newV) {
-        to.x = newV.x;
-        to.y = newV.y;
-        return to;
-    }
-    static newXY = this.newValues;
-    //// AI-ed UNCHECKED
-    /**
-     * 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, to) {
-        return trigonometry_util_1.DyFM_Trigonometry.radiansToAngle(DyFM_Vector2_Util.angleRad(from, to));
-    }
-    /**
-     * 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, to) {
-        return Math.atan2(to.y - from.y, to.x - from.x);
-    }
-    /**
-     * 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, to) {
-        return DyFM_Vector2_Util.angle(from, to);
-    }
-    /**
-     * 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) {
-        return trigonometry_util_1.DyFM_Trigonometry.radiansToAngle(DyFM_Vector2_Util.rad(vector));
-    }
-    /**
-     * 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) {
-        return Math.atan2(vector.y, vector.x);
-    }
-    /**
-     * 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() {
-        return DyFM_Vector2_Util.deg(this);
-    }
-    /**
-     * 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) {
-        return new DyFM_Vector2_Util(Math.floor(v.x), Math.floor(v.y));
-    }
-    /**
-     * 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() {
-        return DyFM_Vector2_Util.floor(this);
-    }
-    /////
-    /**
-     * 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, to) {
-        return DyFM_Vector2_Util.minus(to, from);
-    }
-    /**
-     * 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) {
-        return DyFM_Vector2_Util.direction(this, to);
-    }
-    /**
-     * 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) {
-        const v_U = new DyFM_Vector2_Util(v);
-        return v_U.multiply(1 / v_U.magintude);
-    }
-    /**
-     * 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() {
-        this.newValues(DyFM_Vector2_Util.normalize(this));
-    }
-    /**
-     * 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() {
-        return DyFM_Vector2_Util.normalize(this);
-    }
-    /**
-     * 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
-     * ```
-     */
-    calcMagnitude() {
-        this._magintude = trigonometry_util_1.DyFM_Trigonometry.getHypotenuse(this._x, this._y);
-    }
-    /**
-     * 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() {
-        return new DyFM_Vector2_Util(this._x, this._y);
-    }
-    /**
-     * 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, b) {
-        return a.x !== b.x || a.y !== b.y;
-    }
-    /**
-     * 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, b) {
-        return a.x === b.x && a.y === b.y;
-    }
-    /**
-     * 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, b) {
-        return a.x !== b.x || a.y !== b.y;
-    }
-    /**
-     * 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) {
-        return new DyFM_Vector2_Util(Math.abs(v.x), Math.abs(v.y));
-    }
-    abs() {
-        return this.newXY(Math.abs(this.x), Math.abs(this.y));
-    }
-    /**
-     * 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, decimals = 0) {
-        return new DyFM_Vector2_Util(math_util_1.DyFM_Math.round(v.x, decimals), math_util_1.DyFM_Math.round(v.y, decimals));
-    }
-    /**
-     * 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) {
-        return (new DyFM_Vector2_Util(v)).get();
-    }
-    /**
-     * returns a instance of DyFM_Vector2 from a DyFM_Vector2_Util
-     */
-    get() {
-        return { x: this.x, y: this.y };
-    }
-    getVector2 = this.get;
-    toVector2 = this.get;
-    /**
-     * returns a new vector with the same values
-     */
-    static clone(v) {
-        return { x: v.x, y: v.y };
-    }
-}
-exports.DyFM_Vector2_Util = DyFM_Vector2_Util;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyFM_Vector2_Util = void 0;
+const math_util_1 = require("./math.util");
+const trigonometry_util_1 = require("./trigonometry.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 });
+ * ```
+ */
+class DyFM_Vector2_Util {
+    isVector2Util = true;
+    _x = 0;
+    /**
+     * if you are setting both x and y,
+     * use newValues() or newXY() to avoid multiple magnitude calculation
+     * */
+    set x(value) {
+        this._x = value;
+        this.calcMagnitude();
+    }
+    get x() {
+        return this._x;
+    }
+    _y = 0;
+    /**
+     * if you are setting both x and y,
+     * use newValues() or newXY() to avoid multiple magnitude calculation
+     * */
+    set y(value) {
+        this._y = value;
+        this.calcMagnitude();
+    }
+    get y() {
+        return this._y;
+    }
+    _magintude = 0;
+    get magintude() {
+        return this._magintude;
+    }
+    // these are created as soft objects to avoid changing instances with DyFM_Vector2 instance functions
+    /**
+     * zero vector
+     */
+    static zero = { x: 0, y: 0 };
+    /**
+     * up vector
+     */
+    static up = { x: 0, y: 1 };
+    /**
+     * down vector
+     */
+    static down = { x: 0, y: -1 };
+    /**
+     * right vector
+     */
+    static right = { x: 1, y: 0 };
+    /**
+     * left vector
+     */
+    static left = { x: -1, y: 0 };
+    constructor(xOrXyOrVector = 0, y) {
+        if (typeof xOrXyOrVector === 'object' &&
+            xOrXyOrVector.x !== undefined &&
+            xOrXyOrVector.y !== undefined) {
+            this._x = xOrXyOrVector.x;
+            this._y = xOrXyOrVector.y;
+        }
+        else if (y === undefined) {
+            this._x = xOrXyOrVector;
+            this._y = xOrXyOrVector;
+        }
+        else {
+            this._x = xOrXyOrVector;
+            this._y = y;
+        }
+        this.calcMagnitude();
+    }
+    /**
+     * returns true if the vector is constructed
+     */
+    constructed() {
+        return true;
+    }
+    /**
+     * 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, b) {
+        return this.minus(a, b).magintude;
+    }
+    distance(to) {
+        return DyFM_Vector2_Util.distance(this, to);
+    }
+    /**
+     * 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, minusB) {
+        return this.plus(a, this.negative(minusB));
+    }
+    minus(vector) {
+        this.plus(DyFM_Vector2_Util.negative(vector));
+        return 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, plusB) {
+        return new DyFM_Vector2_Util(a.x + plusB.x, a.y + plusB.y);
+    }
+    plus(vector) {
+        this.newValues(DyFM_Vector2_Util.plus(this, vector));
+        return this;
+    }
+    static add = this.plus;
+    add = this.plus;
+    /** 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, n) {
+        return new DyFM_Vector2_Util(v.x * n, v.y * n);
+    }
+    multiply(n) {
+        return this.newValues(DyFM_Vector2_Util.multiply(this, n));
+    }
+    /** 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, divideBy) {
+        return new DyFM_Vector2_Util(v.x / divideBy, v.y / divideBy);
+    }
+    divide(n) {
+        this.newValues(DyFM_Vector2_Util.divide(this, n));
+        return 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) {
+        return new DyFM_Vector2_Util(-v.x, -v.y);
+    }
+    /** this returns a new instance */
+    getNegative() {
+        return DyFM_Vector2_Util.negative(this);
+    }
+    negate() {
+        this.newValues(DyFM_Vector2_Util.negative(this));
+        return 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, baseFrom, baseTo) {
+        return this.plus(v, this.minus(baseTo, baseFrom));
+    }
+    rebase(baseFrom, baseTo) {
+        this.newValues(DyFM_Vector2_Util.rebase(this, baseFrom, baseTo));
+        return 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, angle) {
+        const rad = trigonometry_util_1.DyFM_Trigonometry.angleToRadians(angle);
+        return this.rotateRad(vector, rad);
+    }
+    /**
+     * 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, rad) {
+        const cos = Math.cos(rad);
+        const sin = Math.sin(rad);
+        const newX = (vector.x * cos) - (vector.y * sin);
+        const newY = (vector.x * sin) + (vector.y * cos);
+        return new DyFM_Vector2_Util(newX, newY);
+    }
+    /**
+     * 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) {
+        this.newValues(DyFM_Vector2_Util.rotate(this, angle));
+        return 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) {
+        this.newValues(DyFM_Vector2_Util.rotateRad(this, rad));
+        return 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) {
+        this.newXY(newV.x, newV.y);
+        return 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, newY) {
+        this._x = newX;
+        this._y = newY;
+        this.calcMagnitude();
+        return 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, newV) {
+        to.x = newV.x;
+        to.y = newV.y;
+        return to;
+    }
+    static newXY = this.newValues;
+    //// AI-ed UNCHECKED
+    /**
+     * 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, to) {
+        return trigonometry_util_1.DyFM_Trigonometry.radiansToAngle(DyFM_Vector2_Util.angleRad(from, to));
+    }
+    /**
+     * 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, to) {
+        return Math.atan2(to.y - from.y, to.x - from.x);
+    }
+    /**
+     * 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, to) {
+        return DyFM_Vector2_Util.angle(from, to);
+    }
+    /**
+     * 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) {
+        return trigonometry_util_1.DyFM_Trigonometry.radiansToAngle(DyFM_Vector2_Util.rad(vector));
+    }
+    /**
+     * 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) {
+        return Math.atan2(vector.y, vector.x);
+    }
+    /**
+     * 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() {
+        return DyFM_Vector2_Util.deg(this);
+    }
+    /**
+     * 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) {
+        return new DyFM_Vector2_Util(Math.floor(v.x), Math.floor(v.y));
+    }
+    /**
+     * 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() {
+        return DyFM_Vector2_Util.floor(this);
+    }
+    /////
+    /**
+     * 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, to) {
+        return DyFM_Vector2_Util.minus(to, from);
+    }
+    /**
+     * 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) {
+        return DyFM_Vector2_Util.direction(this, to);
+    }
+    /**
+     * 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) {
+        const v_U = new DyFM_Vector2_Util(v);
+        return v_U.multiply(1 / v_U.magintude);
+    }
+    /**
+     * 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() {
+        this.newValues(DyFM_Vector2_Util.normalize(this));
+    }
+    /**
+     * 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() {
+        return DyFM_Vector2_Util.normalize(this);
+    }
+    /**
+     * 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
+     * ```
+     */
+    calcMagnitude() {
+        this._magintude = trigonometry_util_1.DyFM_Trigonometry.getHypotenuse(this._x, this._y);
+    }
+    /**
+     * 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() {
+        return new DyFM_Vector2_Util(this._x, this._y);
+    }
+    /**
+     * 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, b) {
+        return a.x !== b.x || a.y !== b.y;
+    }
+    /**
+     * 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, b) {
+        return a.x === b.x && a.y === b.y;
+    }
+    /**
+     * 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, b) {
+        return a.x !== b.x || a.y !== b.y;
+    }
+    /**
+     * 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) {
+        return new DyFM_Vector2_Util(Math.abs(v.x), Math.abs(v.y));
+    }
+    abs() {
+        return this.newXY(Math.abs(this.x), Math.abs(this.y));
+    }
+    /**
+     * 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, decimals = 0) {
+        return new DyFM_Vector2_Util(math_util_1.DyFM_Math.round(v.x, decimals), math_util_1.DyFM_Math.round(v.y, decimals));
+    }
+    /**
+     * 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) {
+        return (new DyFM_Vector2_Util(v)).get();
+    }
+    /**
+     * returns a instance of DyFM_Vector2 from a DyFM_Vector2_Util
+     */
+    get() {
+        return { x: this.x, y: this.y };
+    }
+    getVector2 = this.get;
+    toVector2 = this.get;
+    /**
+     * returns a new vector with the same values
+     */
+    static clone(v) {
+        return { x: v.x, y: v.y };
+    }
+}
+exports.DyFM_Vector2_Util = DyFM_Vector2_Util;
 //# sourceMappingURL=vector2.util.js.map