@nativewrappers/fivem 0.0.1

package/lib/common/utils/Vector2.js

@@ -0,0 +1,113 @@
+export class Vector2 {
+    static create(v1) {
+        if (typeof v1 === 'number')
+            return new Vector2(v1, v1);
+        return new Vector2(v1.x, v1.y);
+    }
+    /**
+     * Creates a vector from an array of numbers
+     * @param primitive An array of numbers (usually returned by a native)
+     * ```
+     */
+    static fromArray(primitive) {
+        return new Vector2(primitive[0], primitive[1]);
+    }
+    /**
+     * Creates an array of vectors from an array number arrays
+     * @param primitives A multi-dimensional array of number arrays
+     * ```
+     */
+    static fromArrays(primitives) {
+        return primitives.map(prim => new Vector2(prim[0], prim[1]));
+    }
+    static fromBuffer({ buffer }) {
+        return new Vector2(buffer.readFloatLE(0), buffer.readFloatLE(4));
+    }
+    static clone(v1) {
+        return Vector2.create(v1);
+    }
+    static add(v1, v2) {
+        if (typeof v2 === 'number')
+            return new Vector2(v1.x + v2, v1.y + v2);
+        return new Vector2(v1.x + v2.x, v1.y + v2.y);
+    }
+    static subtract(v1, v2) {
+        if (typeof v2 === 'number')
+            return new Vector2(v1.x - v2, v1.y - v2);
+        return new Vector2(v1.x - v2.x, v1.y - v2.y);
+    }
+    static multiply(v1, v2) {
+        if (typeof v2 === 'number')
+            return new Vector2(v1.x * v2, v1.y * v2);
+        return new Vector2(v1.x * v2.x, v1.y * v2.y);
+    }
+    static divide(v1, v2) {
+        if (typeof v2 === 'number')
+            return new Vector2(v1.x / v2, v1.y / v2);
+        return new Vector2(v1.x / v2.x, v1.y / v2.y);
+    }
+    static dotProduct(v1, v2) {
+        return v1.x * v2.x + v1.y * v2.y;
+    }
+    static normalize(v) {
+        return Vector2.divide(v, v.Length);
+    }
+    constructor(x, y) {
+        this.x = x;
+        this.y = y;
+        this.type = 'vec2';
+    }
+    toString() {
+        return `${this.type}(${this.x}, ${this.y})`;
+    }
+    clone() {
+        return new Vector2(this.x, this.y);
+    }
+    /**
+     * The product of the Euclidean magnitudes of this and another Vector2.
+     *
+     * @param v Vector2 to find Euclidean magnitude between.
+     * @returns Euclidean magnitude with another vector.
+     */
+    distanceSquared(v) {
+        const w = this.subtract(v);
+        return Vector2.dotProduct(w, w);
+    }
+    /**
+     * The distance between two Vectors.
+     *
+     * @param v Vector2 to find distance between.
+     * @returns Distance between this and another vector.
+     */
+    distance(v) {
+        return Math.sqrt(this.distanceSquared(v));
+    }
+    get normalize() {
+        return Vector2.normalize(this);
+    }
+    dotProduct(v) {
+        return Vector2.dotProduct(this, v);
+    }
+    add(v) {
+        return Vector2.add(this, v);
+    }
+    subtract(v) {
+        return Vector2.subtract(this, v);
+    }
+    multiply(v) {
+        return Vector2.multiply(this, v);
+    }
+    divide(v) {
+        return Vector2.divide(this, v);
+    }
+    toArray() {
+        return [this.x, this.y];
+    }
+    replace(v) {
+        this.x = v.x;
+        this.y = v.y;
+    }
+    get Length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y);
+    }
+}

package/lib/common/utils/Vector3.d.ts

