@nativewrappers/fivem 0.0.1

package/lib/client/utils/Vector2.js

@@ -0,0 +1,106 @@
+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 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;
+    }
+    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/client/utils/Vector3.d.ts

@@ -0,0 +1,69 @@
+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;
+    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 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);
+    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/client/utils/Vector3.js

@@ -0,0 +1,140 @@
+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 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;
+    }
+    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/client/utils/Vector4.d.ts

@@ -0,0 +1,62 @@
+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;
+    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 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);
+    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/client/utils/Vector4.js

@@ -0,0 +1,124 @@
+// 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 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;
+    }
+    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/client/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/client/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/client/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/client/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/client/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/client/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/client/utils/index.d.ts

@@ -0,0 +1,10 @@
+export { String } from './String';
+export { LiteEvent } from './LiteEvent';
+export { PointF } from './PointF';
+export { Crypto } from './Crypto';
+export { Point } from './Point';
+export { Size } from './Size';
+export { Color } from './Color';
+export { Vector2, Vector3, Vector4, Maths, Quaternion, Delay, enumValues, getStringFromUInt8Array, getUInt32FromUint8Array, } from '@common/utils/index';
+export declare const Wait: (milliseconds: number) => Promise<void>;
+export * from './Animations';

package/lib/client/utils/index.js

@@ -0,0 +1,10 @@
+export { String } from './String';
+export { LiteEvent } from './LiteEvent';
+export { PointF } from './PointF';
+export { Crypto } from './Crypto';
+export { Point } from './Point';
+export { Size } from './Size';
+export { Color } from './Color';
+export { Vector2, Vector3, Vector4, Maths, Quaternion, Delay, enumValues, getStringFromUInt8Array, getUInt32FromUint8Array, } from '@common/utils/index';
+export const Wait = (milliseconds) => new Promise(resolve => setTimeout(resolve, milliseconds));
+export * from './Animations';

package/lib/client/weapon/DlcWeaponData.d.ts

@@ -0,0 +1,43 @@
+import { WeaponHash } from '../hashes';
+/**
+ * DlcWeaponData
+ * refer1: https://github.com/citizenfx/fivem/blob/master/code/client/clrcore/External/DlcWeaponStructs.cs#L10
+ * refer2: https://docs.fivem.net/natives/?_0xBF0FD6E56C964FCB
+ *
+ * int emptyCheck; //use DLC1::_IS_DLC_DATA_EMPTY on this
+ * int padding1;
+ * int weaponHash;
+ * int padding2;
+ * int unk;
+ * int padding3;
+ * int weaponCost;
+ * int padding4;
+ * int ammoCost;
+ * int padding5;
+ * int ammoType;
+ * int padding6;
+ * int defaultClipSize;
+ * int padding7;
+ * char nameLabel[64];
+ * char descLabel[64];
+ * char desc2Label[64]; // usually "the" + name
+ * char upperCaseNameLabel[64];
+ *
+ */
+export interface DlcWeaponData {
+    validCheck: number;
+    weaponHash: number;
+    unk: number;
+    weaponCost: number;
+    ammoCost: number;
+    ammoType: number;
+    defaultClipSize: number;
+    name: string;
+    desc: string;
+    simpleDesc: string;
+    upperCaseName: string;
+}
+/**
+ * DlcWeaponData - Mapping of WeaponHash -> DlcWeaponData
+ */
+export declare const DlcWeaponData: Map<WeaponHash, DlcWeaponData>;

package/lib/client/weapon/DlcWeaponData.js

@@ -0,0 +1,44 @@
+import { getUInt32FromUint8Array } from '../utils';
+import { getStringFromUInt8Array } from '../utils';
+/**
+ * DlcWeaponData - Mapping of WeaponHash -> DlcWeaponData
+ */
+export const DlcWeaponData = new Map();
+/**
+ * Initialize DlcWeaponData, avoid calling expansive native repeatedly
+ *
+ */
+function initializeOnce() {
+    let isInitialized = false;
+    return function () {
+        if (isInitialized || IsDuplicityVersion()) {
+            return;
+        }
+        // magic number based on struct DlcWeaponData
+        const intLength = 4;
+        const strLength = 64;
+        const weaponCount = GetNumDlcWeapons();
+        for (let i = 0; i < weaponCount; i++) {
+            const buffer = new Uint8Array(14 * intLength + 4 * strLength);
+            // https://docs.fivem.net/natives/?_0x79923CD21BECE14E
+            Citizen.invokeNative('0x79923CD21BECE14E', i, buffer, Citizen.returnResultAnyway());
+            // noinspection PointlessArithmeticExpressionJS
+            const dlcWeaponData = {
+                validCheck: getUInt32FromUint8Array(buffer, 0 * intLength, 1 * intLength),
+                weaponHash: getUInt32FromUint8Array(buffer, 2 * intLength, 3 * intLength),
+                unk: getUInt32FromUint8Array(buffer, 4 * intLength, 5 * intLength),
+                weaponCost: getUInt32FromUint8Array(buffer, 6 * intLength, 7 * intLength),
+                ammoCost: getUInt32FromUint8Array(buffer, 8 * intLength, 9 * intLength),
+                ammoType: getUInt32FromUint8Array(buffer, 10 * intLength, 11 * intLength),
+                defaultClipSize: getUInt32FromUint8Array(buffer, 12 * intLength, 13 * intLength),
+                name: getStringFromUInt8Array(buffer, 14 * intLength, 14 * intLength + strLength),
+                desc: getStringFromUInt8Array(buffer, 14 * intLength + strLength, 14 * intLength + 2 * strLength),
+                simpleDesc: getStringFromUInt8Array(buffer, 14 * intLength + 2 * strLength, 14 * intLength + 3 * strLength),
+                upperCaseName: getStringFromUInt8Array(buffer, 14 * intLength + 3 * strLength, 14 * intLength + 4 * strLength),
+            };
+            DlcWeaponData.set(dlcWeaponData.weaponHash, dlcWeaponData);
+        }
+        isInitialized = true;
+    };
+}
+initializeOnce()();