@woosh/meep-engine 2.31.1 → 2.31.5

package/core/geom/Vector2.js

@@ -10,444 +10,619 @@ import { lerp } from "../math/lerp.js";
 import { max2 } from "../math/max2.js";
 import { min2 } from "../math/min2.js";
 
-/**
- *
- * @param {number} [x=0
- * @param {number} [y=0]
- * @property {number} x
- * @property {number} y
- * @constructor
- */
-function Vector2(x = 0, y = 0) {
-    assert.equal(typeof x, "number", `X must be of type "number", instead was "${typeof x}"`);
-    assert.equal(typeof y, "number", `Y must be of type "number", instead was "${typeof y}"`);
+class Vector2 {
+    /**
+     *
+     * @param {number} [x=0
+     * @param {number} [y=0]
+     * @property {number} x
+     * @property {number} y
+     * @constructor
+     */
+    constructor(x = 0, y = 0) {
+        assert.isNumber(x, 'x');
+        assert.isNumber(y, 'y');
 
-    assert.ok(!Number.isNaN(x), `X must be a valid number, instead was NaN`);
-    assert.ok(!Number.isNaN(y), `Y must be a valid number, instead was NaN`);
+        assert.notNaN(x, 'x');
+        assert.notNaN(y, 'y');
+
+        /**
+         *
+         * @type {number}
+         */
+        this.x = x;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.y = y;
+
+        this.onChanged = new Signal();
+    }
 
     /**
      *
-     * @type {number}
+     * @param {number[]} array
+     * @param {number} offset
      */
-    this.x = x;
+    readFromArray(array, offset) {
+        this.set(
+            array[offset],
+            array[offset + 1]
+        );
+    }
 
     /**
      *
-     * @type {number}
+     * @param {number[]} array
+     * @param {number} offset
      */
-    this.y = y;
+    writeToArray(array, offset) {
+        array[offset] = this.x;
+        array[offset + 1] = this.y;
+    }
 
-    this.onChanged = new Signal();
-}
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @returns {Vector2}
+     */
+    set(x, y) {
+        assert.isNumber(x, 'x');
+        assert.isNumber(y, 'y');
 
-/**
- * @readonly
- * @type {Vector2}
- */
-Vector2.up = Object.freeze(new Vector2(0, 1));
+        assert.notNaN(x, 'x');
+        assert.notNaN(y, 'y');
 
-/**
- * @readonly
- * @type {Vector2}
- */
-Vector2.down = Object.freeze(new Vector2(0, -1));
+        const oldX = this.x;
+        const oldY = this.y;
 
-/**
- * @readonly
- * @type {Vector2}
- */
-Vector2.left = Object.freeze(new Vector2(-1, 0));
+        if (oldX !== x || oldY !== y) {
+            this.x = x;
+            this.y = y;
 
-/**
- * @readonly
- * @type {Vector2}
- */
-Vector2.right = Object.freeze(new Vector2(1, 0));
+            if (this.onChanged.hasHandlers()) {
+                this.onChanged.send4(x, y, oldX, oldY);
+            }
+        }
+        return this;
+    }
 
-/**
- * @readonly
- * @type {Vector2}
- */
-Vector2.zero = Object.freeze(new Vector2(0, 0));
-/**
- * @readonly
- * @type {Vector2}
- */
-Vector2.one = Object.freeze(new Vector2(1, 1));
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     */
+    setSilent(x, y) {
 
-/**
- * @readonly
- * @type {boolean}
- */
-Vector2.prototype.isVector2 = true;
+        this.x = x;
+        this.y = y;
 
-/**
- *
- * @param {number[]} array
- * @param {number} offset
- */
-Vector2.prototype.readFromArray = function (array, offset) {
-    this.set(
-        array[offset],
-        array[offset + 1]
-    );
-};
+    }
 
-/**
- *
- * @param {number[]} array
- * @param {number} offset
- */
-Vector2.prototype.writeToArray = function (array, offset) {
-    array[offset] = this.x;
-    array[offset + 1] = this.y;
-};
+    /**
+     *
+     * @param {number} x
+     * @returns {Vector2}
+     */
+    setX(x) {
+        return this.set(x, this.y);
+    }
 
-/**
- *
- * @param {number} x
- * @param {number} y
- * @returns {Vector2}
- */
-Vector2.prototype.set = function (x, y) {
-    assert.isNumber(x, 'x');
-    assert.isNumber(y, 'y');
+    /**
+     *
+     * @param {number} y
+     * @returns {Vector2}
+     */
+    setY(y) {
+        return this.set(this.x, y);
+    }
 
-    assert.notNaN(x, 'x');
-    assert.notNaN(y, 'y');
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @returns {Vector2}
+     */
+    _sub(x, y) {
+        return this.set(this.x - x, this.y - y);
+    }
 
-    const oldX = this.x;
-    const oldY = this.y;
+    /**
+     *
+     * @param {Vector2} other
+     * @returns {Vector2}
+     */
+    sub(other) {
+        return this._sub(other.x, other.y);
+    }
 
-    if (oldX !== x || oldY !== y) {
-        this.x = x;
-        this.y = y;
+    /**
+     *
+     * @param {Vector2} a
+     * @param {Vector2} b
+     */
+    subVectors(a, b) {
+        this.set(a.x - b.x, a.y - b.y);
+    }
 
-        if (this.onChanged.hasHandlers()) {
-            this.onChanged.send4(x, y, oldX, oldY);
-        }
+    /**
+     * performs Math.floor operation on x and y
+     * @returns {Vector2}
+     */
+    floor() {
+        return this.set(Math.floor(this.x), Math.floor(this.y));
     }
-    return this;
-};
 
-/**
- *
- * @param {number} x
- * @param {number} y
- */
-Vector2.prototype.setSilent = function (x, y) {
+    /**
+     * performs Math.ceil operation on x and y
+     * @returns {Vector2}
+     */
+    ceil() {
+        return this.set(Math.ceil(this.x), Math.ceil(this.y));
+    }
 
-    this.x = x;
-    this.y = y;
+    /**
+     * Round both components to nearest integer
+     */
+    round() {
+        const x = Math.round(this.x);
+        const y = Math.round(this.y);
+        this.set(x, y);
+    }
 
-};
+    /**
+     * performs Math.abs operation on x and y
+     * @returns {Vector2}
+     */
+    abs() {
+        return this.set(Math.abs(this.x), Math.abs(this.y));
+    }
 
-/**
- *
- * @param {number} x
- * @returns {Vector2}
- */
-Vector2.prototype.setX = function (x) {
-    return this.set(x, this.y);
-};
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @returns {Vector2}
+     */
+    _mod(x, y) {
+        return this.set(this.x % x, this.y % y);
+    }
 
-/**
- *
- * @param {number} y
- * @returns {Vector2}
- */
-Vector2.prototype.setY = function (y) {
-    return this.set(this.x, y);
-};
+    /**
+     *
+     * @param {Vector2} other
+     * @returns {Vector2}
+     */
+    mod(other) {
+        return this._mod(other.x, other.y);
+    }
 
-/**
- *
- * @param {number} x
- * @param {number} y
- * @returns {Vector2}
- */
-Vector2.prototype._sub = function (x, y) {
-    return this.set(this.x - x, this.y - y);
-};
+    /**
+     *
+     * @param {Vector2} other
+     * @returns {Vector2}
+     */
+    divide(other) {
+        return this.set(this.x / other.x, this.y / other.y);
+    }
 
-/**
- *
- * @param {Vector2} other
- * @returns {Vector2}
- */
-Vector2.prototype.sub = function (other) {
-    return this._sub(other.x, other.y);
-};
+    /**
+     *
+     * @param {Vector2} other
+     * @returns {Vector2}
+     */
+    multiply(other) {
+        return this._multiply(other.x, other.y);
+    }
 
-/**
- * performs Math.floor operation on x and y
- * @returns {Vector2}
- */
-Vector2.prototype.floor = function () {
-    return this.set(Math.floor(this.x), Math.floor(this.y));
-};
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @returns {Vector2}
+     */
+    _multiply(x, y) {
+        return this.set(this.x * x, this.y * y);
+    }
 
-/**
- * performs Math.ceil operation on x and y
- * @returns {Vector2}
- */
-Vector2.prototype.ceil = function () {
-    return this.set(Math.ceil(this.x), Math.ceil(this.y));
-};
+    /**
+     *
+     * @param {Vector2} other
+     * @returns {Vector2}
+     */
+    max(other) {
+        const x = max2(this.x, other.x);
+        const y = max2(this.y, other.y);
+        return this.set(x, y);
+    }
 
-/**
- * Round both components to nearest integer
- */
-Vector2.prototype.round = function () {
-    const x = Math.round(this.x);
-    const y = Math.round(this.y);
-    this.set(x, y);
-};
+    /**
+     *
+     * @param {Vector2} other
+     * @returns {number}
+     */
+    dot(other) {
+        return v2_dot(this.x, this.y, other.x, other.y);
+    }
 
-/**
- * performs Math.abs operation on x and y
- * @returns {Vector2}
- */
-Vector2.prototype.abs = function () {
-    return this.set(Math.abs(this.x), Math.abs(this.y));
-};
+    /**
+     *
+     * @param {Vector2} other
+     * @returns {Vector2}
+     */
+    copy(other) {
+        return this.set(other.x, other.y);
+    }
 
-/**
- *
- * @param {number} x
- * @param {number} y
- * @returns {Vector2}
- */
-Vector2.prototype._mod = function (x, y) {
-    return this.set(this.x % x, this.y % y);
-};
+    /**
+     *
+     * @returns {Vector2}
+     */
+    clone() {
+        return new Vector2(this.x, this.y);
+    }
 
-/**
- *
- * @param {Vector2} other
- * @returns {Vector2}
- */
-Vector2.prototype.mod = function (other) {
-    return this._mod(other.x, other.y);
-};
+    /**
+     *
+     * @returns {Vector2}
+     */
+    negate() {
+        return this.set(-this.x, -this.y);
+    }
 
-/**
- *
- * @param {Vector2} other
- * @returns {Vector2}
- */
-Vector2.prototype.divide = function (other) {
-    return this.set(this.x / other.x, this.y / other.y);
-};
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @returns {Vector2}
+     */
+    _add(x, y) {
+        return this.set(this.x + x, this.y + y);
+    }
 
-/**
- *
- * @param {Vector2} other
- * @returns {Vector2}
- */
-Vector2.prototype.multiply = function (other) {
-    return this._multiply(other.x, other.y);
-};
+    /**
+     *
+     * @param {Vector2} other
+     * @returns {Vector2}
+     */
+    add(other) {
+        return this._add(other.x, other.y);
+    }
 
-/**
- *
- * @param {number} x
- * @param {number} y
- * @returns {Vector2}
- */
-Vector2.prototype._multiply = function (x, y) {
-    return this.set(this.x * x, this.y * y);
-};
+    /**
+     *
+     * @param {Number} val
+     */
+    addScalar(val) {
+        return this._add(val, val);
+    }
 
-/**
- *
- * @param {Vector2} other
- * @returns {Vector2}
- */
-Vector2.prototype.max = function (other) {
-    const x = max2(this.x, other.x);
-    const y = max2(this.y, other.y);
-    return this.set(x, y);
-};
+    /**
+     *
+     * @param {number} val
+     */
+    setScalar(val) {
+        this.set(val, val);
+    }
 
+    /**
+     *
+     * @param {number} val
+     */
+    divideScalar(val) {
+        this.multiplyScalar(1 / val);
+    }
 
-/**
- *
- * @param {Vector2} other
- * @returns {Vector2}
- */
-Vector2.prototype.copy = function (other) {
-    return this.set(other.x, other.y);
-};
+    /**
+     *
+     * @param {Number} val
+     * @returns {Vector2}
+     */
+    multiplyScalar(val) {
+        assert.isNumber(val, 'val');
+        assert.notNaN(val, 'val');
 
-/**
- *
- * @returns {Vector2}
- */
-Vector2.prototype.clone = function () {
-    return new Vector2(this.x, this.y);
-};
+        return this.set(this.x * val, this.y * val);
+    }
 
-/**
- *
- * @returns {Vector2}
- */
-Vector2.prototype.negate = function () {
-    return this.set(-this.x, -this.y);
-};
+    toJSON() {
+        return { x: this.x, y: this.y };
+    }
 
-/**
- *
- * @param {number} x
- * @param {number} y
- * @returns {Vector2}
- */
-Vector2.prototype._add = function (x, y) {
-    return this.set(this.x + x, this.y + y);
-};
-/**
- *
- * @param {Vector2} other
- * @returns {Vector2}
- */
-Vector2.prototype.add = function (other) {
-    return this._add(other.x, other.y);
-};
-/**
- *
- * @param {Number} val
- */
-Vector2.prototype.addScalar = function (val) {
-    return this._add(val, val);
-};
+    fromJSON({ x = 0, y = 0 }) {
+        this.set(x, y);
+    }
 
-/**
- *
- * @param {number} val
- */
-Vector2.prototype.setScalar = function (val) {
-    this.set(val, val);
-};
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer) {
+        buffer.writeFloat64(this.x);
+        buffer.writeFloat64(this.y);
+    }
 
-/**
- *
- * @param {number} val
- */
-Vector2.prototype.divideScalar = function (val) {
-    this.multiplyScalar(1 / val);
-};
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer) {
+        const x = buffer.readFloat64();
+        const y = buffer.readFloat64();
 
-/**
- *
- * @param {Number} val
- * @returns {Vector2}
- */
-Vector2.prototype.multiplyScalar = function (val) {
-    assert.equal(typeof val, "number", `Input scalar must be of type "number", instead was "${typeof val}"`);
-    assert.ok(!Number.isNaN(val), `Input scalar must be a valid number, instead was NaN`);
+        this.set(x, y);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBufferFloat32(buffer) {
+        buffer.writeFloat32(this.x);
+        buffer.writeFloat32(this.y);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBufferFloat32(buffer) {
+        const x = buffer.readFloat32();
+        const y = buffer.readFloat32();
 
-    return this.set(this.x * val, this.y * val);
-};
+        this.set(x, y);
+    }
 
-Vector2.prototype.toJSON = function () {
-    return { x: this.x, y: this.y };
-};
+    /**
+     *
+     * @returns {boolean}
+     */
+    isZero() {
+        return this.x === 0 && this.y === 0;
+    }
 
-Vector2.prototype.fromJSON = function (obj) {
-    this.set(obj.x, obj.y);
-};
+    /**
+     *
+     * @param {Number} minX
+     * @param {Number} minY
+     * @param {Number} maxX
+     * @param {Number} maxY
+     */
+    clamp(minX, minY, maxX, maxY) {
+        const x = clamp(this.x, minX, maxX);
+        const y = clamp(this.y, minY, maxY);
+        return this.set(x, y);
+    }
 
-/**
- *
- * @param {BinaryBuffer} buffer
- */
-Vector2.prototype.toBinaryBuffer = function (buffer) {
-    buffer.writeFloat64(this.x);
-    buffer.writeFloat64(this.y);
-};
+    /**
+     *
+     * @param {Number} lowX
+     * @param {Number} lowY
+     */
+    clampLow(lowX, lowY) {
+        const x = max2(this.x, lowX);
+        const y = max2(this.y, lowY);
+        return this.set(x, y);
+    }
 
-/**
- *
- * @param {BinaryBuffer} buffer
- */
-Vector2.prototype.fromBinaryBuffer = function (buffer) {
-    const x = buffer.readFloat64();
-    const y = buffer.readFloat64();
+    /**
+     *
+     * @param {Number} highX
+     * @param {Number} highY
+     */
+    clampHigh(highX, highY) {
+        const x = min2(this.x, highX);
+        const y = min2(this.y, highY);
+        return this.set(x, y);
+    }
+
+    /**
+     *
+     * @param {Vector2} other
+     * @returns {number}
+     */
+    distanceSqrTo(other) {
+        return this._distanceSqrTo(other.x, other.y);
+    }
+
+    /**
+     *
+     * @param {Vector2} a
+     * @param {Vector2} b
+     * @param {number} fraction
+     */
+    lerpVectors(a, b, fraction) {
+        v2Lerp(this, a, b, fraction);
+    }
+
+    /**
+     *
+     * @param {number[]} matrix3
+     */
+    applyMatrix3(matrix3) {
+        const x = this.x;
+        const y = this.y;
+
+        const _x = matrix3[0] * x + matrix3[3] * y + matrix3[6];
+        const _y = matrix3[1] * x + matrix3[4] * y + matrix3[7];
+
+        this.set(_x, _y);
+    }
+
+    /**
+     *
+     * @param {Vector2} other
+     * @returns {number}
+     */
+    distanceTo(other) {
+        return this._distanceTo(other.x, other.y);
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
+     */
+    _distanceSqrTo(x, y) {
+        const dx = this.x - x;
+        const dy = this.y - y;
+        return magnitudeSqr(dx, dy);
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
+     */
+    _distanceTo(x, y) {
+        return Math.sqrt(this._distanceSqrTo(x, y));
+    }
+
+    /**
+     *
+     * @param {Vector2} other
+     * @returns {number}
+     */
+    manhattanDistanceTo(other) {
+        const dx = Math.abs(this.x - other.x);
+        const dy = Math.abs(this.y - other.y);
+
+        return dx + dy;
+    }
+
+    /**
+     * @returns {number}
+     */
+    length() {
+        return v2_magnitude(this.x, this.y);
+    }
+
+    /**
+     * Normalizes the vector, preserving its direction, but making magnitude equal to 1
+     */
+    normalize() {
+        const l = this.length();
+
+        if (l === 0) {
+            //special case, can't normalize 0 length vector
+            return;
+        }
+
+        const m = 1 / l;
+
+        this.multiplyScalar(m);
+    }
+
+
+    /**
+     *
+     * @returns {number}
+     */
+    hashCode() {
+        const x = Math.sin(this.x) * 1367130550;
+        const y = Math.sin(this.y) * 1367130550;
+
+        let hash = ((x << 5) - x) + y;
+
+        hash |= 0; //convert to 32bit int
+
+        return hash;
+    }
+
+    /**
+     *
+     * @param {number} angle in radians
+     */
+    rotate(angle) {
+        const sin = Math.sin(angle);
+        const cos = Math.cos(angle);
+
+        const x = this.x * cos - this.y * sin
+        const y = this.x * sin - this.y * cos;
+
+        this.set(x, y);
+    }
+
+    /**
+     *
+     * @param {function} processor
+     * @param {*} [thisArg]
+     * @returns {Vector2}
+     */
+    process(processor, thisArg) {
+        processor.call(thisArg, this.x, this.y);
+
+        this.onChanged.add(processor, thisArg);
+
+        return this;
+    }
+
+    toString() {
+        return `Vector2{x:${this.x}, y:${this.y}}`;
+    }
+
+    /**
+     *
+     * @param {Vector2} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.x === other.x && this.y === other.y;
+    }
+
+    * [Symbol.iterator]() {
+
+        yield this.x;
+        yield this.y;
+
+    }
+}
 
-    this.set(x, y);
-};
 /**
- *
- * @param {BinaryBuffer} buffer
+ * @readonly
+ * @type {Vector2}
  */
-Vector2.prototype.toBinaryBufferFloat32 = function (buffer) {
-    buffer.writeFloat32(this.x);
-    buffer.writeFloat32(this.y);
-};
+Vector2.up = Object.freeze(new Vector2(0, 1));
 
 /**
- *
- * @param {BinaryBuffer} buffer
+ * @readonly
+ * @type {Vector2}
  */
-Vector2.prototype.fromBinaryBufferFloat32 = function (buffer) {
-    const x = buffer.readFloat32();
-    const y = buffer.readFloat32();
-
-    this.set(x, y);
-};
+Vector2.down = Object.freeze(new Vector2(0, -1));
 
 /**
- *
- * @returns {boolean}
+ * @readonly
+ * @type {Vector2}
  */
-Vector2.prototype.isZero = function () {
-    return this.x === 0 && this.y === 0;
-};
-
+Vector2.left = Object.freeze(new Vector2(-1, 0));
 
 /**
- *
- * @param {Number} minX
- * @param {Number} minY
- * @param {Number} maxX
- * @param {Number} maxY
+ * @readonly
+ * @type {Vector2}
  */
-Vector2.prototype.clamp = function (minX, minY, maxX, maxY) {
-    const x = clamp(this.x, minX, maxX);
-    const y = clamp(this.y, minY, maxY);
-    return this.set(x, y);
-};
+Vector2.right = Object.freeze(new Vector2(1, 0));
 
 /**
- *
- * @param {Number} lowX
- * @param {Number} lowY
+ * @readonly
+ * @type {Vector2}
  */
-Vector2.prototype.clampLow = function (lowX, lowY) {
-    const x = max2(this.x, lowX);
-    const y = max2(this.y, lowY);
-    return this.set(x, y);
-};
-
+Vector2.zero = Object.freeze(new Vector2(0, 0));
 /**
- *
- * @param {Number} highX
- * @param {Number} highY
+ * @readonly
+ * @type {Vector2}
  */
-Vector2.prototype.clampHigh = function (highX, highY) {
-    const x = min2(this.x, highX);
-    const y = min2(this.y, highY);
-    return this.set(x, y);
-};
+Vector2.one = Object.freeze(new Vector2(1, 1));
 
 /**
- *
- * @param {Vector2} other
- * @returns {number}
+ * @readonly
+ * @type {boolean}
  */
-Vector2.prototype.distanceSqrTo = function (other) {
-    return this._distanceSqrTo(other.x, other.y);
-};
+Vector2.prototype.isVector2 = true;
 
 /**
  *
@@ -464,30 +639,6 @@ function v2Lerp(result, a, b, fraction) {
     result.set(x, y);
 }
 
-/**
- *
- * @param {Vector2} a
- * @param {Vector2} b
- * @param {number} fraction
- */
-Vector2.prototype.lerpVectors = function (a, b, fraction) {
-    v2Lerp(this, a, b, fraction);
-};
-
-/**
- *
- * @param {number[]} matrix3
- */
-Vector2.prototype.applyMatrix3 = function (matrix3) {
-    const x = this.x;
-    const y = this.y;
-
-    const _x = matrix3[0] * x + matrix3[3] * y + matrix3[6];
-    const _y = matrix3[1] * x + matrix3[4] * y + matrix3[7];
-
-    this.set(_x, _y);
-};
-
 
 /**
  *
@@ -515,10 +666,10 @@ export function v2_angleBetween(x0, y0, x1, y1) {
  * @returns {number}
  */
 export function v2_dot(x0, y0, x1, y1) {
-    assert.typeOf(x0, 'number', 'x0');
-    assert.typeOf(y0, 'number', 'y0');
-    assert.typeOf(x1, 'number', 'x1');
-    assert.typeOf(y1, 'number', 'y1');
+    assert.isNumber(x0, 'x0');
+    assert.isNumber(y0, 'y0');
+    assert.isNumber(x1, 'x1');
+    assert.isNumber(y1, 'y1');
 
     return (x0 * x1 + y0 * y1);
 }
@@ -553,120 +704,14 @@ export function v2_magnitude(x, y) {
  */
 export function v2_distance(x0, y0, x1, y1) {
 
-    assert.typeOf(x0, 'number', 'x0');
-    assert.typeOf(y0, 'number', 'y0');
-    assert.typeOf(x1, 'number', 'x1');
-    assert.typeOf(y1, 'number', 'y1');
+    assert.isNumber(x0, 'x0');
+    assert.isNumber(y0, 'x0');
+    assert.isNumber(x1, 'x0');
+    assert.isNumber(y1, 'x0');
 
     return v2_magnitude(x1 - x0, y1 - y0);
 }
 
 Vector2._distance = v2_distance;
 
-/**
- *
- * @param {Vector2} other
- * @returns {number}
- */
-Vector2.prototype.distanceTo = function (other) {
-    return this._distanceTo(other.x, other.y);
-};
-
-/**
- *
- * @param {number} x
- * @param {number} y
- * @returns {number}
- */
-Vector2.prototype._distanceSqrTo = function (x, y) {
-    const dx = this.x - x;
-    const dy = this.y - y;
-    return magnitudeSqr(dx, dy);
-};
-
-/**
- *
- * @param {number} x
- * @param {number} y
- * @returns {number}
- */
-Vector2.prototype._distanceTo = function (x, y) {
-    return Math.sqrt(this._distanceSqrTo(x, y));
-};
-
-/**
- *
- * @param {Vector2} other
- * @returns {number}
- */
-Vector2.prototype.manhattanDistanceTo = function (other) {
-    const dx = Math.abs(this.x - other.x);
-    const dy = Math.abs(this.y - other.y);
-
-    return dx + dy;
-};
-
-/**
- * @returns {number}
- */
-Vector2.prototype.length = function () {
-    return v2_magnitude(this.x, this.y);
-};
-
-/**
- *
- * @returns {number}
- */
-Vector2.prototype.hashCode = function () {
-    const x = Math.sin(this.x) * 1367130550;
-    const y = Math.sin(this.y) * 1367130550;
-
-    let hash = ((x << 5) - x) + y;
-
-    hash |= 0; //convert to 32bit int
-
-    return hash;
-};
-
-/**
- *
- * @param {number} angle in radians
- */
-Vector2.prototype.rotate = function (angle) {
-    const sin = Math.sin(angle);
-    const cos = Math.cos(angle);
-
-    const x = this.x * cos - this.y * sin
-    const y = this.x * sin - this.y * cos;
-
-    this.set(x, y);
-};
-
-/**
- *
- * @param {function} processor
- * @param {*} [thisArg]
- * @returns {Vector2}
- */
-Vector2.prototype.process = function (processor, thisArg) {
-    processor.call(thisArg, this.x, this.y);
-
-    this.onChanged.add(processor, thisArg);
-
-    return this;
-};
-
-Vector2.prototype.toString = function () {
-    return `Vector2{x:${this.x}, y:${this.y}}`;
-};
-
-/**
- *
- * @param {Vector2} other
- * @returns {boolean}
- */
-Vector2.prototype.equals = function (other) {
-    return this.x === other.x && this.y === other.y;
-};
-
 export default Vector2;