@@ -0,0 +1,73 @@
+import type { MsgpackBuffer } from '@common/types';
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export type Vector = Vector3 | Vec3;
+export declare class Vector3 implements Vec3 {
+    x: number;
+    y: number;
+    z: number;
+    type: string;
+    static readonly Zero: Vector3;
+    static create(v1: Vec3 | number): Vector3;
+    /**
+     * Creates a vector from an array of numbers
+     * @param primitive An array of numbers (usually returned by a native)
+     * @example ```ts
+     * const entityPos = Vector3.fromArray(GetEntityCoords(entity))
+     * ```
+     */
+    static fromArray(primitive: [number, number, number] | number[]): Vector3;
+    /**
+     * Creates an array of vectors from an array number arrays
+     * @param primitives A multi-dimensional array of number arrays
+     * @example ```ts
+     * const [forward, right, up, position] = Vector3.fromArrays(GetEntityMatrix(entity))
+     * ```
+     */
+    static fromArrays(primitives: [number, number, number][] | number[][]): Vector3[];
+    static fromBuffer({ buffer }: MsgpackBuffer): Vector3;
+    static clone(v1: Vec3): Vector3;
+    static add(v1: Vector, v2: Vector | number): Vector3;
+    static addX(vec: Vector, x: number): Vector3;
+    static addY(vec: Vector, y: number): Vector3;
+    static addZ(vec: Vector, z: number): Vector3;
+    static subtract(v1: Vector, v2: Vector | number): Vector3;
+    static multiply(v1: Vector, v2: Vector | number): Vector3;
+    static divide(v1: Vector, v2: Vector | number): Vector3;
+    static dotProduct(v1: Vector, v2: Vector): number;
+    static crossProduct(v1: Vector, v2: Vector): Vector3;
+    static normalize(v: Vector3): Vector3;
+    constructor(x: number, y: number, z: number);
+    toString(): string;
+    clone(): Vector3;
+    /**
+     * The product of the Euclidean magnitudes of this and another Vector3.
+     *
+     * @param v Vector3 to find Euclidean magnitude between.
+     * @returns Euclidean magnitude with another vector.
+     */
+    distanceSquared(v: Vector): number;
+    /**
+     * The distance between two Vectors.
+     *
+     * @param v Vector3 to find distance between.
+     * @returns Distance between this and another vector.
+     */
+    distance(v: Vector): number;
+    get normalize(): Vector3;
+    crossProduct(v: Vector): Vector3;
+    dotProduct(v: Vector): number;
+    add(v: Vector | number): Vector3;
+    addX(x: number): Vector3;
+    addY(y: number): Vector3;
+    addZ(z: number): Vector3;
+    subtract(v: Vector): Vector3;
+    multiply(v: Vector | number): Vector3;
+    divide(v: Vector | number): Vector3;
+    toArray(): [number, number, number];
+    replace(v: Vector): void;
+    get Length(): number;
+}

package/lib/common/utils/Vector3.js

