@nativewrappers/fivem 0.0.19 → 0.0.21

package/client/Camera.js

@@ -35,10 +35,10 @@ export class Camera {
         return this.ForwardVector;
     }
     set Direction(direction) {
-        const dir = direction.normalize;
+        const dir = direction.normalize();
         const vec1 = new Vector3(dir.x, dir.y, 0);
         const vec2 = new Vector3(dir.z, vec1.distanceSquared(vec1), 0);
-        const vec3 = vec2.normalize;
+        const vec3 = vec2.normalize();
         this.Rotation = new Vector3(Math.atan2(vec3.x, vec3.y) * 57.295779513082323, this.Rotation.y, Math.atan2(dir.x, dir.y) * -57.295779513082323);
     }
     //   public get UpVector() : Vector3 {

package/client/Events.js

@@ -11,15 +11,15 @@ const getClassFromArguments = (...args) => {
     for (const arg of args) {
         switch (arg.type) {
             case ClassTypes.Vector2: {
-                newArgs.push(Vector2.create(arg));
+                newArgs.push(Vector2.fromObject(arg));
                 continue;
             }
             case ClassTypes.Vector3: {
-                newArgs.push(Vector3.create(arg));
+                newArgs.push(Vector3.fromObject(arg));
                 continue;
             }
             case ClassTypes.Vector4: {
-                newArgs.push(Vector4.create(arg));
+                newArgs.push(Vector4.fromObject(arg));
                 continue;
             }
             case ClassTypes.Ped: {

package/common/utils/Vector.d.ts

@@ -1,61 +1,212 @@
 import type { MsgpackBuffer } from '../types';
+/**
+ * Represents a 2-dimensional vector.
+ */
 export interface Vec2 {
     x: number;
     y: number;
 }
+/**
+ * Represents a 3-dimensional vector.
+ */
 export interface Vec3 {
     x: number;
     y: number;
     z: number;
 }
+/**
+ * Represents a 4-dimensional vector.
+ */
 export interface Vec4 {
     x: number;
     y: number;
     z: number;
     w: number;
 }
+/**
+ * An object with vector components.
+ */
 interface VectorObject {
     x: number;
     y: number;
     z?: number;
     w?: number;
 }
-type VectorArray = [number, number, number?, number?] | number[];
+/**
+ * Represents a vector of variable dimensions.
+ */
+type VectorN<L extends number, T = number> = L extends 2 ? [T, T] : L extends 3 ? [T, T, T] : L extends 4 ? [T, T, T, T] : never;
+/**
+ * An array that can be converted to a vector.
+ */
+type VectorArray<T> = T extends Vec4 ? VectorN<4> : T extends Vec3 ? VectorN<3> : T extends Vec2 ? VectorN<2> : number[];
+/**
+ * The constructor type of the Vector class.
+ */
 type VectorType = typeof Vector;
+/**
+ * Represents an object or class that can be treated as a vector.
+ */
 type VectorLike = VectorObject | Vector;
+/**
+ * Utility type to get the vector type of an object based on its component.
+ */
+type InferVector<T> = T extends Vec4 | VectorN<4> ? Vector4 : T extends Vec3 | VectorN<3> ? Vector3 : T extends Vec2 | VectorN<2> ? Vector2 : any;
+/**
+ * A base vector class inherited by all vector classes.
+ */
 export declare class Vector {
     size: number;
     x: number;
     y: number;
     z?: number | undefined;
     w?: number | undefined;
+    /**
+     * The type identifier for vectors.
+     */
     type: string;
-    static create<T extends VectorType>(this: T, x: VectorLike | number, y?: number, z?: number, w?: number): InstanceType<T>;
-    static fromBuffer({ buffer }: MsgpackBuffer): Vector;
-    static clone<T extends VectorType>(this: T, obj: VectorLike): InstanceType<T>;
+    protected static create(x: number, y?: number): Vector2;
+    protected static create(x: number, y?: number, z?: number): Vector3;
+    protected static create(x: number, y?: number, z?: number, w?: number): Vector4;
+    /**
+     * Creates a new vector based on the provided vector-like object.
+     * @param obj The object representing the vector.
+     * @returns A new vector instance.
+     */
+    protected static create<T extends VectorType, U extends VectorLike>(this: T, obj: U): InferVector<U>;
+    /**
+     * Creates a vector from binary data in a MsgpackBuffer.
+     * @param msgpackBuffer The buffer containing binary data.
+     * @returns A new vector instance.
+     */
+    static fromBuffer<T extends VectorType>(this: T, { buffer }: MsgpackBuffer): InstanceType<T>;
+    /**
+     * Creates a deep copy of the provided vector.
+     * @param obj The vector to clone.
+     * @returns A new vector instance that is a copy of the provided vector.
+     */
+    static clone<T extends VectorType, U extends VectorLike>(this: T, obj: U): InferVector<U>;
+    /**
+     * Performs an operation between a vector and either another vector or scalar value.
+     * @param a - The first vector.
+     * @param b - The second vector or scalar value.
+     * @param operator - The function defining the operation to perform.
+     * @returns A new vector resulting from the operation.
+     */
     private static operate;
+    /**
+     * Adds two vectors or a scalar value to a vector.
+     * @param a - The first vector or scalar value.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with incremented components.
+     */
     static add<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
+    /**
+     * Adds a scalar value to the x-component of a vector.
+     * @param obj - The vector.
+     * @param x - The value to add to the x-component.
+     * @returns A new vector with the x-component incremented.
+     */
+    static addX<T extends VectorType, U extends VectorLike>(this: T, obj: U, x: number): InferVector<U>;
+    /**
+     * Adds a scalar value to the y-component of a vector.
+     * @param obj - The vector.
+     * @param y - The value to add to the y-component.
+     * @returns A new vector with the y-component incremented.
+     */
+    static addY<T extends VectorType, U extends VectorLike>(this: T, obj: U, y: number): InferVector<U> | undefined;
+    /**
+     * Adds a scalar value to the z-component of a vector.
+     * @param obj - The vector.
+     * @param z - The value to add to the z-component.
+     * @returns A new vector with the z-component incremented.
+     */
+    static addZ<T extends VectorType, U extends VectorLike>(this: T, obj: U, z: number): InferVector<U> | undefined;
+    /**
+     * Adds a scalar value to the w-component of a vector.
+     * @param obj - The vector.
+     * @param w - The value to add to the w-component.
+     * @returns A new vector with the w-component incremented.
+     */
+    static addW<T extends VectorType, U extends VectorLike>(this: T, obj: U, w: number): InferVector<U> | undefined;
+    /**
+     * Subtracts one vector from another or subtracts a scalar value from a vector.
+     * @param a - The vector.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with subtracted components.
+     */
     static subtract<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
+    /**
+     * Multiplies two vectors by their components, or multiplies a vector by a scalar value.
+     * @param a - The vector.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with multiplied components.
+     */
     static multiply<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
+    /**
+     * Divides two vectors by their components, or divides a vector by a scalar value.
+     * @param a - The vector.
+     * @param b - The second vector or scalar vector.
+     * @returns A new vector with divided components.
+     */
     static divide<T extends VectorType, U extends VectorLike>(this: T, a: U, b: VectorLike | number): U;
+    /**
+     * Calculates the dot product of two vectors.
+     * @param a - The first vector.
+     * @param b - The second vector.
+     * @returns A scalar value representing the degree of alignment between the input vectors.
+     */
     static dotProduct<T extends VectorType, U extends VectorLike>(this: T, a: U, b: U): number;
+    /**
+     * Calculates the cross product of two vectors in three-dimensional space.
+     * @param a - The first vector.
+     * @param b - The second vector.
+     * @returns A new vector perpendicular to both input vectors.
+     */
+    static crossProduct<T extends VectorType, U extends VectorObject>(this: T, a: U, b: U): U;
+    /**
+     * Normalizes a vector, producing a new vector with the same direction but with a magnitude of 1.
+     * @param vector - The vector to be normalized.
+     * @returns The new normalized vector.
+     */
     static normalize<T extends VectorType, U extends VectorLike>(this: T, a: U): U;
     /**
      * Creates a vector from an array of numbers.
      * @param primitive An array of numbers (usually returned by a native).
      */
-    static fromArray<T extends VectorType>(this: T, primitive: VectorArray): InstanceType<T>;
+    static fromArray<T extends VectorType, U extends VectorArray<T>>(this: T, primitive: U): InferVector<U>;
+    /**
+     * Creates a vector from an array or object containing vector components.
+     * @param primitive The object to use as a vector.
+     */
+    static fromObject<T extends VectorType, U extends InferVector<T> | VectorArray<T>>(this: T, primitive: U): InstanceType<T>;
     /**
      * Creates an array of vectors from an array of number arrays
      * @param primitives A multi-dimensional array of number arrays
      */
-    static fromArrays<T extends VectorType>(this: T, primitives: VectorArray[]): InstanceType<T>[];
+    static fromArrays<T extends VectorType, U extends VectorArray<T>[]>(this: T, primitives: U): InferVector<VectorArray<T>>[];
+    /**
+     * Calculates the length (magnitude) of a vector.
+     * @param obj - The vector for which to calculate the length.
+     * @returns The magnitude of the vector.
+     */
     static Length<T extends VectorType, U extends VectorLike>(this: T, obj: U): number;
+    /**
+     * Constructs a new vector.
+     * @param size The size of the vector (number of components).
+     * @param x The x-component of the vector.
+     * @param y The y-component of the vector (optional, defaults to x).
+     * @param z The z-component of the vector (optional).
+     * @param w The w-component of the vector (optional).
+     */
     constructor(size: number, x?: number, y?: number, z?: number | undefined, w?: number | undefined);
-    [Symbol.iterator](): Iterator<[string, number]>;
+    [Symbol.iterator](): Iterator<number>;
     toString(): string;
     toJSON(): string;
-    clone(): this;
+    /**
+     * @see Vector.clone
+     */
+    clone(): InferVector<this>;
     /**
      * The product of the Euclidean magnitudes of this and another Vector.
      *
@@ -70,32 +221,116 @@ export declare class Vector {
      * @returns Distance between this and another vector.
      */
     distance(v: VectorLike): number;
-    get normalize(): this;
+    /**
+     * @see Vector.normalize
+     */
+    normalize(): this;
+    /**
+     * @see Vector.dotProduct
+     */
     dotProduct(v: this): number;
+    /**
+     * @see Vector.add
+     */
     add(v: VectorLike | number): this;
+    /**
+     * @see Vector.addX
+     */
+    addX(x: number): InferVector<this>;
+    /**
+     * @see Vector.addY
+     */
+    addY(x: number): InferVector<this> | undefined;
+    /**
+     * @see Vector.subtract
+     */
     subtract(v: VectorLike): this;
+    /**
+     * @see Vector.multiply
+     */
     multiply(v: VectorLike | number): this;
+    /**
+     * @see Vector.divide
+     */
     divide(v: VectorLike | number): this;
-    toArray(): [number, number];
-    replace(v: VectorLike): void;
+    /**
+     * Converts the vector to an array of its components.
+     */
+    toArray(): number[];
+    /**
+     * Replaces the components of the vector with the components of another vector object.
+     * @param v - The object whose components will replace the current vector's components.
+     */
+    replace<T extends VectorLike>(v: T): void;
+    /**
+     * Calculates the length (magnitude) of a vector.
+     * @returns The magnitude of the vector.
+     */
     get Length(): number;
 }
+/**
+ * Represents a 2-dimensional vector.
+ */
 export declare class Vector2 extends Vector {
     type: string;
-    constructor(x: number, y?: number);
     static readonly Zero: Vector2;
+    /**
+     * Constructs a new 2D vector.
+     * @param x The x-component of the vector.
+     * @param y The y-component of the vector (optional, defaults to x).
+     */
+    constructor(x: number, y?: number);
 }
+/**
+ * Represents a 3-dimensional vector.
+ */
 export declare class Vector3 extends Vector implements Vec3 {
     type: string;
     z: number;
-    constructor(x: number, y?: number, z?: number);
     static readonly Zero: Vector3;
+    /**
+     * Constructs a new 3D vector.
+     * @param x The x-component of the vector.
+     * @param y The y-component of the vector (optional, defaults to x).
+     * @param z The z-component of the vector (optional, defaults to y).
+     */
+    constructor(x: number, y?: number, z?: number);
+    /**
+     * @see Vector.addZ
+     */
+    addZ(z: number): InferVector<this> | undefined;
+    /**
+     * @see Vector.crossProduct
+     */
+    crossProduct(v: VectorLike): VectorLike;
 }
+/**
+ * Represents a 4-dimensional vector.
+ */
 export declare class Vector4 extends Vector {
     type: string;
     z: number;
     w: number;
-    constructor(x: number, y?: number, z?: number, w?: number);
     static readonly Zero: Vector4;
+    /**
+     * Constructs a new 4D vector.
+     * @param x The x-component of the vector.
+     * @param y The y-component of the vector (optional, defaults to x).
+     * @param z The z-component of the vector (optional, defaults to y).
+     * @param w The w-component of the vector (optional, defaults to z).
+     */
+    constructor(x: number, y?: number, z?: number, w?: number);
+    /**
+     * @see Vector.addZ
+     */
+    addZ(z: number): InferVector<this> | undefined;
+    /**
+     * @see Vector.addW
+     */
+    addW(w: number): InferVector<this> | undefined;
+    /**
+     * @see Vector.crossProduct
+     */
+    crossProduct(v: VectorLike): VectorLike;
 }
 export {};

package/common/utils/Vector.js

@@ -1,5 +1,16 @@
 // Adapted from https://raw.githubusercontent.com/you21979/typescript-vector/master/vector3.ts
+/**
+ * A base vector class inherited by all vector classes.
+ */
 export class Vector {
+    /**
+     * Creates a new vector based on the provided parameters.
+     * @param x The x-component of the vector.
+     * @param y The y-component of the vector (optional, defaults to the value of x).
+     * @param z The z-component of the vector (optional, defaults to the value of y).
+     * @param w The w-component of the vector (optional, defaults to the value of z).
+     * @returns A new vector instance.
+     */
     static create(x, y, z, w) {
         if (y === undefined && typeof x === 'number')
             return new Vector2(x, x);
@@ -18,15 +29,32 @@ export class Vector {
                 return new Vector4(x, y, z, w);
         }
     }
+    /**
+     * Creates a vector from binary data in a MsgpackBuffer.
+     * @param msgpackBuffer The buffer containing binary data.
+     * @returns A new vector instance.
+     */
     static fromBuffer({ buffer }) {
         const arr = [];
         for (let offset = 0; offset < buffer.length; offset += 4)
             arr.push(buffer.readFloatLE(offset));
         return this.fromArray(arr);
     }
+    /**
+     * Creates a deep copy of the provided vector.
+     * @param obj The vector to clone.
+     * @returns A new vector instance that is a copy of the provided vector.
+     */
     static clone(obj) {
         return this.create(obj);
     }
+    /**
+     * Performs an operation between a vector and either another vector or scalar value.
+     * @param a - The first vector.
+     * @param b - The second vector or scalar value.
+     * @param operator - The function defining the operation to perform.
+     * @returns A new vector resulting from the operation.
+     */
     static operate(a, b, operator) {
         let { x, y, z, w } = a;
         const isNumber = typeof b === 'number';
@@ -38,18 +66,98 @@ export class Vector {
             w = operator(w, isNumber ? b : b.w ?? 0);
         return this.create(x, y, z, w);
     }
+    /**
+     * Adds two vectors or a scalar value to a vector.
+     * @param a - The first vector or scalar value.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with incremented components.
+     */
     static add(a, b) {
         return this.operate(a, b, (x, y) => x + y);
     }
+    /**
+     * Adds a scalar value to the x-component of a vector.
+     * @param obj - The vector.
+     * @param x - The value to add to the x-component.
+     * @returns A new vector with the x-component incremented.
+     */
+    static addX(obj, x) {
+        const vec = this.clone(obj);
+        vec.x += x;
+        return vec;
+    }
+    /**
+     * Adds a scalar value to the y-component of a vector.
+     * @param obj - The vector.
+     * @param y - The value to add to the y-component.
+     * @returns A new vector with the y-component incremented.
+     */
+    static addY(obj, y) {
+        if (typeof obj.y !== 'number')
+            return;
+        const vec = this.clone(obj);
+        vec.y += y;
+        return vec;
+    }
+    /**
+     * Adds a scalar value to the z-component of a vector.
+     * @param obj - The vector.
+     * @param z - The value to add to the z-component.
+     * @returns A new vector with the z-component incremented.
+     */
+    static addZ(obj, z) {
+        if (typeof obj.z !== 'number')
+            return;
+        const vec = this.clone(obj);
+        vec.z += z;
+        return vec;
+    }
+    /**
+     * Adds a scalar value to the w-component of a vector.
+     * @param obj - The vector.
+     * @param w - The value to add to the w-component.
+     * @returns A new vector with the w-component incremented.
+     */
+    static addW(obj, w) {
+        if (typeof obj.w !== 'number')
+            return;
+        const vec = this.clone(obj);
+        vec.w += w;
+        return vec;
+    }
+    /**
+     * Subtracts one vector from another or subtracts a scalar value from a vector.
+     * @param a - The vector.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with subtracted components.
+     */
     static subtract(a, b) {
         return this.operate(a, b, (x, y) => x - y);
     }
+    /**
+     * Multiplies two vectors by their components, or multiplies a vector by a scalar value.
+     * @param a - The vector.
+     * @param b - The second vector or scalar value.
+     * @returns A new vector with multiplied components.
+     */
     static multiply(a, b) {
         return this.operate(a, b, (x, y) => x * y);
     }
+    /**
+     * Divides two vectors by their components, or divides a vector by a scalar value.
+     * @param a - The vector.
+     * @param b - The second vector or scalar vector.
+     * @returns A new vector with divided components.
+     */
     static divide(a, b) {
         return this.operate(a, b, (x, y) => x / y);
     }
+    /**
+     * Calculates the dot product of two vectors.
+     * @param a - The first vector.
+     * @param b - The second vector.
+     * @returns A scalar value representing the degree of alignment between the input vectors.
+     */
     static dotProduct(a, b) {
         let result = 0;
         for (const key of ['x', 'y', 'z', 'w']) {
@@ -63,8 +171,31 @@ export class Vector {
         }
         return result;
     }
+    /**
+     * Calculates the cross product of two vectors in three-dimensional space.
+     * @param a - The first vector.
+     * @param b - The second vector.
+     * @returns A new vector perpendicular to both input vectors.
+     */
+    static crossProduct(a, b) {
+        const { x: ax, y: ay, z: az, w: aw } = a;
+        const { x: bx, y: by, z: bz } = b;
+        if (ax === undefined ||
+            ay === undefined ||
+            az === undefined ||
+            bx === undefined ||
+            by === undefined ||
+            bz === undefined)
+            throw new Error('Vector.crossProduct requires two three-dimensional vectors.');
+        return this.create(ay * bz - az * by, az * bx - ax * bz, ax * by - ay * bx, aw);
+    }
+    /**
+     * Normalizes a vector, producing a new vector with the same direction but with a magnitude of 1.
+     * @param vector - The vector to be normalized.
+     * @returns The new normalized vector.
+     */
     static normalize(a) {
-        const length = a.Length || this.Length(a);
+        const length = a instanceof Vector ? a.Length : this.Length(a);
         return this.divide(a, length);
     }
     /**
@@ -73,15 +204,17 @@ export class Vector {
      */
     static fromArray(primitive) {
         const [x, y, z, w] = primitive;
-        switch (this.name === 'Vector' ? `Vector${primitive.length < 2 ? 2 : primitive.length}` : this.name) {
-            case 'Vector':
-                return new Vector(x, y);
-            case 'Vector3':
-                return new Vector3(x, y, z);
-            default:
-            case 'Vector4':
-                return new Vector4(x, y, z, w);
-        }
+        return this.create(x, y, z, w);
+    }
+    /**
+     * Creates a vector from an array or object containing vector components.
+     * @param primitive The object to use as a vector.
+     */
+    static fromObject(primitive) {
+        if (Array.isArray(primitive))
+            return this.fromArray(primitive);
+        const { x, y, z, w } = primitive;
+        return this.create(x, y, z, w);
     }
     /**
      * Creates an array of vectors from an array of number arrays
@@ -90,30 +223,47 @@ export class Vector {
     static fromArrays(primitives) {
         return primitives.map(this.fromArray);
     }
+    /**
+     * Calculates the length (magnitude) of a vector.
+     * @param obj - The vector for which to calculate the length.
+     * @returns The magnitude of the vector.
+     */
     static Length(obj) {
         let sum = 0;
         for (const key of ['x', 'y', 'z', 'w']) {
-            const value = obj[key];
-            if (value)
+            if (key in obj) {
+                const value = obj[key];
                 sum += value * value;
+            }
         }
         return Math.sqrt(sum);
     }
+    /**
+     * Constructs a new vector.
+     * @param size The size of the vector (number of components).
+     * @param x The x-component of the vector.
+     * @param y The y-component of the vector (optional, defaults to x).
+     * @param z The z-component of the vector (optional).
+     * @param w The w-component of the vector (optional).
+     */
     constructor(size, x = 0, y = x, z, w) {
         this.size = size;
         this.x = x;
         this.y = y;
         this.z = z;
         this.w = w;
+        /**
+         * The type identifier for vectors.
+         */
         this.type = 'vec';
     }
     *[Symbol.iterator]() {
-        yield ['x', this.x];
-        yield ['y', this.y];
+        yield this.x;
+        yield this.y;
         if (this.z)
-            yield ['z', this.z];
+            yield this.z;
         if (this.w)
-            yield ['w', this.w];
+            yield this.w;
     }
     toString() {
         const { x, y, z, w } = this;
@@ -122,6 +272,9 @@ export class Vector {
     toJSON() {
         return this.toString();
     }
+    /**
+     * @see Vector.clone
+     */
     clone() {
         return Vector.clone(this);
     }
@@ -144,59 +297,159 @@ export class Vector {
     distance(v) {
         return Math.sqrt(this.distanceSquared(v));
     }
-    get normalize() {
+    /**
+     * @see Vector.normalize
+     */
+    normalize() {
         return Vector.normalize(this);
     }
+    /**
+     * @see Vector.dotProduct
+     */
     dotProduct(v) {
         return Vector.dotProduct(this, v);
     }
+    /**
+     * @see Vector.add
+     */
     add(v) {
         return Vector.add(this, v);
     }
+    /**
+     * @see Vector.addX
+     */
+    addX(x) {
+        return Vector.addX(this, x);
+    }
+    /**
+     * @see Vector.addY
+     */
+    addY(x) {
+        return Vector.addY(this, x);
+    }
+    /**
+     * @see Vector.subtract
+     */
     subtract(v) {
         return Vector.subtract(this, v);
     }
+    /**
+     * @see Vector.multiply
+     */
     multiply(v) {
         return Vector.multiply(this, v);
     }
+    /**
+     * @see Vector.divide
+     */
     divide(v) {
         return Vector.divide(this, v);
     }
+    /**
+     * Converts the vector to an array of its components.
+     */
     toArray() {
-        return [this.x, this.y];
+        return [...this];
     }
+    /**
+     * Replaces the components of the vector with the components of another vector object.
+     * @param v - The object whose components will replace the current vector's components.
+     */
     replace(v) {
-        this.x = v.x;
-        this.y = v.y;
+        for (const key of ['x', 'y', 'z', 'w']) {
+            if (key in this && key in v)
+                this[key] = v[key];
+        }
     }
+    /**
+     * Calculates the length (magnitude) of a vector.
+     * @returns The magnitude of the vector.
+     */
     get Length() {
         let sum = 0;
-        for (let [_, value] of this)
+        for (let value of this)
             sum += value * value;
         return Math.sqrt(sum);
     }
 }
+/**
+ * Represents a 2-dimensional vector.
+ */
 export class Vector2 extends Vector {
+    /**
+     * Constructs a new 2D vector.
+     * @param x The x-component of the vector.
+     * @param y The y-component of the vector (optional, defaults to x).
+     */
     constructor(x, y = x) {
         super(2, x, y);
         this.type = 'vec2';
     }
 }
 Vector2.Zero = new Vector2(0, 0);
+/**
+ * Represents a 3-dimensional vector.
+ */
 export class Vector3 extends Vector {
+    /**
+     * Constructs a new 3D vector.
+     * @param x The x-component of the vector.
+     * @param y The y-component of the vector (optional, defaults to x).
+     * @param z The z-component of the vector (optional, defaults to y).
+     */
     constructor(x, y = x, z = y) {
         super(3, x, y, z);
         this.type = 'vec3';
         this.z = z;
     }
+    /**
+     * @see Vector.addZ
+     */
+    addZ(z) {
+        return Vector.addZ(this, z);
+    }
+    /**
+     * @see Vector.crossProduct
+     */
+    crossProduct(v) {
+        return Vector.crossProduct(this, v);
+    }
 }
 Vector3.Zero = new Vector3(0, 0, 0);
+/**
+ * Represents a 4-dimensional vector.
+ */
 export class Vector4 extends Vector {
+    /**
+     * Constructs a new 4D vector.
+     * @param x The x-component of the vector.
+     * @param y The y-component of the vector (optional, defaults to x).
+     * @param z The z-component of the vector (optional, defaults to y).
+     * @param w The w-component of the vector (optional, defaults to z).
+     */
     constructor(x, y = x, z = y, w = z) {
         super(4, x, y, z, w);
         this.type = 'vec4';
         this.z = z;
         this.w = w;
     }
+    /**
+     * @see Vector.addZ
+     */
+    addZ(z) {
+        return Vector.addZ(this, z);
+    }
+    /**
+     * @see Vector.addW
+     */
+    addW(w) {
+        return Vector.addW(this, w);
+    }
+    /**
+     * @see Vector.crossProduct
+     */
+    crossProduct(v) {
+        return Vector.crossProduct(this, v);
+    }
 }
 Vector4.Zero = new Vector4(0, 0, 0, 0);

package/package.json

@@ -4,7 +4,7 @@
   "author": "Remco Troost <d0p3t>",
   "license": "MIT",
   "type": "module",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "publishConfig": {
     "directory": "lib"
   },

package/server/Events.js

@@ -8,15 +8,15 @@ const getClassFromArguments = (...args) => {
     for (const arg of args) {
         switch (arg.type) {
             case ClassTypes.Vector2: {
-                newArgs.push(Vector2.create(arg));
+                newArgs.push(Vector2.fromObject(arg));
                 continue;
             }
             case ClassTypes.Vector3: {
-                newArgs.push(Vector3.create(arg));
+                newArgs.push(Vector3.fromObject(arg));
                 continue;
             }
             case ClassTypes.Vector4: {
-                newArgs.push(Vector4.create(arg));
+                newArgs.push(Vector4.fromObject(arg));
                 continue;
             }
             case ClassTypes.Ped: {