@@ -0,0 +1,147 @@
+export class Vector3 {
+    static create(v1) {
+        if (typeof v1 === 'number')
+            return new Vector3(v1, v1, v1);
+        return new Vector3(v1.x, v1.y, v1.z);
+    }
+    /**
+     * Creates a vector from an array of numbers
+     * @param primitive An array of numbers (usually returned by a native)
+     * @example ```ts
+     * const entityPos = Vector3.fromArray(GetEntityCoords(entity))
+     * ```
+     */
+    static fromArray(primitive) {
+        return new Vector3(primitive[0], primitive[1], primitive[2]);
+    }
+    /**
+     * Creates an array of vectors from an array number arrays
+     * @param primitives A multi-dimensional array of number arrays
+     * @example ```ts
+     * const [forward, right, up, position] = Vector3.fromArrays(GetEntityMatrix(entity))
+     * ```
+     */
+    static fromArrays(primitives) {
+        return primitives.map(prim => new Vector3(prim[0], prim[1], prim[2]));
+    }
+    static fromBuffer({ buffer }) {
+        return new Vector3(buffer.readFloatLE(0), buffer.readFloatLE(4), buffer.readFloatLE(8));
+    }
+    static clone(v1) {
+        return Vector3.create(v1);
+    }
+    static add(v1, v2) {
+        if (typeof v2 === 'number')
+            return new Vector3(v1.x + v2, v1.y + v2, v1.z + v2);
+        return new Vector3(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
+    }
+    static addX(vec, x) {
+        return new Vector3(vec.x + x, vec.y, vec.z);
+    }
+    static addY(vec, y) {
+        return new Vector3(vec.x, vec.y + y, vec.z);
+    }
+    static addZ(vec, z) {
+        return new Vector3(vec.x, vec.y, vec.z + z);
+    }
+    static subtract(v1, v2) {
+        if (typeof v2 === 'number')
+            return new Vector3(v1.x - v2, v1.y - v2, v1.z - v2);
+        return new Vector3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
+    }
+    static multiply(v1, v2) {
+        if (typeof v2 === 'number')
+            return new Vector3(v1.x * v2, v1.y * v2, v1.z * v2);
+        return new Vector3(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z);
+    }
+    static divide(v1, v2) {
+        if (typeof v2 === 'number')
+            return new Vector3(v1.x / v2, v1.y / v2, v1.z / v2);
+        return new Vector3(v1.x / v2.x, v1.y / v2.y, v1.z / v2.z);
+    }
+    static dotProduct(v1, v2) {
+        return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
+    }
+    static crossProduct(v1, v2) {
+        const x = v1.y * v2.z - v1.z * v2.y;
+        const y = v1.z * v2.x - v1.x * v2.z;
+        const z = v1.x * v2.y - v1.y * v2.x;
+        return new Vector3(x, y, z);
+    }
+    static normalize(v) {
+        return Vector3.divide(v, v.Length);
+    }
+    constructor(x, y, z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.type = 'vec3';
+    }
+    toString() {
+        return `${this.type}(${this.x}, ${this.y}, ${this.z})`;
+    }
+    clone() {
+        return new Vector3(this.x, this.y, this.z);
+    }
+    /**
+     * The product of the Euclidean magnitudes of this and another Vector3.
+     *
+     * @param v Vector3 to find Euclidean magnitude between.
+     * @returns Euclidean magnitude with another vector.
+     */
+    distanceSquared(v) {
+        const w = this.subtract(v);
+        return Vector3.dotProduct(w, w);
+    }
+    /**
+     * The distance between two Vectors.
+     *
+     * @param v Vector3 to find distance between.
+     * @returns Distance between this and another vector.
+     */
+    distance(v) {
+        return Math.sqrt(this.distanceSquared(v));
+    }
+    get normalize() {
+        return Vector3.normalize(this);
+    }
+    crossProduct(v) {
+        return Vector3.crossProduct(this, v);
+    }
+    dotProduct(v) {
+        return Vector3.dotProduct(this, v);
+    }
+    add(v) {
+        return Vector3.add(this, v);
+    }
+    addX(x) {
+        return Vector3.addX(this, x);
+    }
+    addY(y) {
+        return Vector3.addY(this, y);
+    }
+    addZ(z) {
+        return Vector3.addZ(this, z);
+    }
+    subtract(v) {
+        return Vector3.subtract(this, v);
+    }
+    multiply(v) {
+        return Vector3.multiply(this, v);
+    }
+    divide(v) {
+        return Vector3.divide(this, v);
+    }
+    toArray() {
+        return [this.x, this.y, this.z];
+    }
+    replace(v) {
+        this.x = v.x;
+        this.y = v.y;
+        this.z = v.z;
+    }
+    get Length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+    }
+}
+Vector3.Zero = new Vector3(0, 0, 0);

package/lib/common/utils/Vector4.d.ts

@@ -0,0 +1,66 @@
+import type { MsgpackBuffer } from '@common/types';
+import { Vector3 } from './Vector3';
+export interface Vec4 {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export type Vector4Type = Vector4 | Vec4;
+export declare class Vector4 implements Vec4 {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    type: string;
+    static create(v1: Vec4 | number): Vector4;
+    /**
+     * Creates a vector from an array of numbers
+     * @param primitive An array of numbers (usually returned by a native)
+     * ```
+     */
+    static fromArray(primitive: [number, number, number, number] | number[]): Vector4;
+    /**
+     * Creates an array of vectors from an array number arrays
+     * @param primitives A multi-dimensional array of number arrays
+     * ```
+     */
+    static fromArrays(primitives: [number, number, number, number][] | number[][]): Vector4[];
+    static fromBuffer({ buffer }: MsgpackBuffer): Vector4;
+    static clone(v1: Vec4): Vector4;
+    static add(v1: Vector4Type, v2: Vector4Type | number): Vector4;
+    static subtract(v1: Vector4Type, v2: Vector4Type | number): Vector4;
+    static multiply(v1: Vector4Type, v2: Vector4Type | number): Vector4;
+    static divide(v1: Vector4Type, v2: Vector4Type | number): Vector4;
+    static dotProduct(v1: Vector4Type, v2: Vector4Type): number;
+    static crossProduct(v1: Vector4Type, v2: Vector4Type): Vector4;
+    static normalize(v: Vector4): Vector4;
+    constructor(x: number, y: number, z: number, w: number);
+    toString(): string;
+    clone(): Vector4;
+    /**
+     * The product of the Euclidean magnitudes of this and another Vector4.
+     *
+     * @param v Vector4 to find Euclidean magnitude between.
+     * @returns Euclidean magnitude with another vector.
+     */
+    distanceSquared(v: Vector4Type): number;
+    /**
+     * The distance between two Vectors.
+     *
+     * @param v Vector4 to find distance between.
+     * @returns Distance between this and another vector.
+     */
+    distance(v: Vector4Type): number;
+    get normalize(): Vector4;
+    crossProduct(v: Vector4Type): Vector4;
+    dotProduct(v: Vector4Type): number;
+    add(v: Vector4Type | number): Vector4;
+    subtract(v: Vector4Type): Vector4;
+    multiply(v: Vector4Type | number): Vector4;
+    divide(v: Vector4Type | number): Vector4;
+    toArray(): [number, number, number, number];
+    toVec3(): Vector3;
+    replace(v: Vector4Type): void;
+    get Length(): number;
+}

package/lib/common/utils/Vector4.js

@@ -0,0 +1,131 @@
+// Source: https://raw.githubusercontent.com/you21979/typescript-vector/master/vector3.ts
+import { Vector3 } from './Vector3';
+export class Vector4 {
+    static create(v1) {
+        if (typeof v1 === 'number')
+            return new Vector4(v1, v1, v1, v1);
+        return new Vector4(v1.x, v1.y, v1.z, v1.w);
+    }
+    /**
+     * Creates a vector from an array of numbers
+     * @param primitive An array of numbers (usually returned by a native)
+     * ```
+     */
+    static fromArray(primitive) {
+        return new Vector4(primitive[0], primitive[1], primitive[2], primitive[3]);
+    }
+    /**
+     * Creates an array of vectors from an array number arrays
+     * @param primitives A multi-dimensional array of number arrays
+     * ```
+     */
+    static fromArrays(primitives) {
+        return primitives.map(prim => new Vector4(prim[0], prim[1], prim[2], prim[3]));
+    }
+    static fromBuffer({ buffer }) {
+        return new Vector4(buffer.readFloatLE(0), buffer.readFloatLE(4), buffer.readFloatLE(8), buffer.readFloatLE(12));
+    }
+    static clone(v1) {
+        return Vector4.create(v1);
+    }
+    static add(v1, v2) {
+        if (typeof v2 === 'number')
+            return new Vector4(v1.x + v2, v1.y + v2, v1.z + v2, v1.w + v2);
+        return new Vector4(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z, v1.w + v2.w);
+    }
+    static subtract(v1, v2) {
+        if (typeof v2 === 'number')
+            return new Vector4(v1.x - v2, v1.y - v2, v1.z - v2, v1.w - v2);
+        return new Vector4(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z, v1.w - v2.w);
+    }
+    static multiply(v1, v2) {
+        if (typeof v2 === 'number')
+            return new Vector4(v1.x * v2, v1.y * v2, v1.z * v2, v1.w * v2);
+        return new Vector4(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z, v1.w * v2.w);
+    }
+    static divide(v1, v2) {
+        if (typeof v2 === 'number')
+            return new Vector4(v1.x / v2, v1.y / v2, v1.z / v2, v1.w / v2);
+        return new Vector4(v1.x / v2.x, v1.y / v2.y, v1.z / v2.z, v1.w / v2.w);
+    }
+    static dotProduct(v1, v2) {
+        return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z + v1.w * v2.w;
+    }
+    static crossProduct(v1, v2) {
+        const x = v1.y * v2.z - v1.z * v2.y;
+        const y = v1.z * v2.x - v1.x * v2.z;
+        const z = v1.x * v2.y - v1.y * v2.x;
+        return new Vector4(x, y, z, v1.w);
+    }
+    static normalize(v) {
+        return Vector4.divide(v, v.Length);
+    }
+    constructor(x, y, z, w) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
+        this.type = 'vec4';
+    }
+    toString() {
+        return `${this.type}(${this.x}, ${this.y}, ${this.z}, ${this.w})`;
+    }
+    clone() {
+        return new Vector4(this.x, this.y, this.z, this.w);
+    }
+    /**
+     * The product of the Euclidean magnitudes of this and another Vector4.
+     *
+     * @param v Vector4 to find Euclidean magnitude between.
+     * @returns Euclidean magnitude with another vector.
+     */
+    distanceSquared(v) {
+        const w = this.subtract(v);
+        return Vector4.dotProduct(w, w);
+    }
+    /**
+     * The distance between two Vectors.
+     *
+     * @param v Vector4 to find distance between.
+     * @returns Distance between this and another vector.
+     */
+    distance(v) {
+        return Math.sqrt(this.distanceSquared(v));
+    }
+    get normalize() {
+        return Vector4.normalize(this);
+    }
+    crossProduct(v) {
+        return Vector4.crossProduct(this, v);
+    }
+    dotProduct(v) {
+        return Vector4.dotProduct(this, v);
+    }
+    add(v) {
+        return Vector4.add(this, v);
+    }
+    subtract(v) {
+        return Vector4.subtract(this, v);
+    }
+    multiply(v) {
+        return Vector4.multiply(this, v);
+    }
+    divide(v) {
+        return Vector4.divide(this, v);
+    }
+    toArray() {
+        return [this.x, this.y, this.z, this.w];
+    }
+    toVec3() {
+        return new Vector3(this.x, this.y, this.z);
+    }
+    replace(v) {
+        this.x = v.x;
+        this.y = v.y;
+        this.z = v.z;
+        this.w = v.w;
+    }
+    get Length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
+    }
+}

package/lib/common/utils/cleanPlayerName.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Cleans up a player name and returns one version to be displayed, and one pure version to be used for fuzzy matching.
+ * In case the name has no ascii characters, the pure name will be "empty name".
+ * NOTE: this is not perfect, but took me two hours to arrive to this point.
+ */
+export declare const cleanPlayerName: (original: string) => string;

package/lib/common/utils/cleanPlayerName.js

@@ -0,0 +1,27 @@
+/* eslint-disable */
+// Spooky shit happens in here, don't let eslint get angry
+// Shamlessly ripped from txAdmin, MIT license
+/**
+ * Cleans up a player name and returns one version to be displayed, and one pure version to be used for fuzzy matching.
+ * In case the name has no ascii characters, the pure name will be "empty name".
+ * NOTE: this is not perfect, but took me two hours to arrive to this point.
+ */
+export const cleanPlayerName = (original) => {
+    // \u0000-\u001F > C0 controls
+    // \u007F-\u009F > delete + C1 controls
+    // \u200B-\u200D\uFEFF > zero width spaces
+    // \u200E > RTL mark
+    // \uA9C1-\uA9C5 > javanese text adornation (oversized)
+    // \u239B-\u23AD > Miscellaneous Technical — Bracket pieces items (oversized)
+    let displayName = original
+        .substring(0, 75) //lua should have truncated it first, but double checking
+        .replace(/[\u0000-\u001F\u007F-\u009F\u200B-\u200D\uFEFF\u200E\uA9C1-\uA9C5\u239B-\u23AD]/g, '')
+        .replace(/~(HUD_\S+|HC_\S+|[a-z]|[a1]_\d+|bold|italic|ws|wanted_star|nrt|EX_R\*|BLIP_\S+|ACCEPT|CANCEL|PAD_\S+|INPUT_\S+|INPUTGROUP_\S+)~/gi, '') // https://docs.fivem.net/docs/game-references/text-formatting/
+        .replace(/\^\d/gi, '') //console color codes
+        .replace(/\p{Mark}{2,}/gu, '') //2+ consecutive marks (zalgo text)
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!displayName.length)
+        displayName = 'empty name';
+    return displayName;
+};

package/lib/common/utils/enumValues.d.ts

@@ -0,0 +1,12 @@
+/**
+ * EnumValues - iterate over enum values
+ * Just copy&paste from https://github.com/microsoft/TypeScript/issues/4753#issuecomment-694557208
+ *
+ * @param enumObj
+ */
+export declare function enumValues<T extends string>(enumObj: {
+    [key: string]: T;
+}): IterableIterator<T>;
+export declare function enumValues<T extends string | number>(enumObj: {
+    [key: string]: T;
+}): IterableIterator<Exclude<T, string>>;

package/lib/common/utils/enumValues.js

@@ -0,0 +1,14 @@
+export function* enumValues(enumObj) {
+    let isStringEnum = true;
+    for (const property in enumObj) {
+        if (typeof enumObj[property] === 'number') {
+            isStringEnum = false;
+            break;
+        }
+    }
+    for (const property in enumObj) {
+        if (isStringEnum || typeof enumObj[property] === 'number') {
+            yield enumObj[property];
+        }
+    }
+}

package/lib/common/utils/getStringFromUInt8Array.d.ts

@@ -0,0 +1,8 @@
+/**
+ * get string from uint8 array
+ *
+ * @param buffer - Uint8Array
+ * @param start - The beginning of the specified portion of the array
+ * @param end - The end of the specified portion of the array
+ */
+export declare const getStringFromUInt8Array: (buffer: Uint8Array, start: number, end: number) => string;

package/lib/common/utils/getStringFromUInt8Array.js

@@ -0,0 +1,10 @@
+/**
+ * get string from uint8 array
+ *
+ * @param buffer - Uint8Array
+ * @param start - The beginning of the specified portion of the array
+ * @param end - The end of the specified portion of the array
+ */
+export const getStringFromUInt8Array = (buffer, start, end) => String.fromCharCode(...buffer.slice(start, end))
+    // eslint-disable-next-line no-control-regex
+    .replace(/\u0000/g, '');

package/lib/common/utils/getUInt32FromUint8Array.d.ts

@@ -0,0 +1,8 @@
+/**
+ * get uint32 from uint8 array
+ *
+ * @param buffer - Uint8Array
+ * @param start - The beginning of the specified portion of the array
+ * @param end - The end of the specified portion of the array
+ */
+export declare const getUInt32FromUint8Array: (buffer: Uint8Array, start: number, end: number) => number;

package/lib/common/utils/getUInt32FromUint8Array.js

@@ -0,0 +1,8 @@
+/**
+ * get uint32 from uint8 array
+ *
+ * @param buffer - Uint8Array
+ * @param start - The beginning of the specified portion of the array
+ * @param end - The end of the specified portion of the array
+ */
+export const getUInt32FromUint8Array = (buffer, start, end) => new Uint32Array(buffer.slice(start, end).buffer)[0];

package/lib/common/utils/index.d.ts

@@ -0,0 +1,12 @@
+export { Vector2 } from './Vector2';
+export { Vector3 } from './Vector3';
+export { Vector4 } from './Vector4';
+export { PointF } from './PointF';
+export { Maths } from './Maths';
+export { Quaternion } from './Quaternion';
+export { Color } from './Color';
+export { cleanPlayerName } from './cleanPlayerName';
+export declare const Delay: (milliseconds: number) => Promise<void>;
+export { enumValues } from './enumValues';
+export { getStringFromUInt8Array } from './getStringFromUInt8Array';
+export { getUInt32FromUint8Array } from './getUInt32FromUint8Array';

package/lib/common/utils/index.js

@@ -0,0 +1,12 @@
+export { Vector2 } from './Vector2';
+export { Vector3 } from './Vector3';
+export { Vector4 } from './Vector4';
+export { PointF } from './PointF';
+export { Maths } from './Maths';
+export { Quaternion } from './Quaternion';
+export { Color } from './Color';
+export { cleanPlayerName } from './cleanPlayerName';
+export const Delay = (milliseconds) => new Promise(resolve => setTimeout(resolve, milliseconds));
+export { enumValues } from './enumValues';
+export { getStringFromUInt8Array } from './getStringFromUInt8Array';
+export { getUInt32FromUint8Array } from './getUInt32FromUint8Array';