pma-locals 1.0.0

package/dist/client.js

@@ -0,0 +1,2903 @@
+(() => {
+  var __defProp = Object.defineProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/common/utils/Delay.js
+  var __defProp2 = Object.defineProperty;
+  var __name2 = /* @__PURE__ */ __name((target, value) => __defProp2(target, "name", { value, configurable: true }), "__name");
+  var Delay = /* @__PURE__ */ __name2((ms) => new Promise((res) => setTimeout(res, ms)), "Delay");
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/common/utils/ClassTypes.js
+  var ClassTypes = /* @__PURE__ */ ((ClassTypes2) => {
+    ClassTypes2[ClassTypes2["Ped"] = 0] = "Ped";
+    ClassTypes2[ClassTypes2["Prop"] = 1] = "Prop";
+    ClassTypes2[ClassTypes2["Vehicle"] = 2] = "Vehicle";
+    ClassTypes2[ClassTypes2["Entity"] = 3] = "Entity";
+    ClassTypes2[ClassTypes2["Player"] = 4] = "Player";
+    ClassTypes2[ClassTypes2["Vector2"] = 5] = "Vector2";
+    ClassTypes2[ClassTypes2["Vector3"] = 6] = "Vector3";
+    ClassTypes2[ClassTypes2["Vector4"] = 7] = "Vector4";
+    ClassTypes2[ClassTypes2["Quanterion"] = 8] = "Quanterion";
+    return ClassTypes2;
+  })(ClassTypes || {});
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/common/utils/Vector.js
+  var __defProp3 = Object.defineProperty;
+  var __name3 = /* @__PURE__ */ __name((target, value) => __defProp3(target, "name", { value, configurable: true }), "__name");
+  var EXT_VECTOR2 = 20;
+  var EXT_VECTOR3 = 21;
+  var EXT_VECTOR4 = 22;
+  var size = /* @__PURE__ */ Symbol("size");
+  var _a;
+  var _Vector = class _Vector {
+    /**
+     * Constructs a new 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).
+     * @param w The w-component of the vector (optional).
+     */
+    constructor(x, y = x, z, w) {
+      __publicField(this, "type");
+      __publicField(this, _a, 2);
+      __publicField(this, "x", 0);
+      __publicField(this, "y", 0);
+      __publicField(this, "z");
+      __publicField(this, "w");
+      for (let i = 0; i < arguments.length; i++) {
+        if (typeof arguments[i] !== "number") {
+          throw new TypeError(
+            `${this.constructor.name} argument at index ${i} must be a number, but got ${typeof arguments[i]}`
+          );
+        }
+      }
+      this.x = x;
+      this.y = y;
+    }
+    static create(x, y = x, z, w) {
+      if (typeof x === "object") ({ x, y, z, w } = x);
+      const size2 = this instanceof _Vector && this.size || [x, y, z, w].filter((arg) => arg !== void 0).length;
+      switch (size2) {
+        case 1:
+        case 2:
+          return new Vector2(x, y);
+        case 3:
+          return new Vector3(x, y, z);
+        case 4:
+          return new Vector4(x, y, z, w);
+        default:
+          throw new Error(`Cannot instantiate Vector with size of ${size2}.`);
+      }
+    }
+    /**
+     * 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);
+    }
+    /**
+     * Creates a vector from binary data in a MsgpackBuffer.
+     * @param msgpackBuffer The buffer containing binary data.
+     * @returns A new vector instance.
+     */
+    static fromBuffer({ buffer, type }) {
+      if (type !== EXT_VECTOR2 && type !== EXT_VECTOR3 && type !== EXT_VECTOR4)
+        throw new Error("Buffer type is not a valid Vector.");
+      const arr = new Array(buffer.length / 4);
+      for (let i = 0; i < arr.length; i++) arr[i] = Number(buffer.readFloatLE(i * 4).toPrecision(7));
+      return this.fromArray(arr);
+    }
+    /**
+     * 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";
+      x = operator(x, isNumber ? b : b.x ?? 0);
+      y = operator(y, isNumber ? b : b.y ?? 0);
+      if (z !== void 0) z = operator(z, isNumber ? b : b.z ?? 0);
+      if (w !== void 0) 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) {
+      return this.create(obj.x + x, obj.y, obj.z, obj.w);
+    }
+    /**
+     * 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) {
+      return this.create(obj.x, obj.y + y, obj.z, obj.w);
+    }
+    /**
+     * 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) {
+      return this.create(obj.x, obj.y, obj.z + z, obj.w);
+    }
+    /**
+     * 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) {
+      return this.create(obj.x, obj.y, obj.z, obj.w + w);
+    }
+    /**
+     * 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);
+    }
+    /**
+     * Performs an operation between a vector and either another vector or scalar value converting the vector into absolute values.
+     * @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 operateAbsolute(a, b, operator) {
+      let { x, y, z, w } = a;
+      const isNumber = typeof b === "number";
+      x = operator(Math.abs(x), isNumber ? b : Math.abs(b.x ?? 0));
+      y = operator(Math.abs(y), isNumber ? b : Math.abs(b.y ?? 0));
+      if (z !== void 0) z = operator(Math.abs(z), isNumber ? b : Math.abs(b.z ?? 0));
+      if (w !== void 0) w = operator(Math.abs(w), isNumber ? b : Math.abs(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 addAbsolute(a, b) {
+      return this.operateAbsolute(a, b, (x, y) => x + y);
+    }
+    /**
+     * 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 subtractAbsolute(a, b) {
+      return this.operateAbsolute(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 multiplyAbsolute(a, b) {
+      return this.operateAbsolute(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 divideAbsolute(a, b) {
+      return this.operateAbsolute(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"]) {
+        const x = a[key];
+        const y = b[key];
+        if (!!x && !!y) result += x * y;
+        else if (x || y) throw new Error("Vectors must have the same dimensions.");
+      }
+      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 === void 0 || ay === void 0 || az === void 0 || bx === void 0 || by === void 0 || bz === void 0)
+        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 instanceof _Vector ? a.Length : this.Length(a);
+      return this.divide(a, length);
+    }
+    /**
+     * Creates a vector from an array of numbers.
+     * @param primitive An array of numbers (usually returned by a native).
+     */
+    static fromArray(primitive) {
+      const [x, y, z, w] = primitive;
+      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);
+      if ("buffer" in primitive) return this.fromBuffer(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
+     * @param primitives A multi-dimensional array of number arrays
+     */
+    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"]) {
+        if (key in obj) {
+          const value = obj[key];
+          sum += value * value;
+        }
+      }
+      return Math.sqrt(sum);
+    }
+    *[(_a = size, Symbol.iterator)]() {
+      yield this.x;
+      yield this.y;
+      if (this.z !== void 0) yield this.z;
+      if (this.w !== void 0) yield this.w;
+    }
+    get size() {
+      return this[size];
+    }
+    toString() {
+      return `vector${this.size}(${this.toArray().join(", ")})`;
+    }
+    /**
+     * @see Vector.clone
+     */
+    clone() {
+      return _Vector.clone(this);
+    }
+    /**
+     * The product of the Euclidean magnitudes of this and another Vector.
+     *
+     * @param v Vector to find Euclidean magnitude between.
+     * @returns Euclidean magnitude with another vector.
+     */
+    distanceSquared(v) {
+      const w = this.subtract(v);
+      return _Vector.dotProduct(w, w);
+    }
+    /**
+     * The distance between two Vectors.
+     *
+     * @param v Vector to find distance between.
+     * @returns Distance between this and another vector.
+     */
+    distance(v) {
+      return Math.sqrt(this.distanceSquared(v));
+    }
+    /**
+     * @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(y) {
+      return _Vector.addY(this, y);
+    }
+    /**
+     * @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);
+    }
+    /**
+     * @see Vector.addAbsolute
+     */
+    addAbsolute(v) {
+      return _Vector.addAbsolute(this, v);
+    }
+    /**
+     * @see Vector.subtractAbsolute
+     */
+    subtractAbsolute(v) {
+      return _Vector.subtractAbsolute(this, v);
+    }
+    /**
+     * @see Vector.multiply
+     */
+    multiplyAbsolute(v) {
+      return _Vector.multiplyAbsolute(this, v);
+    }
+    /**
+     * @see Vector.divide
+     */
+    divideAbsolute(v) {
+      return _Vector.divideAbsolute(this, v);
+    }
+    /**
+     * Converts the vector to an array of its components.
+     */
+    toArray() {
+      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) {
+      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 (const value of this) sum += value * value;
+      return Math.sqrt(sum);
+    }
+    swizzle(components) {
+      if (!/^[xyzw]+$/.test(components)) throw new Error(`Invalid key in swizzle components (${components}).`);
+      const arr = components.split("").map((char) => this[char] ?? 0);
+      return _Vector.create(...arr);
+    }
+  };
+  __name(_Vector, "Vector");
+  __name3(_Vector, "Vector");
+  var Vector = _Vector;
+  var _a2, _b;
+  var _Vector2 = class _Vector2 extends (_b = Vector, _a2 = size, _b) {
+    /**
+     * 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(x, y);
+      // DO NOT USE, ONLY EXPOSED BECAUSE TS IS TRASH, THIS TYPE IS NOT GUARANTEED
+      // TO EXIST, CHANGING IT WILL BREAK STUFF
+      __publicField(this, "type", ClassTypes.Vector2);
+      __publicField(this, _a2, 2);
+    }
+    /**
+     * 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).
+     * @returns A new vector instance.
+     */
+    static create(x, y = x) {
+      if (typeof x === "object") ({ x, y } = x);
+      return new this(x, y);
+    }
+  };
+  __name(_Vector2, "Vector2");
+  __name3(_Vector2, "Vector2");
+  __publicField(_Vector2, "Zero", new _Vector2(0, 0));
+  var Vector2 = _Vector2;
+  var _a3, _b2;
+  var _Vector3 = class _Vector3 extends (_b2 = Vector, _a3 = size, _b2) {
+    /**
+     * 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(x, y, z);
+      // DO NOT USE, ONLY EXPOSED BECAUSE TS IS TRASH, THIS TYPE IS NOT GUARANTEED
+      // TO EXIST, CHANGING IT WILL BREAK STUFF
+      __publicField(this, "type", ClassTypes.Vector3);
+      __publicField(this, _a3, 3);
+      __publicField(this, "z", 0);
+      this.z = z;
+    }
+    /**
+     * 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).
+     * @returns A new vector instance.
+     */
+    static create(x, y = x, z = y) {
+      if (typeof x === "object") ({ x, y, z = y } = x);
+      return new this(x, y, z);
+    }
+    /**
+     * @see Vector.addZ
+     */
+    addZ(z) {
+      return Vector.addZ(this, z);
+    }
+    /**
+     * @see Vector.crossProduct
+     */
+    crossProduct(v) {
+      return Vector.crossProduct(this, v);
+    }
+    /**
+     * @returns the x and y values as Vec2
+     */
+    toVec2() {
+      return new Vector2(this.x, this.y);
+    }
+  };
+  __name(_Vector3, "Vector3");
+  __name3(_Vector3, "Vector3");
+  __publicField(_Vector3, "Zero", new _Vector3(0, 0, 0));
+  __publicField(_Vector3, "UnitX", new _Vector3(1, 0, 0));
+  __publicField(_Vector3, "UnitY", new _Vector3(0, 1, 0));
+  __publicField(_Vector3, "UnitZ", new _Vector3(0, 0, 1));
+  __publicField(_Vector3, "One", new _Vector3(1, 1, 1));
+  __publicField(_Vector3, "Up", new _Vector3(0, 0, 1));
+  __publicField(_Vector3, "Down", new _Vector3(0, 0, -1));
+  __publicField(_Vector3, "Left", new _Vector3(-1, 0, 0));
+  __publicField(_Vector3, "Right", new _Vector3(1, 0, 0));
+  __publicField(_Vector3, "ForwardRH", new _Vector3(0, 1, 0));
+  __publicField(_Vector3, "ForwardLH", new _Vector3(0, -1, 0));
+  __publicField(_Vector3, "BackwardRH", new _Vector3(0, -1, 0));
+  __publicField(_Vector3, "BackwardLH", new _Vector3(0, 1, 0));
+  __publicField(_Vector3, "Backward", _Vector3.BackwardRH);
+  var Vector3 = _Vector3;
+  var _a4, _b3;
+  var _Vector4 = class _Vector4 extends (_b3 = Vector, _a4 = size, _b3) {
+    /**
+     * 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(x, y, z, w);
+      // DO NOT USE, ONLY EXPOSED BECAUSE TS IS TRASH, THIS TYPE IS NOT GUARANTEED
+      // TO EXIST, CHANGING IT WILL BREAK STUFF
+      __publicField(this, "type", ClassTypes.Vector4);
+      __publicField(this, _a4, 4);
+      __publicField(this, "z", 0);
+      __publicField(this, "w", 0);
+      this.z = z;
+      this.w = w;
+    }
+    /**
+     * 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 = x, z = y, w = z) {
+      if (typeof x === "object") ({ x, y, z = y, w = z } = x);
+      return new this(x, y, z, 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);
+    }
+    /**
+     * @returns the x and y values as Vec2
+     */
+    toVec2() {
+      return new Vector2(this.x, this.y);
+    }
+    /**
+     * @returns the x and y values as Vec3
+     */
+    toVec3() {
+      return new Vector3(this.x, this.y, this.z);
+    }
+  };
+  __name(_Vector4, "Vector4");
+  __name3(_Vector4, "Vector4");
+  __publicField(_Vector4, "Zero", new _Vector4(0, 0, 0, 0));
+  var Vector4 = _Vector4;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/Model.js
+  var __defProp4 = Object.defineProperty;
+  var __name4 = /* @__PURE__ */ __name((target, value) => __defProp4(target, "name", { value, configurable: true }), "__name");
+  var _Model = class _Model {
+    /**
+     * Creates a model object based on the hash key or model string.
+     *
+     * @param hash A number or string of the model's hash. Example: "mp_m_freemode_01"
+     */
+    constructor(hash) {
+      /**
+       * Hash of this model.
+       */
+      __publicField(this, "hash");
+      __publicField(this, "requestCount", 0);
+      if (typeof hash === "string") {
+        this.hash = GetHashKey(hash);
+      } else {
+        this.hash = hash;
+      }
+    }
+    /**
+     * Returns the amount of times this model has been requested from the client, useful for finding situations where the client fails to release the ref
+     */
+    get RequestCount() {
+      return this.requestCount;
+    }
+    [Symbol.dispose]() {
+      if (this.requestCount > 0) {
+        this.markAsNoLongerNeeded();
+      }
+    }
+    /**
+     * Gets the hash of the model.
+     *
+     * @returns The hash key.
+     */
+    get Hash() {
+      return this.hash;
+    }
+    /**
+     * Gets if the model is valid or not.
+     *
+     * @returns Whether this model is valid.
+     */
+    get IsValid() {
+      return IsModelValid(this.hash);
+    }
+    /**
+     * Gets if the model is in cd image or not.
+     *
+     * @returns Whether this model is in cd image.
+     */
+    get IsInCdImage() {
+      return IsModelInCdimage(this.hash);
+    }
+    /**
+     * Gets if the model is loaded or not.
+     *
+     * @returns Whether this model is loaded.
+     */
+    get IsLoaded() {
+      if (this.IsWeapon) {
+        return Citizen.invokeNative("0xFF07CF465F48B830", this.hash);
+      }
+      return HasModelLoaded(this.hash);
+    }
+    /**
+     * Gets if the model collision is loaded or not.
+     *
+     * @returns Whether this model collision is loaded.
+     */
+    get IsCollisionLoaded() {
+      return HasCollisionForModelLoaded(this.hash);
+    }
+    /**
+     * Gets if the model is a boat or not.
+     *
+     * @returns Whether this model is a boat.
+     */
+    get IsBoat() {
+      return IsThisModelABoat(this.hash);
+    }
+    /**
+     * Gets if the model is a Ped or not.
+     *
+     * @returns Whether this model is a Ped.
+     */
+    get IsPed() {
+      return IsModelAPed(this.hash);
+    }
+    /**
+     * Gets if the model is a prop or not.
+     *
+     * @returns Whether this model is a prop.
+     */
+    get IsProp() {
+      return this.IsValid && !this.IsPed && !this.IsVehicle && !this.IsWeapon;
+    }
+    /**
+     * Gets if the model is a train or not.
+     *
+     * @returns Whether this model is a train.
+     */
+    get IsTrain() {
+      return IsThisModelATrain(this.hash);
+    }
+    /**
+     * Gets if the model is a Vehicle or not.
+     *
+     * @returns Whether this model is a Vehicle.
+     */
+    get IsVehicle() {
+      return IsModelAVehicle(this.hash);
+    }
+    get IsWeapon() {
+      return IsWeaponValid(this.hash);
+    }
+    /**
+     * Gets the model dimensions.
+     *
+     * @returns This model min & max dimensions.
+     */
+    get Dimensions() {
+      const [minArray, maxArray] = GetModelDimensions(this.hash);
+      const min = Vector3.fromArray(minArray);
+      const max = Vector3.fromArray(maxArray);
+      return { min, max };
+    }
+    // TODO: Metaped stuff too at some point
+    requestModel() {
+      RequestModel(this.hash, false);
+      this.requestCount++;
+    }
+    /**
+     * Request and load the model with a specified timeout. Default timeout is 1000 (recommended).
+     * This function will not automatically set the model as no longer needed when
+     * done.
+     *
+     * @param timeoutMs Maximum allowed time for model to load.
+     */
+    async request(timeoutMs = 1e3) {
+      if (!this.IsInCdImage && !this.IsValid && !this.IsWeapon) {
+        return false;
+      }
+      if (this.IsLoaded) {
+        return true;
+      }
+      this.requestModel();
+      const timeout = GetGameTimer() + timeoutMs;
+      while (!this.IsLoaded && GetGameTimer() < timeout) {
+        await Delay(0);
+      }
+      if (!this.IsLoaded) {
+        this.markAsNoLongerNeeded();
+      }
+      return this.IsLoaded;
+    }
+    /**
+     * Sets the model as no longer needed allowing the game engine to free memory.
+     */
+    markAsNoLongerNeeded() {
+      SetModelAsNoLongerNeeded(this.hash);
+    }
+  };
+  __name(_Model, "Model");
+  __name4(_Model, "Model");
+  var Model = _Model;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/utils/Native.js
+  var __defProp5 = Object.defineProperty;
+  var __name5 = /* @__PURE__ */ __name((target, value) => __defProp5(target, "name", { value, configurable: true }), "__name");
+  var _N = /* @__PURE__ */ __name5((hash, ...args) => {
+    return Citizen.invokeNative(hash, ...args);
+  }, "_N");
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/Attribute.js
+  var __defProp6 = Object.defineProperty;
+  var __name6 = /* @__PURE__ */ __name((target, value) => __defProp6(target, "name", { value, configurable: true }), "__name");
+  var _CoreAttribute = class _CoreAttribute {
+    constructor(ped, attribute) {
+      __publicField(this, "handle");
+      __publicField(this, "attribute");
+      this.handle = ped.Handle;
+      this.attribute = attribute;
+    }
+    /**
+     * This doesn't seem to actually do anything
+     * @todo maybe remove unless theres a valid use case
+     * @param amount
+     * @param makeSound
+     */
+    enableOverpower(amount, makeSound = false) {
+      _N("0x4AF5A4C7B9157D14", this.handle, this.attribute, amount, makeSound);
+    }
+    get Overpowered() {
+      return _N("0x200373A8DF081F22", this.attribute, Citizen.resultAsInteger());
+    }
+    /**
+     * @returns the amount of overpower time left in seconds
+     */
+    get OverpoweredTimeLeft() {
+      return _N("0xB429F58803D285B1", this.handle, this.attribute, Citizen.resultAsInteger());
+    }
+    /**
+     * Returns how full the core is
+     */
+    get CoreValue() {
+      return GetAttributeCoreValue(this.handle, this.attribute);
+    }
+    set CoreValue(amount) {
+      _N("0xC6258F41D86676E0", this.handle, this.attribute, amount);
+    }
+  };
+  __name(_CoreAttribute, "CoreAttribute");
+  __name6(_CoreAttribute, "CoreAttribute");
+  var CoreAttribute = _CoreAttribute;
+  var _PedAttribute = class _PedAttribute {
+    constructor(ped, attribute) {
+      __publicField(this, "handle");
+      __publicField(this, "attribute");
+      this.handle = ped.Handle;
+      this.attribute = attribute;
+    }
+    /**
+     *
+     * @param amount the amount of points to add to the attribute
+     */
+    addPoints(amount) {
+      AddAttributePoints(this.handle, this.attribute, amount);
+    }
+    /**
+     * Disables the overpower state on this attribute, see {@link enableOverpower} on how to enable
+     */
+    disableOverpower() {
+      DisableAttributeOverpower(this.handle, this.attribute);
+    }
+    /**
+     *
+     * @param amount the amount to overpower this attribute by
+     * @param makeSound if activating the overpower should play sound
+     */
+    enableOverpower(amount, makeSound = false) {
+      _N("0xF6A7C08DF2E28B28", this.handle, this.attribute, amount, makeSound);
+    }
+    /**
+     * Gets the amount of attribute points the ped has
+     */
+    get Points() {
+      return GetAttributePoints(this.handle, this.attribute);
+    }
+    set Points(amount) {
+      SetAttributePoints(this.handle, this.attribute, amount);
+    }
+    get Rank() {
+      return GetAttributeRank(this.handle, this.attribute);
+    }
+    set BaseRank(amount) {
+      SetAttributeBaseRank(this.handle, this.attribute, amount);
+    }
+    get BaseRank() {
+      return GetAttributeBaseRank(this.handle, this.attribute);
+    }
+    set BonusRank(amount) {
+      SetAttributeBonusRank(this.handle, this.attribute, amount);
+    }
+    get BonusRank() {
+      return GetAttributeBonusRank(this.handle, this.attribute);
+    }
+    get MaxRank() {
+      return _N("0x704674A0535A471D", this.attribute, Citizen.resultAsInteger());
+    }
+    get Overpowered() {
+      return _N("0x103C2F885ABEB00B", this.attribute, Citizen.resultAsInteger());
+    }
+  };
+  __name(_PedAttribute, "PedAttribute");
+  __name6(_PedAttribute, "PedAttribute");
+  var PedAttribute = _PedAttribute;
+  var _Attributes = class _Attributes {
+    constructor(ped) {
+      __publicField(this, "pedAttributes", []);
+      __publicField(this, "coreAttributes", []);
+      for (let i = 0; i <= 21; i++) {
+        this.pedAttributes[i] = new PedAttribute(ped, i);
+      }
+      for (let i = 0; i <= 2; i++) {
+        this.coreAttributes[i] = new CoreAttribute(ped, i);
+      }
+    }
+    getCore(attribute) {
+      if (attribute > 2) throw new RangeError("The max enum for CoreAttribute is 2");
+      if (attribute < 0) throw new RangeError("The minimum enum for CoreAttribute is 0");
+      return this.coreAttributes[attribute];
+    }
+    get(attribute) {
+      if (attribute > 22) throw new RangeError("The max enum for PedAttribute is 22");
+      if (attribute < 0) throw new RangeError("The minimum enum for PedAttribute is 0");
+      return this.pedAttributes[attribute];
+    }
+    set CoreIcon(status) {
+      if (status > 15) throw new RangeError("The max enum for StatusEffect is 15");
+      if (status < 0) throw new RangeError("The minimum enum for StatusEffect is 0");
+      _N("0xA4D3A1C008F250DF", status);
+    }
+    set PeriodicIcon(status) {
+      if (status > 15) throw new RangeError("The max enum for StatusEffect is 15!");
+      if (status < 0) throw new RangeError("The minimum enum for StatusEffect is 0");
+      _N("0xFB6E111908502871", status);
+    }
+  };
+  __name(_Attributes, "Attributes");
+  __name6(_Attributes, "Attributes");
+  var Attributes = _Attributes;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/common-game/cfx/cfx.js
+  var cfx_default = { Entity, Player };
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/common-game/CommonModel.js
+  var __defProp7 = Object.defineProperty;
+  var __name7 = /* @__PURE__ */ __name((target, value) => __defProp7(target, "name", { value, configurable: true }), "__name");
+  var _CommonModel = class _CommonModel {
+    /**
+     * Creates a model object based on the hash key or model string.
+     *
+     * @param hash A number or string of the model's hash. Example: "mp_m_freemode_01"
+     */
+    constructor(hash) {
+      /**
+       * Hash of this model.
+       */
+      __publicField(this, "hash");
+      __publicField(this, "requestCount", 0);
+      if (typeof hash === "string") {
+        this.hash = GetHashKey(hash);
+      } else {
+        this.hash = hash;
+      }
+    }
+    /**
+     * Returns the amount of times this model has been requested from the client, useful for finding situations where the client fails to release the ref
+     */
+    get RequestCount() {
+      return this.requestCount;
+    }
+    [Symbol.dispose]() {
+      if (this.requestCount > 0) {
+        this.markAsNoLongerNeeded();
+      }
+    }
+    /**
+     * Gets the hash of the model.
+     *
+     * @returns The hash key.
+     */
+    get Hash() {
+      return this.hash;
+    }
+    /**
+     * Gets if the model is valid or not.
+     *
+     * @returns Whether this model is valid.
+     */
+    get IsValid() {
+      return IsModelValid(this.hash);
+    }
+    /**
+     * Gets if the model is in cd image or not.
+     *
+     * @returns Whether this model is in cd image.
+     */
+    get IsInCdImage() {
+      return IsModelInCdimage(this.hash);
+    }
+    /**
+     * Gets if the model is loaded or not.
+     *
+     * @returns Whether this model is loaded.
+     */
+    get IsLoaded() {
+      if (this.IsWeapon) {
+        return Citizen.invokeNative("0xFF07CF465F48B830", this.hash);
+      }
+      return HasModelLoaded(this.hash);
+    }
+    /**
+     * Gets if the model collision is loaded or not.
+     *
+     * @returns Whether this model collision is loaded.
+     */
+    get IsCollisionLoaded() {
+      return HasCollisionForModelLoaded(this.hash);
+    }
+    /**
+     * Gets if the model is a boat or not.
+     *
+     * @returns Whether this model is a boat.
+     */
+    get IsBoat() {
+      return IsThisModelABoat(this.hash);
+    }
+    /**
+     * Gets if the model is a Ped or not.
+     *
+     * @returns Whether this model is a Ped.
+     */
+    get IsPed() {
+      return IsModelAPed(this.hash);
+    }
+    /**
+     * Gets if the model is a prop or not.
+     *
+     * @returns Whether this model is a prop.
+     */
+    get IsProp() {
+      return this.IsValid && !this.IsPed && !this.IsVehicle && !this.IsWeapon;
+    }
+    /**
+     * Gets if the model is a train or not.
+     *
+     * @returns Whether this model is a train.
+     */
+    get IsTrain() {
+      return IsThisModelATrain(this.hash);
+    }
+    /**
+     * Gets if the model is a Vehicle or not.
+     *
+     * @returns Whether this model is a Vehicle.
+     */
+    get IsVehicle() {
+      return IsModelAVehicle(this.hash);
+    }
+    get IsWeapon() {
+      return IsWeaponValid(this.hash);
+    }
+    /**
+     * Gets the model dimensions.
+     *
+     * @returns This model min & max dimensions.
+     */
+    get Dimensions() {
+      const [minArray, maxArray] = GetModelDimensions(this.hash);
+      const min = Vector3.fromArray(minArray);
+      const max = Vector3.fromArray(maxArray);
+      return { min, max };
+    }
+    // TODO: Metaped stuff too at some point
+    requestModel() {
+      RequestModel(this.hash, false);
+      this.requestCount++;
+    }
+    /**
+     * Request and load the model with a specified timeout. Default timeout is 1000 (recommended).
+     * This function will not automatically set the model as no longer needed when
+     * done.
+     *
+     * @param timeoutMs Maximum allowed time for model to load.
+     */
+    async request(timeoutMs = 1e3) {
+      if (!this.IsInCdImage && !this.IsValid && !this.IsWeapon) {
+        return false;
+      }
+      if (this.IsLoaded) {
+        return true;
+      }
+      this.requestModel();
+      const timeout = GetGameTimer() + timeoutMs;
+      while (!this.IsLoaded && GetGameTimer() < timeout) {
+        await Delay(0);
+      }
+      if (!this.IsLoaded) {
+        this.markAsNoLongerNeeded();
+      }
+      return this.IsLoaded;
+    }
+    /**
+     * Sets the model as no longer needed allowing the game engine to free memory.
+     */
+    markAsNoLongerNeeded() {
+      SetModelAsNoLongerNeeded(this.hash);
+    }
+  };
+  __name(_CommonModel, "CommonModel");
+  __name7(_CommonModel, "CommonModel");
+  var CommonModel = _CommonModel;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/common/GlobalData.js
+  var __defProp8 = Object.defineProperty;
+  var __name8 = /* @__PURE__ */ __name((target, value) => __defProp8(target, "name", { value, configurable: true }), "__name");
+  globalThis.OnError = (type, err) => {
+  };
+  var _GlobalData = class _GlobalData {
+  };
+  __name(_GlobalData, "GlobalData");
+  __name8(_GlobalData, "GlobalData");
+  __publicField(_GlobalData, "CurrentResource", GetCurrentResourceName());
+  __publicField(_GlobalData, "GameName", GetGameName());
+  __publicField(_GlobalData, "GameBuild", GetGameBuildNumber());
+  __publicField(_GlobalData, "IS_SERVER", IsDuplicityVersion());
+  __publicField(_GlobalData, "IS_REDM", GetGameName() === "redm");
+  __publicField(_GlobalData, "IS_FIVEM", GetGameName() === "fivem");
+  __publicField(_GlobalData, "IS_CLIENT", !_GlobalData.IS_SERVER);
+  __publicField(_GlobalData, "NetworkTick", null);
+  __publicField(_GlobalData, "NetworkedTicks", []);
+  __publicField(_GlobalData, "EnablePrettyPrint", true);
+  /*
+   * Called when one of the decors errors
+   */
+  __publicField(_GlobalData, "OnError", /* @__PURE__ */ __name8((type, err) => {
+    globalThis.OnError(type, err);
+  }, "OnError"));
+  var GlobalData = _GlobalData;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/common-game/entities/IHandle.js
+  var __defProp9 = Object.defineProperty;
+  var __name9 = /* @__PURE__ */ __name((target, value) => __defProp9(target, "name", { value, configurable: true }), "__name");
+  var _IHandle = class _IHandle {
+    constructor(handle) {
+      __publicField(this, "handle");
+      this.handle = handle;
+    }
+    exists() {
+      return DoesEntityExist(this.handle);
+    }
+    get Handle() {
+      return this.handle;
+    }
+  };
+  __name(_IHandle, "IHandle");
+  __name9(_IHandle, "IHandle");
+  var IHandle = _IHandle;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/common-game/entities/CommonBaseEntity.js
+  var __defProp10 = Object.defineProperty;
+  var __name10 = /* @__PURE__ */ __name((target, value) => __defProp10(target, "name", { value, configurable: true }), "__name");
+  var _CommonBaseEntity = class _CommonBaseEntity extends IHandle {
+    constructor(handle) {
+      super(handle);
+      __publicField(this, "stateBagCookies", []);
+      __publicField(this, "netId", null);
+    }
+    /**
+      * Replaces the current handle for the entity used on, this should be used sparringly, mainly
+      * in situations where you're going to reuse an entity over and over and don't want to make a
+      * new entity every time.
+      *
+      *  **WARNING**: This does no checks, if you provide it an invalid entity it will use it
+      *
+      * ```ts
+      * const REUSABLE_ENTITY = new Entity(entityHandle);
+      *
+      * onNet("entityHandler", (entNetId: number) => {
+      *  // if no net entity we should ignore
+      *  if (!NetworkDoesEntityExistWithNetworkId(entNetId)) return;
+      *
+      *  // Reuse our entity so we don't have to initialize a new one
+      *  REUSABLE_ENTITY.replaceHandle(NetworkGetEntityFromNetworkId(entNetId));
+      *  // Do something with REUSABLE_ENTITY entity
+      * })
+      ```
+      */
+    replaceHandle(newHandle) {
+      this.handle = newHandle;
+    }
+    /*
+     * @returns `true` if the entity exists, `false` otherwise.
+     */
+    get Exists() {
+      return DoesEntityExist(this.handle);
+    }
+    /*
+     * @returns the handle of the specified entity
+     */
+    get Handle() {
+      return this.handle;
+    }
+    /**
+     * This will return a warning if the the entity is not networked, you should always use {@link IsNetworked} prior to calling thisl
+     * @returns the network for the specified entity
+     */
+    get NetworkId() {
+      return NetworkGetNetworkIdFromEntity(this.handle);
+    }
+    /**
+     * @returns `true` if the current entity is networked, false otherwise
+     */
+    get IsNetworked() {
+      return NetworkGetEntityIsNetworked(this.handle);
+    }
+    set IsNetworked(networked) {
+      if (networked) {
+        NetworkRegisterEntityAsNetworked(this.handle);
+      } else {
+        if (GlobalData.IS_REDM) {
+          Citizen.invokeNative("0xE31A04513237DC89", this.handle);
+        } else {
+          NetworkUnregisterNetworkedEntity(this.handle);
+        }
+      }
+    }
+    get State() {
+      return cfx_default.Entity(this.handle).state;
+    }
+    AddStateBagChangeHandler(keyFilter, handler) {
+      const stateBagName = this.IsNetworked ? `entity:${this.NetworkId}` : `localEntity:${this.handle}`;
+      const cookie = AddStateBagChangeHandler(keyFilter, stateBagName, handler);
+      this.stateBagCookies.push(cookie);
+      return cookie;
+    }
+    /**
+     * A short hand function for AddStateBagChangeHandler, this gets automatically cleaned up on entity deletion.
+     * @param keyFilter the key to filter for or null
+     * @param handler the function to handle the change
+     * @returns a cookie to be used in RemoveStateBagChangeHandler
+     */
+    listenForStateChange(keyFilter, handler) {
+      return this.AddStateBagChangeHandler(keyFilter, handler);
+    }
+    removeStateListener(tgtCookie) {
+      this.stateBagCookies = this.stateBagCookies.filter((cookie) => {
+        const isCookie = cookie === tgtCookie;
+        if (isCookie) RemoveStateBagChangeHandler(cookie);
+        return isCookie;
+      });
+    }
+    get Owner() {
+      return NetworkGetEntityOwner(this.handle);
+    }
+    get Speed() {
+      return GetEntitySpeed(this.handle);
+    }
+    getSpeedVector(isRelative = false) {
+      return Vector3.fromArray(GetEntitySpeedVector(this.handle, isRelative));
+    }
+    get ForwardVector() {
+      return Vector3.fromArray(GetEntityForwardVector(this.handle));
+    }
+    get Matrix() {
+      return Vector3.fromArrays(GetEntityMatrix(this.handle));
+    }
+    get MaxHealth() {
+      return GetEntityMaxHealth(this.handle);
+    }
+    set MaxHealth(amount) {
+      SetEntityMaxHealth(this.handle, amount);
+    }
+    set IsDead(value) {
+      if (value) {
+        SetEntityHealth(this.handle, 0);
+      } else {
+        SetEntityHealth(this.handle, 200);
+      }
+    }
+    /**
+     * @returns Returns true if the entity is dead
+     */
+    get IsDead() {
+      return IsEntityDead(this.handle);
+    }
+    get IsAlive() {
+      return !IsEntityDead(this.handle);
+    }
+    get Model() {
+      return new CommonModel(GetEntityModel(this.handle));
+    }
+    /**
+     * Returns if the entity is set as a mission entity and will not be cleaned up by the engine
+     */
+    get IsMissionEntity() {
+      return IsEntityAMissionEntity(this.handle);
+    }
+    /**
+     * Sets if the entity is a mission entity and will not be cleaned up by the engine
+     */
+    set IsMissionEntity(value) {
+      if (value) {
+        SetEntityAsMissionEntity(this.handle, false, false);
+      } else {
+        SetEntityAsNoLongerNeeded(this.handle);
+      }
+    }
+    set PositionNoOffset(position) {
+      SetEntityCoordsNoOffset(this.handle, position.x, position.y, position.z, true, true, true);
+    }
+    get Rotation() {
+      return Vector3.fromArray(GetEntityRotation(this.handle, 2));
+    }
+    set Rotation(rotation) {
+      SetEntityRotation(this.handle, rotation.x, rotation.y, rotation.z, 2, true);
+    }
+    set Quaternion(quaternion) {
+      SetEntityQuaternion(this.handle, quaternion.x, quaternion.y, quaternion.z, quaternion.w);
+    }
+    get IsPositionFrozen() {
+      return IsEntityPositionFrozen(this.handle);
+    }
+    set IsPositionFrozen(value) {
+      FreezeEntityPosition(this.handle, value);
+    }
+    get Velocity() {
+      return Vector3.fromArray(GetEntityVelocity(this.handle));
+    }
+    set Velocity(velocity) {
+      SetEntityVelocity(this.handle, velocity.x, velocity.y, velocity.z);
+    }
+    get IsVisible() {
+      return IsEntityVisible(this.handle);
+    }
+    /**
+     * @param amount the health to set the health to, setting to `0` will kill the entity, if using on a {@link Ped} you should check the MaxHealth before setting.
+     */
+    set Health(amount) {
+      SetEntityHealth(this.handle, amount, 0);
+    }
+    /**
+     * @returns the amount of health the current {@link BaseEntity} has
+     */
+    get Health() {
+      return GetEntityHealth(this.handle);
+    }
+    /**
+     * @returns the heading of the current {@link BaseEntity}
+     */
+    get Heading() {
+      return GetEntityHeading(this.handle);
+    }
+    /**
+     * @param heading sets the entitys heading to the specified heading, this can be in the range of 0..360
+     */
+    set Heading(heading) {
+      SetEntityHeading(this.handle, heading);
+    }
+    /**
+     * @returns the position of the current Entity
+     */
+    get Position() {
+      return Vector3.fromArray(GetEntityCoords(this.handle, true, true));
+    }
+    /**
+     * You should always try to load the collisions before setting the entitys position if going a long distance.
+     * @param pos sets the position for the current ped
+     */
+    set Position(pos) {
+      SetEntityCoords(this.handle, pos.x, pos.y, pos.z, false, false, false, false);
+    }
+    delete() {
+      this.IsMissionEntity = true;
+      DeleteEntity(this.handle);
+      for (const cookie of this.stateBagCookies) {
+        RemoveStateBagChangeHandler(cookie);
+      }
+    }
+    /*
+     * Attaches an entity to another entity via a bone
+     * @example
+     * ```typescript
+     * const ply = Game.PlayerPed;
+     * const bag = await World.createProp(new Model('ba_prop_battle_bag_01b'), ply.Position, true, true, true);
+     * bag.attachToBone(
+     *     ply.Bones.getBone(64113),
+     *     new Vector3(0.12, -0.25, 0.0),
+     *     new Vector3(105.0, 50.0, 190.0)
+     * )
+     * ```
+     */
+    attachToBone(entityBone, position, rotation, collisions = false, unk9 = true, useSoftPinning = true, rotationOrder = 1) {
+      if (this.handle === entityBone.Owner.Handle) {
+        throw new Error("You cannot attach an entity to the same entity this will result in a crash!");
+      }
+      AttachEntityToEntity(
+        this.handle,
+        entityBone.Owner.Handle,
+        entityBone.Index,
+        position.x,
+        position.y,
+        position.z,
+        rotation.x,
+        rotation.y,
+        rotation.z,
+        unk9,
+        useSoftPinning,
+        collisions,
+        IsEntityAPed(entityBone.Owner.Handle),
+        rotationOrder,
+        true
+      );
+    }
+  };
+  __name(_CommonBaseEntity, "CommonBaseEntity");
+  __name10(_CommonBaseEntity, "CommonBaseEntity");
+  var CommonBaseEntity = _CommonBaseEntity;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/common-game/entities/CommonBaseEntityBoneCollection.js
+  var __defProp11 = Object.defineProperty;
+  var __name11 = /* @__PURE__ */ __name((target, value) => __defProp11(target, "name", { value, configurable: true }), "__name");
+  var _CommonBaseEntityBoneCollection = class _CommonBaseEntityBoneCollection {
+    constructor(owner) {
+      __publicField(this, "owner");
+      this.owner = owner;
+    }
+    hasBone(name) {
+      return GetEntityBoneIndexByName(this.owner.Handle, name) !== -1;
+    }
+  };
+  __name(_CommonBaseEntityBoneCollection, "CommonBaseEntityBoneCollection");
+  __name11(_CommonBaseEntityBoneCollection, "CommonBaseEntityBoneCollection");
+  var CommonBaseEntityBoneCollection = _CommonBaseEntityBoneCollection;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/common-game/entities/CommonBaseEntityBone.js
+  var __defProp12 = Object.defineProperty;
+  var __name12 = /* @__PURE__ */ __name((target, value) => __defProp12(target, "name", { value, configurable: true }), "__name");
+  var _CommonBaseEntityBone = class _CommonBaseEntityBone extends IHandle {
+    constructor(owner, boneInfo) {
+      super(typeof boneInfo === "number" ? boneInfo : GetEntityBoneIndexByName(owner.Handle, boneInfo));
+      __publicField(this, "owner");
+      this.owner = owner;
+    }
+    // overwrite the `IHandle` exists function call
+    exists() {
+      return this.handle !== -1;
+    }
+    get Index() {
+      return this.handle;
+    }
+    get Owner() {
+      return this.owner;
+    }
+    get Position() {
+      return Vector3.fromArray(GetWorldPositionOfEntityBone(this.owner.Handle, this.handle));
+    }
+    // public get Rotation(): Vector3 {
+    //   return Vector3.fromArray(GetEntityBoneRotation(this.owner.Handle, this.index));
+    // }
+    get IsValid() {
+      return this.owner.exists() && this.handle !== -1;
+    }
+  };
+  __name(_CommonBaseEntityBone, "CommonBaseEntityBone");
+  __name12(_CommonBaseEntityBone, "CommonBaseEntityBone");
+  var CommonBaseEntityBone = _CommonBaseEntityBone;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/common-game/entities/CommonEntityBone.js
+  var __defProp13 = Object.defineProperty;
+  var __name13 = /* @__PURE__ */ __name((target, value) => __defProp13(target, "name", { value, configurable: true }), "__name");
+  var _CommonEntityBone = class _CommonEntityBone extends CommonBaseEntityBone {
+    constructor(owner, boneIndexOrBoneName) {
+      super(owner, boneIndexOrBoneName);
+    }
+  };
+  __name(_CommonEntityBone, "CommonEntityBone");
+  __name13(_CommonEntityBone, "CommonEntityBone");
+  var CommonEntityBone = _CommonEntityBone;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/common-game/entities/CommonEntityBoneCollection.js
+  var __defProp14 = Object.defineProperty;
+  var __name14 = /* @__PURE__ */ __name((target, value) => __defProp14(target, "name", { value, configurable: true }), "__name");
+  var _CommonEntityBoneCollection = class _CommonEntityBoneCollection extends CommonBaseEntityBoneCollection {
+    constructor(owner) {
+      super(owner);
+    }
+    getBoneFromName(boneName) {
+      return new CommonEntityBone(this.owner, GetEntityBoneIndexByName(this.owner.Handle, boneName));
+    }
+    getBoneFromIndex(boneIndex) {
+      return new CommonEntityBone(this.owner, boneIndex);
+    }
+    getBone(bone) {
+      return new CommonEntityBone(
+        this.owner,
+        typeof bone === "number" ? bone : GetEntityBoneIndexByName(this.owner.Handle, bone ?? "")
+      );
+    }
+    get Core() {
+      return new CommonEntityBone(this.owner, -1);
+    }
+  };
+  __name(_CommonEntityBoneCollection, "CommonEntityBoneCollection");
+  __name14(_CommonEntityBoneCollection, "CommonEntityBoneCollection");
+  var CommonEntityBoneCollection = _CommonEntityBoneCollection;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/common-game/entities/CommonVehicle.js
+  var __defProp15 = Object.defineProperty;
+  var __name15 = /* @__PURE__ */ __name((target, value) => __defProp15(target, "name", { value, configurable: true }), "__name");
+  var _CommonVehicle = class _CommonVehicle extends CommonBaseEntity {
+    constructor(handle) {
+      super(handle);
+      __publicField(this, "type", ClassTypes.Vehicle);
+      __publicField(this, "bones");
+    }
+    static fromHandle(handle) {
+      if (handle === 0 || !DoesEntityExist(handle)) {
+        return null;
+      }
+      return new this(handle);
+    }
+    static fromNetworkId(networkId) {
+      if (!NetworkDoesEntityExistWithNetworkId(networkId)) {
+        return null;
+      }
+      return new this(NetworkGetEntityFromNetworkId(networkId));
+    }
+    get Bones() {
+      if (!this.bones) {
+        this.bones = new CommonEntityBoneCollection(this);
+      }
+      return this.bones;
+    }
+  };
+  __name(_CommonVehicle, "CommonVehicle");
+  __name15(_CommonVehicle, "CommonVehicle");
+  var CommonVehicle = _CommonVehicle;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/common-game/entities/CommonPedBone.js
+  var __defProp16 = Object.defineProperty;
+  var __name16 = /* @__PURE__ */ __name((target, value) => __defProp16(target, "name", { value, configurable: true }), "__name");
+  var _CommonPedBone = class _CommonPedBone extends CommonBaseEntityBone {
+    constructor(owner, boneIndex) {
+      super(owner, boneIndex);
+    }
+    get IsValid() {
+      return this.Owner.exists() && this.Index !== -1;
+    }
+  };
+  __name(_CommonPedBone, "CommonPedBone");
+  __name16(_CommonPedBone, "CommonPedBone");
+  var CommonPedBone = _CommonPedBone;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/common-game/entities/CommonPedBoneCollection.js
+  var __defProp17 = Object.defineProperty;
+  var __name17 = /* @__PURE__ */ __name((target, value) => __defProp17(target, "name", { value, configurable: true }), "__name");
+  var _CommonPedBoneCollection = class _CommonPedBoneCollection extends CommonBaseEntityBoneCollection {
+    constructor(owner) {
+      super(owner);
+    }
+    get Core() {
+      return new CommonPedBone(this.owner, -1);
+    }
+    get LastDamaged() {
+      const [, outBone] = GetPedLastDamageBone(this.owner.Handle, 0);
+      return CommonPedBone[outBone];
+    }
+    clearLastDamaged() {
+      ClearPedLastDamageBone(this.owner.Handle);
+    }
+    getBoneFromId(boneId) {
+      return new CommonPedBone(this.owner, GetPedBoneIndex(this.owner.Handle, boneId));
+    }
+    getBoneFromName(boneName) {
+      return new CommonPedBone(this.owner, GetEntityBoneIndexByName(this.owner.Handle, boneName));
+    }
+    getBone(bone) {
+      return new CommonPedBone(
+        this.owner,
+        typeof bone === "number" ? bone : GetEntityBoneIndexByName(this.owner.Handle, bone ?? "")
+      );
+    }
+  };
+  __name(_CommonPedBoneCollection, "CommonPedBoneCollection");
+  __name17(_CommonPedBoneCollection, "CommonPedBoneCollection");
+  var CommonPedBoneCollection = _CommonPedBoneCollection;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/entities/BaseEntity.js
+  var __defProp18 = Object.defineProperty;
+  var __name18 = /* @__PURE__ */ __name((target, value) => __defProp18(target, "name", { value, configurable: true }), "__name");
+  var _BaseEntity = class _BaseEntity extends CommonBaseEntity {
+  };
+  __name(_BaseEntity, "BaseEntity");
+  __name18(_BaseEntity, "BaseEntity");
+  var BaseEntity = _BaseEntity;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/enums/Driving.js
+  var DrivingStyle = /* @__PURE__ */ ((DrivingStyle2) => {
+    DrivingStyle2[DrivingStyle2["None"] = 0] = "None";
+    return DrivingStyle2;
+  })(DrivingStyle || {});
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/enums/FiringPatterns.js
+  var FiringPatterns = /* @__PURE__ */ ((FiringPatterns2) => {
+    FiringPatterns2[FiringPatterns2["None"] = 0] = "None";
+    FiringPatterns2[FiringPatterns2["BurstFire"] = -687903391] = "BurstFire";
+    FiringPatterns2[FiringPatterns2["UNK1"] = -753768974] = "UNK1";
+    FiringPatterns2[FiringPatterns2["UNK2"] = 1857128337] = "UNK2";
+    FiringPatterns2[FiringPatterns2["BurstFireInCover"] = 40051185] = "BurstFireInCover";
+    FiringPatterns2[FiringPatterns2["BurstFireMG"] = 432416687] = "BurstFireMG";
+    FiringPatterns2[FiringPatterns2["BurstFirePistol"] = -651807432] = "BurstFirePistol";
+    FiringPatterns2[FiringPatterns2["BurstFirePumpShotgun"] = 12239771] = "BurstFirePumpShotgun";
+    FiringPatterns2[FiringPatterns2["BurstFireRifle"] = -1670073338] = "BurstFireRifle";
+    FiringPatterns2[FiringPatterns2["BurstFireSmg"] = -787632658] = "BurstFireSmg";
+    FiringPatterns2[FiringPatterns2["UNK3"] = 1575766855] = "UNK3";
+    FiringPatterns2[FiringPatterns2["BurstSingleShot"] = -1413485146] = "BurstSingleShot";
+    FiringPatterns2[FiringPatterns2["CompanionBill"] = -667771326] = "CompanionBill";
+    FiringPatterns2[FiringPatterns2["CompanionDutch"] = -921847361] = "CompanionDutch";
+    FiringPatterns2[FiringPatterns2["CompanionHosea"] = 1173361664] = "CompanionHosea";
+    FiringPatterns2[FiringPatterns2["CompanionJohn"] = 1026597428] = "CompanionJohn";
+    FiringPatterns2[FiringPatterns2["CompanionMicah"] = -2017692654] = "CompanionMicah";
+    FiringPatterns2[FiringPatterns2["UNK4"] = 2055493265] = "UNK4";
+    FiringPatterns2[FiringPatterns2["UNK5"] = -1725067907] = "UNK5";
+    FiringPatterns2[FiringPatterns2["UNK6"] = -2056883078] = "UNK6";
+    FiringPatterns2[FiringPatterns2["ExConfederatesCombat"] = 517186037] = "ExConfederatesCombat";
+    FiringPatterns2[FiringPatterns2["ExplosivesInCover"] = 365231505] = "ExplosivesInCover";
+    FiringPatterns2[FiringPatterns2["UNK7"] = 577037782] = "UNK7";
+    FiringPatterns2[FiringPatterns2["FullAuto"] = -957453492] = "FullAuto";
+    FiringPatterns2[FiringPatterns2["InCoverCompanionBill"] = 2047104079] = "InCoverCompanionBill";
+    FiringPatterns2[FiringPatterns2["InCoverCompanionDutch"] = -887696719] = "InCoverCompanionDutch";
+    FiringPatterns2[FiringPatterns2["InCoverCompanionHosea"] = -938698330] = "InCoverCompanionHosea";
+    FiringPatterns2[FiringPatterns2["InCoverCompanionJohn"] = -451565453] = "InCoverCompanionJohn";
+    FiringPatterns2[FiringPatterns2["InCoverCompanionMicah"] = -1946394022] = "InCoverCompanionMicah";
+    FiringPatterns2[FiringPatterns2["UNK8"] = 1836430378] = "UNK8";
+    FiringPatterns2[FiringPatterns2["SingleShot"] = 1566631136] = "SingleShot";
+    FiringPatterns2[FiringPatterns2["SlowShot"] = -1422700276] = "SlowShot";
+    FiringPatterns2[FiringPatterns2["UNK9"] = 1521641709] = "UNK9";
+    FiringPatterns2[FiringPatterns2["ThrowInCover"] = -1795196902] = "ThrowInCover";
+    return FiringPatterns2;
+  })(FiringPatterns || {});
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/enums/VehicleSeat.js
+  var VehicleSeat = /* @__PURE__ */ ((VehicleSeat2) => {
+    VehicleSeat2[VehicleSeat2["AnyPassenger"] = -2] = "AnyPassenger";
+    VehicleSeat2[VehicleSeat2["Driver"] = -1] = "Driver";
+    VehicleSeat2[VehicleSeat2["FrontRight"] = 0] = "FrontRight";
+    VehicleSeat2[VehicleSeat2["BackLeft"] = 1] = "BackLeft";
+    VehicleSeat2[VehicleSeat2["BackRight"] = 2] = "BackRight";
+    VehicleSeat2[VehicleSeat2["ExtraLeft1"] = 3] = "ExtraLeft1";
+    VehicleSeat2[VehicleSeat2["ExtraRight1"] = 4] = "ExtraRight1";
+    VehicleSeat2[VehicleSeat2["ExtraLeft2"] = 5] = "ExtraLeft2";
+    VehicleSeat2[VehicleSeat2["ExtraRight2"] = 6] = "ExtraRight2";
+    VehicleSeat2[VehicleSeat2["ExtraLeft3"] = 7] = "ExtraLeft3";
+    VehicleSeat2[VehicleSeat2["ExtraRight3"] = 8] = "ExtraRight3";
+    return VehicleSeat2;
+  })(VehicleSeat || {});
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/utils/Animations.js
+  var __defProp19 = Object.defineProperty;
+  var __name19 = /* @__PURE__ */ __name((target, value) => __defProp19(target, "name", { value, configurable: true }), "__name");
+  var LoadAnimDict = /* @__PURE__ */ __name19(async (animDict, waitTime = 1e3) => {
+    const start = GetGameTimer();
+    if (!HasAnimDictLoaded(animDict)) {
+      RequestAnimDict(animDict);
+    }
+    while (!HasAnimDictLoaded(animDict)) {
+      if (GetGameTimer() - start >= waitTime) return false;
+      await Delay(0);
+    }
+    return true;
+  }, "LoadAnimDict");
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/Task.js
+  var __defProp20 = Object.defineProperty;
+  var __name20 = /* @__PURE__ */ __name((target, value) => __defProp20(target, "name", { value, configurable: true }), "__name");
+  var _Tasks = class _Tasks {
+    // we take null because sequences have a null ped, if you pass null to this
+    // you betterk now what you're doing.
+    constructor(ped) {
+      __publicField(this, "ped");
+      const actualPed = ped ?? { handle: null };
+      this.ped = ped;
+    }
+    achieveHeading(heading, timeout = 0) {
+      TaskAchieveHeading(this.ped.Handle, heading, timeout);
+    }
+    blockTemporaryEvents(block = true) {
+      TaskSetBlockingOfNonTemporaryEvents(this.ped.Handle, block);
+    }
+    aimAt(target, duration) {
+      if (target instanceof BaseEntity)
+        TaskAimGunAtEntity(this.ped.Handle, target.Handle, duration, false, false);
+      else TaskAimGunAtCoord(this.ped.Handle, target.x, target.y, target.z, duration, false, false);
+    }
+    arrest(ped) {
+      TaskArrestPed(this.ped.Handle, ped.Handle);
+    }
+    jump() {
+      TaskJump(this.ped.Handle, true);
+    }
+    climb() {
+      TaskClimb(this.ped.Handle, true);
+    }
+    // TODO: test and verify
+    // public climbLadder(): void {
+    //   TaskClimbLadder(this.ped.Handle, 0.0 1);
+    // }
+    //
+    // public cower(duration: number): void {
+    //   TaskCower(this.ped.Handle, duration);
+    // }
+    cruiseWithVehicle(vehicle, speed, drivingStyle = DrivingStyle.None) {
+      TaskVehicleDriveWander(this.ped.Handle, vehicle.Handle, speed, drivingStyle);
+    }
+    // public driveTo(
+    //   vehicle: Vehicle,
+    //   target: Vector3,
+    //   radius: number,
+    //   speed: number,
+    //   drivingstyle = DrivingStyle.None,
+    // ): void {
+    //   // Swap to TaskVehicleDriveToCoord
+    //   TaskVehicleDriveToCoordLongrange(
+    //     this.ped.Handle,
+    //     vehicle.Handle,
+    //     target.x,
+    //     target.y,
+    //     target.z,
+    //     speed,
+    //     drivingstyle,
+    //     radius,
+    //   );
+    // }
+    enterAnyVehicle(seat = VehicleSeat.AnyPassenger, timeout = -1, speed = 0, flag = 0) {
+      TaskEnterVehicle(this.ped.Handle, 0, timeout, seat, speed, flag, 0);
+    }
+    static everyoneLeaveVehicle(vehicle) {
+      TaskEveryoneLeaveVehicle(vehicle.Handle, 0);
+    }
+    fightAgainst(target, duration) {
+      if (duration) {
+        TaskCombatPedTimed(this.ped.Handle, target.Handle, duration, 0);
+      } else {
+        TaskCombatPed(this.ped.Handle, target.Handle, 0, 16);
+      }
+    }
+    fightAgainstHatedTargets(radius, duration) {
+      if (duration) {
+        TaskCombatHatedTargetsAroundPedTimed(this.ped.Handle, radius, duration, 0);
+      } else {
+        TaskCombatHatedTargetsAroundPed(this.ped.Handle, radius, 0, 0);
+      }
+    }
+    fleeFrom(pedOrPosition, distance = 100, duration = -1, fleeType = 0, fleeSpeed = 3, fleeFrom) {
+      if (pedOrPosition instanceof Ped) {
+        TaskSmartFleePed(
+          this.ped.Handle,
+          pedOrPosition.Handle,
+          distance,
+          duration,
+          fleeType,
+          fleeSpeed,
+          fleeFrom ? fleeFrom.Handle : 0
+        );
+      } else {
+        TaskSmartFleeCoord(
+          this.ped.Handle,
+          pedOrPosition.x,
+          pedOrPosition.y,
+          pedOrPosition.z,
+          distance,
+          duration,
+          fleeType,
+          fleeSpeed
+        );
+      }
+    }
+    goTo(position, ignorePaths = false, timeout = -1, speed = 1, targetHeading = 0, distanceToSlide = 0, flags = 0) {
+      if (ignorePaths) {
+        TaskGoStraightToCoord(
+          this.ped.Handle,
+          position.x,
+          position.y,
+          position.z,
+          speed,
+          timeout,
+          targetHeading,
+          distanceToSlide,
+          0
+        );
+      } else {
+        TaskFollowNavMeshToCoord(
+          this.ped.Handle,
+          position.x,
+          position.y,
+          position.z,
+          speed,
+          timeout,
+          0,
+          flags,
+          targetHeading
+        );
+      }
+    }
+    goToEntity(target, offset = null, timeout = -1) {
+      if (offset === null) {
+        offset = new Vector3(0, 0, 0);
+      }
+      TaskGotoEntityOffsetXy(this.ped.Handle, target.Handle, timeout, offset.x, offset.y, offset.z, 1, true);
+    }
+    guardCurrentPosition() {
+      TaskGuardCurrentPosition(this.ped.Handle, 15, 10, true);
+    }
+    handsUp(duration) {
+      TaskHandsUp(this.ped.Handle, duration, 0, -1, false);
+    }
+    lookAt(targetOrPosition, duration = -1) {
+      if (targetOrPosition instanceof BaseEntity) {
+        TaskLookAtEntity(this.ped.Handle, targetOrPosition.Handle, duration, 2048, 31, 0);
+      } else {
+        TaskLookAtCoord(this.ped.Handle, targetOrPosition.x, targetOrPosition.y, targetOrPosition.z, duration, 0, 51, 0);
+      }
+    }
+    async playAnimation(animDict, animName, blendInSpeed, blendOutSpeed, duration, playbackRate, animFlags, ikFlags) {
+      await LoadAnimDict(animDict);
+      TaskPlayAnim(
+        this.ped.Handle,
+        animDict,
+        animName,
+        blendInSpeed,
+        blendOutSpeed,
+        duration,
+        animFlags,
+        playbackRate,
+        false,
+        ikFlags,
+        false,
+        0,
+        false
+      );
+      RemoveAnimDict(animDict);
+    }
+    reloadWeapon() {
+      TaskReloadWeapon(this.ped.Handle, true);
+    }
+    shootAt(targetOrPosition, duration = -1, pattern = FiringPatterns.None, affectCockedState = false) {
+      if (targetOrPosition instanceof Ped) {
+        TaskShootAtEntity(this.ped.Handle, targetOrPosition.Handle, duration, pattern, affectCockedState);
+      } else {
+        TaskShootAtCoord(
+          this.ped.Handle,
+          targetOrPosition.x,
+          targetOrPosition.y,
+          targetOrPosition.z,
+          duration,
+          pattern,
+          0
+        );
+      }
+    }
+    shuffleToNextVehicleSeat(vehicle) {
+      TaskShuffleToNextVehicleSeat(this.ped.Handle, vehicle.Handle);
+    }
+    slideTo(position, heading, duration = 0.7) {
+      TaskPedSlideToCoord(this.ped.Handle, position.x, position.y, position.z, heading, duration);
+    }
+    standStill(duration) {
+      TaskStandStill(this.ped.Handle, duration);
+    }
+    vehicleShootAtPed(target) {
+      TaskVehicleShootAtPed(this.ped.Handle, target.Handle, 20);
+    }
+    wait(duration) {
+      TaskPause(this.ped.Handle, duration);
+    }
+    wanderAround(position, radius) {
+      if (position && radius) {
+        TaskWanderInArea(this.ped.Handle, position.x, position.y, position.z, radius, 0, 0, 0);
+      } else {
+        TaskWanderStandard(this.ped.Handle, 0, 0);
+      }
+    }
+    warpIntoVehicle(vehicle, seat) {
+      TaskWarpPedIntoVehicle(this.ped.Handle, vehicle.Handle, seat);
+    }
+    warpOutOfVehicle(vehicle, flags) {
+      TaskLeaveVehicle(this.ped.Handle, vehicle.Handle, flags, 0);
+    }
+    isPlayingAnim(dict, anim, taskFlag = 3) {
+      return IsEntityPlayingAnim(this.ped.Handle, dict, anim, taskFlag);
+    }
+    clearAll() {
+      ClearPedTasks(this.ped.Handle, true, false);
+    }
+    clearAllImmediately() {
+      ClearPedTasksImmediately(this.ped.Handle, true, false);
+    }
+    clearLookAt() {
+      TaskClearLookAt(this.ped.Handle);
+    }
+    clearSecondary() {
+      ClearPedSecondaryTask(this.ped.Handle);
+    }
+    clearAnimation(animDict, animName) {
+      StopAnimTask(this.ped.Handle, animDict, animName, -4);
+    }
+  };
+  __name(_Tasks, "Tasks");
+  __name20(_Tasks, "Tasks");
+  var Tasks = _Tasks;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/enums/WeaponAttachPoints.js
+  var WeaponAttachPoints = /* @__PURE__ */ ((WeaponAttachPoints2) => {
+    WeaponAttachPoints2[WeaponAttachPoints2["HandPrimary"] = 0] = "HandPrimary";
+    WeaponAttachPoints2[WeaponAttachPoints2["HandSecondary"] = 1] = "HandSecondary";
+    WeaponAttachPoints2[WeaponAttachPoints2["PistolR"] = 2] = "PistolR";
+    WeaponAttachPoints2[WeaponAttachPoints2["MAX_HAND_ATTACH_POINTS"] = 2] = "MAX_HAND_ATTACH_POINTS";
+    WeaponAttachPoints2[WeaponAttachPoints2["PistolLeft"] = 3] = "PistolLeft";
+    WeaponAttachPoints2[WeaponAttachPoints2["Knife"] = 4] = "Knife";
+    WeaponAttachPoints2[WeaponAttachPoints2["Lasso"] = 5] = "Lasso";
+    WeaponAttachPoints2[WeaponAttachPoints2["Thrower"] = 6] = "Thrower";
+    WeaponAttachPoints2[WeaponAttachPoints2["Bow"] = 7] = "Bow";
+    WeaponAttachPoints2[WeaponAttachPoints2["BowAlternative"] = 8] = "BowAlternative";
+    WeaponAttachPoints2[WeaponAttachPoints2["Rifle"] = 9] = "Rifle";
+    WeaponAttachPoints2[WeaponAttachPoints2["RifleAlternative"] = 10] = "RifleAlternative";
+    WeaponAttachPoints2[WeaponAttachPoints2["Lantern"] = 11] = "Lantern";
+    WeaponAttachPoints2[WeaponAttachPoints2["TempLantern"] = 12] = "TempLantern";
+    WeaponAttachPoints2[WeaponAttachPoints2["Melee"] = 13] = "Melee";
+    WeaponAttachPoints2[WeaponAttachPoints2["MAX_SYNCED_WEAPON_ATTACH_POINTS"] = 13] = "MAX_SYNCED_WEAPON_ATTACH_POINTS";
+    WeaponAttachPoints2[WeaponAttachPoints2["Hip"] = 14] = "Hip";
+    WeaponAttachPoints2[WeaponAttachPoints2["Boot"] = 15] = "Boot";
+    WeaponAttachPoints2[WeaponAttachPoints2["Back"] = 16] = "Back";
+    WeaponAttachPoints2[WeaponAttachPoints2["Front"] = 18] = "Front";
+    WeaponAttachPoints2[WeaponAttachPoints2["ShoulderSling"] = 19] = "ShoulderSling";
+    WeaponAttachPoints2[WeaponAttachPoints2["LeftBreast"] = 20] = "LeftBreast";
+    WeaponAttachPoints2[WeaponAttachPoints2["RightBreast"] = 21] = "RightBreast";
+    WeaponAttachPoints2[WeaponAttachPoints2["LeftArmpit"] = 22] = "LeftArmpit";
+    WeaponAttachPoints2[WeaponAttachPoints2["RightArmpit"] = 23] = "RightArmpit";
+    WeaponAttachPoints2[WeaponAttachPoints2["LeftArmpitRifle"] = 24] = "LeftArmpitRifle";
+    WeaponAttachPoints2[WeaponAttachPoints2["Satchel"] = 25] = "Satchel";
+    WeaponAttachPoints2[WeaponAttachPoints2["LeftArmPitBow"] = 26] = "LeftArmPitBow";
+    WeaponAttachPoints2[WeaponAttachPoints2["RightHandExtra"] = 27] = "RightHandExtra";
+    WeaponAttachPoints2[WeaponAttachPoints2["LeftHandExtra"] = 28] = "LeftHandExtra";
+    WeaponAttachPoints2[WeaponAttachPoints2["RightHandAux"] = 29] = "RightHandAux";
+    WeaponAttachPoints2[WeaponAttachPoints2["MAX_WEAPON_ATTACH_POINTS"] = 29] = "MAX_WEAPON_ATTACH_POINTS";
+    WeaponAttachPoints2[WeaponAttachPoints2["WEAPON_ATTACH_POINT_INVALID"] = -1] = "WEAPON_ATTACH_POINT_INVALID";
+    return WeaponAttachPoints2;
+  })(WeaponAttachPoints || {});
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/inventory/InventoryTypes.js
+  var ItemAddReason = /* @__PURE__ */ ((ItemAddReason2) => {
+    ItemAddReason2[ItemAddReason2["Default"] = 752097756] = "Default";
+    ItemAddReason2[ItemAddReason2["Incentive"] = -1965281643] = "Incentive";
+    ItemAddReason2[ItemAddReason2["Syncing"] = -1924444172] = "Syncing";
+    ItemAddReason2[ItemAddReason2["Awards"] = -1216041698] = "Awards";
+    ItemAddReason2[ItemAddReason2["Notification"] = -983395630] = "Notification";
+    ItemAddReason2[ItemAddReason2["Loadout"] = -902540058] = "Loadout";
+    ItemAddReason2[ItemAddReason2["Looted"] = -897553835] = "Looted";
+    ItemAddReason2[ItemAddReason2["UseFailed"] = -746211728] = "UseFailed";
+    ItemAddReason2[ItemAddReason2["GetInventory"] = -669481339] = "GetInventory";
+    ItemAddReason2[ItemAddReason2["CreateCharacter"] = -490406031] = "CreateCharacter";
+    ItemAddReason2[ItemAddReason2["MpMission"] = -334626412] = "MpMission";
+    ItemAddReason2[ItemAddReason2["Pickup"] = 444010018] = "Pickup";
+    ItemAddReason2[ItemAddReason2["SetAmount"] = 1157919518] = "SetAmount";
+    ItemAddReason2[ItemAddReason2["Purchased"] = 1248274121] = "Purchased";
+    ItemAddReason2[ItemAddReason2["LoadSaveGame"] = 1445013766] = "LoadSaveGame";
+    ItemAddReason2[ItemAddReason2["Debug"] = 1543882317] = "Debug";
+    ItemAddReason2[ItemAddReason2["Melee"] = 2073812199] = "Melee";
+    return ItemAddReason2;
+  })(ItemAddReason || {});
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/models/WeaponModel.js
+  var __defProp21 = Object.defineProperty;
+  var __name21 = /* @__PURE__ */ __name((target, value) => __defProp21(target, "name", { value, configurable: true }), "__name");
+  var _WeaponModel = class _WeaponModel extends Model {
+    requestModel() {
+      Citizen.invokeNative("0x72D4CB5DB927009C", this.hash, 0, true);
+      this.requestCount++;
+    }
+    markAsNoLongerNeeded() {
+      Citizen.invokeNative("0xC3896D03E2852236", this.hash);
+      this.requestCount--;
+    }
+    get DefaultAttachPoint() {
+      return Citizen.invokeNative("0x65DC4AC5B96614CB", this.hash, Citizen.resultAsInteger());
+    }
+  };
+  __name(_WeaponModel, "WeaponModel");
+  __name21(_WeaponModel, "WeaponModel");
+  var WeaponModel = _WeaponModel;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/entities/Vehicle.js
+  var __defProp22 = Object.defineProperty;
+  var __name22 = /* @__PURE__ */ __name((target, value) => __defProp22(target, "name", { value, configurable: true }), "__name");
+  var _Vehicle = class _Vehicle extends CommonVehicle {
+    constructor(handle) {
+      super(handle);
+      __publicField(this, "type", ClassTypes.Vehicle);
+    }
+    /**
+     * Gets the entity from the handle given, if the entity doesn't exist it will return
+     * null.
+     */
+    static fromHandle(handle) {
+      if (handle === 0 || !DoesEntityExist(handle)) {
+        return null;
+      }
+      return new _Vehicle(handle);
+    }
+    /**
+     * Gets the ped from the current network id, this doesn't check that
+     * the entity is actually a ped
+     */
+    static fromNetworkId(netId) {
+      if (netId === 0 || !NetworkDoesEntityExistWithNetworkId(netId)) {
+        return null;
+      }
+      return new _Vehicle(NetToPed(netId));
+    }
+    static fromStateBagName(bagName) {
+      const ent = GetEntityFromStateBagName(bagName);
+      if (ent === 0) {
+        return null;
+      }
+      return new _Vehicle(ent);
+    }
+    /**
+     *
+     * @param seatIndex the seat index to check
+     * @returns true of the specified seat is free on the mount
+     */
+    isSeatFree(seatIndex) {
+      return _N("0xAAB0FE202E9FC9F0", this.Handle, seatIndex, Citizen.resultAsInteger());
+    }
+  };
+  __name(_Vehicle, "Vehicle");
+  __name22(_Vehicle, "Vehicle");
+  var Vehicle = _Vehicle;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/entities/bones/PedBoneCollection.js
+  var __defProp23 = Object.defineProperty;
+  var __name23 = /* @__PURE__ */ __name((target, value) => __defProp23(target, "name", { value, configurable: true }), "__name");
+  var _PedBoneCollection = class _PedBoneCollection extends CommonPedBoneCollection {
+    getBoneFromId(boneId) {
+      return new CommonPedBone(this.owner, GetPedBoneIndex(this.owner.Handle, boneId));
+    }
+  };
+  __name(_PedBoneCollection, "PedBoneCollection");
+  __name23(_PedBoneCollection, "PedBoneCollection");
+  var PedBoneCollection = _PedBoneCollection;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/entities/Ped.js
+  var __defProp24 = Object.defineProperty;
+  var __name24 = /* @__PURE__ */ __name((target, value) => __defProp24(target, "name", { value, configurable: true }), "__name");
+  var _Ped = class _Ped extends BaseEntity {
+    constructor(handle) {
+      super(handle);
+      __publicField(this, "type", ClassTypes.Ped);
+      __publicField(this, "bones");
+      __publicField(this, "attributes");
+      __publicField(this, "tasks");
+    }
+    /**
+     * Gets the entity from the handle given, if the entity doesn't exist it will return
+     * null.
+     */
+    static fromHandle(handle) {
+      if (handle === 0 || !DoesEntityExist(handle)) {
+        return null;
+      }
+      return new _Ped(handle);
+    }
+    /**
+     * Gets the ped from the current network id, this doesn't check that
+     * the entity is actually a ped
+     */
+    static fromNetworkId(netId) {
+      if (netId === 0 || !NetworkDoesEntityExistWithNetworkId(netId)) {
+        return null;
+      }
+      return new _Ped(NetToPed(netId));
+    }
+    static fromStateBagName(bagName) {
+      const ent = GetEntityFromStateBagName(bagName);
+      if (ent === 0) {
+        return null;
+      }
+      return new _Ped(ent);
+    }
+    get Player() {
+      const playerId = NetworkGetPlayerIndexFromPed(this.handle);
+      if (playerId !== 255) {
+        return new Player2(playerId);
+      }
+      return null;
+    }
+    /**
+     * @returns the current horse or vehicle the ped is on, or null if they're not on either
+     */
+    get MountedEntity() {
+      const veh = this.CurrentVehicle;
+      if (veh !== null) {
+        return veh;
+      }
+      const horse = this.Mount;
+      return horse;
+    }
+    /**
+     * Blocks scenarios inbetween the specified vectors
+     * @todo Move to Game
+     * @param vec1
+     * @param vec2
+     * @param blockingFlags you can find blocking flags [here](https://github.com/Halen84/RDR3-Native-Flags-And-Enums/blob/main/ADD_SCENARIO_BLOCKING_AREA/README.md)
+     * @returns the scenarioId that can be used in {@link removeScenarioBlock} to unblock
+     */
+    static blockScenariosInArea(vec1, vec2, blockingFlags) {
+      return AddScenarioBlockingArea(
+        vec1.x,
+        vec1.y,
+        vec1.z,
+        vec2.x,
+        vec2.y,
+        vec2.z,
+        true,
+        blockingFlags
+      );
+    }
+    /**
+     * Removes the blocking of scenarios in the specified area
+     * @param scenarioId the number returned from {@link blockScenariosInArea}
+     */
+    static removeScenarioBlock(scenarioId) {
+      RemoveScenarioBlockingArea(scenarioId, false);
+    }
+    get Tasks() {
+      if (this.tasks) {
+        return this.tasks;
+      }
+      this.tasks = new Tasks(this);
+      return this.tasks;
+    }
+    get Bones() {
+      this.bones = this.bones ?? new PedBoneCollection(this);
+      return this.bones;
+    }
+    /**
+     * While this increases the peds max health, if used on a player it wont increase the max core value on the hud
+     */
+    set MaxHealth(amount) {
+      SetPedMaxHealth(this.handle, amount);
+    }
+    /**
+     * @returns the maximum health of the ped
+     */
+    get MaxHealth() {
+      return GetPedMaxHealth(this.handle);
+    }
+    /**
+     * @returns the {@link Attributes} for the current ped
+     */
+    get Attributes() {
+      if (this.attributes) return this.attributes;
+      return this.attributes = new Attributes(this);
+    }
+    get InVehicle() {
+      return IsPedInAnyVehicle(this.handle, true);
+    }
+    get IsInjured() {
+      return IsPedInjured(this.handle);
+    }
+    get IsFatallyInjured() {
+      return IsPedFatallyInjured(this.handle);
+    }
+    get IsPlayer() {
+      return IsPedAPlayer(this.handle);
+    }
+    get IsShooting() {
+      return IsPedShooting(this.handle);
+    }
+    get Accuracy() {
+      return GetPedAccuracy(this.handle);
+    }
+    set Accuracy(accuracy) {
+      SetPedAccuracy(this.handle, accuracy);
+    }
+    get CanBeKnockedOffVehicle() {
+      return CanKnockPedOffVehicle(this.handle);
+    }
+    get IsMale() {
+      return IsPedMale(this.handle);
+    }
+    get IsHuman() {
+      return IsPedHuman(this.handle);
+    }
+    get IsOnTopOfVehicle() {
+      return IsPedOnVehicle(this.handle, false);
+    }
+    get Vehicle() {
+      return Vehicle.fromHandle(GetVehiclePedIsIn(this.handle, false));
+    }
+    /**
+     * @returns the last mount that this ped was on, or null if it doesn't exist
+     */
+    get LastMount() {
+      const pedId = _N("0x4C8B59171957BCF7", this.handle, Citizen.resultAsInteger());
+      return _Ped.fromHandle(pedId);
+    }
+    /**
+     * @returns the the current mount that the ped is on, or null if there isn't one
+     */
+    get Mount() {
+      return _Ped.fromHandle(GetMount(this.handle));
+    }
+    /**
+     * returns the horse that this ped is leading
+     */
+    get LeadingHorse() {
+      const pedId = _N("0x693126B5D0457D0D", this.handle, Citizen.resultAsInteger());
+      return _Ped.fromHandle(pedId);
+    }
+    /**
+     * returns the owner of the current animal
+     */
+    get AnimalOwner() {
+      const pedId = _N("0xF103823FFE72BB49", this.handle, Citizen.resultAsInteger());
+      return _Ped.fromHandle(pedId);
+    }
+    get TamingState() {
+      return _N("0x454AD4DA6C41B5BD", this.handle, Citizen.resultAsInteger());
+    }
+    get IsInteractingWithAnimal() {
+      return _N("0x7FC84E85D98F063D", this.handle, Citizen.resultAsInteger());
+    }
+    get IsSittingInAnyVehicle() {
+      return IsPedSittingInAnyVehicle(this.handle);
+    }
+    get IsPlantingBomb() {
+      return IsPedPlantingBomb(this.handle);
+    }
+    get IsInAnyBoat() {
+      return IsPedInAnyBoat(this.handle);
+    }
+    get IsInAnyHeli() {
+      return IsPedInAnyHeli(this.handle);
+    }
+    get IsInAnyPlane() {
+      return IsPedInAnyPlane(this.handle);
+    }
+    get IsInFlyingVehicle() {
+      return IsPedInFlyingVehicle(this.handle);
+    }
+    get IsFalling() {
+      return IsPedFalling(this.handle);
+    }
+    get IsSliding() {
+      return _N("0xD6740E14E4CEFC0B", this.handle, Citizen.resultAsInteger());
+    }
+    get IsJumping() {
+      return IsPedJumping(this.handle);
+    }
+    get IsClimbing() {
+      return IsPedClimbing(this.handle);
+    }
+    get IsClimbingLadder() {
+      return _N("0x59643424B68D52B5", this.handle, Citizen.resultAsInteger());
+    }
+    get IsVaulting() {
+      return IsPedVaulting(this.handle);
+    }
+    get IsDiving() {
+      return IsPedDiving(this.handle);
+    }
+    get IsOpeningADoor() {
+      return IsPedOpeningADoor(this.handle);
+    }
+    set SeeingRange(value) {
+      SetPedSeeingRange(this.handle, value);
+    }
+    set HearingRange(value) {
+      SetPedHearingRange(this.handle, value);
+    }
+    get IsStealthed() {
+      return GetPedStealthMovement(this.handle);
+    }
+    get IsJacking() {
+      return IsPedJacking(this.handle);
+    }
+    get IsStunned() {
+      return IsPedBeingStunned(this.handle, 0);
+    }
+    get IsBeingJacked() {
+      return IsPedBeingJacked(this.handle);
+    }
+    get IsInCombatRoll() {
+      return _N("0xC48A9EB0D499B3E5", this.handle, Citizen.resultAsInteger());
+    }
+    get CrouchMovement() {
+      return _N("0xD5FE956C70FF370B", this.handle, Citizen.resultAsInteger());
+    }
+    /**
+     * returns true if {@link DamageCleanliness} was ever lower than {@link eDamageCleanliness.Good}
+     */
+    get IsDamaged() {
+      return _N("0x6CFC373008A1EDAF", this.handle, Citizen.resultAsInteger());
+    }
+    set IsDamaged(damaged) {
+      _N("0xDACE03C65C6666DB", this.handle, damaged);
+    }
+    get DamageCleanliness() {
+      return _N("0x88EFFED5FE8B0B4A", this.handle, Citizen.resultAsInteger());
+    }
+    set DamageCleanliness(cleanliness) {
+      _N("0x7528720101A807A5", this.handle, cleanliness);
+    }
+    set DefenseModifier(amount) {
+      _N("0x9B6808EC46BE849B", this.handle, amount);
+    }
+    set CanBeTargeted(toggle) {
+      SetPedCanBeTargetted(this.handle, toggle);
+    }
+    // TODO: Team class wrapper
+    // TODO: Bone wrapper `GET_PED_LAST_DAMAGE_BONE`
+    /**
+     * returns the ped who jacked this ped
+     */
+    getJacker() {
+      return new _Ped(GetPedsJacker(this.handle));
+    }
+    setCrouchMovement(state, immediately = false) {
+      _N("0x7DE9692C6F64CFE8", this.handle, state, 0, immediately);
+    }
+    canBeTargetedByPlayer(player, toggle) {
+      SetPedCanBeTargettedByPlayer(this.handle, player.Handle, toggle);
+    }
+    clearLastBoneDamage() {
+      ClearPedLastDamageBone(this.handle);
+    }
+    set OwnsAnimal(animal) {
+      _N("0x931B241409216C1F", this.handle, animal.Handle, false);
+    }
+    isInteractionPossible(animal) {
+      return _N("0xD543D3A8FDE4F185", this.handle, animal.Handle, Citizen.resultAsInteger());
+    }
+    isOnVehicle(vehicle) {
+      return IsPedOnSpecificVehicle(this.handle, vehicle.Handle);
+    }
+    isSittingInVehicle(vehicle) {
+      return IsPedSittingInVehicle(this.handle, vehicle.Handle);
+    }
+    warpOutOfVehicle() {
+      _N("0xE0B61ED8BB37712F", this.handle);
+    }
+    /**
+     * puts the ped onto the specified mount
+     * @param targetPed the horse to put the ped on
+     * @param seatIndex the seat index to put the ped on
+     */
+    setOntoMount(targetPed, seatIndex) {
+      _N("0x028F76B6E78246EB", this.handle, targetPed.Handle, seatIndex, true);
+    }
+    removeFromMount() {
+      _N("0x5337B721C51883A9", this.handle, true, true);
+    }
+    /**
+     * Sets the ped into the specified vehicle
+     * @param vehicle the vehicle to put the ped into
+     * @param seatIndex the seat index to put the ped into
+     */
+    setIntoVehicle(vehicle, seatIndex) {
+      SetPedIntoVehicle(this.handle, vehicle.Handle, seatIndex);
+    }
+    /**
+     * kills the ped and optionally sets the killer
+     * @param killer the entity that killed the ped
+     */
+    killPed(killer) {
+      SetEntityHealth(this.handle, 0, killer ? killer.Handle : 0);
+    }
+    damage(amount, boneId = 0, killer) {
+      ApplyDamageToPed(this.handle, amount, 0, boneId, killer ? killer.Handle : 0);
+    }
+    /**
+     * this returns a different type then the getter so we can't use set, maybe ts will fix soon (tm)
+     * @param state how hard it will be to knock a ped off their vehicle
+     */
+    setCanBeKnockedOffVehicle(state) {
+      SetPedCanBeKnockedOffVehicle(this.handle, state);
+    }
+    /**
+     * Removes the specified ped if its not a player entity
+     */
+    delete() {
+      SetEntityAsMissionEntity(this.handle, true, true);
+      DeletePed(this.handle);
+    }
+    /**
+     * creates a clone of the ped
+     * @param network if the ped should be a networked entity
+     * @param bScriptHostPed whether to register the ped as pinned to the script host in the R* network model.
+     * @param copyHeadBlend whether to copy the peds head blend
+     * @returns the cloned ped
+     */
+    clone(network, bScriptHostPed, copyHeadBlend) {
+      return new _Ped(ClonePed(this.handle, network, bScriptHostPed, copyHeadBlend));
+    }
+    /**
+     * clones the ped onto the target ped
+     * @param targetPed the ped to clone onto
+     */
+    cloneTo(targetPed) {
+      ClonePedToTarget(this.handle, targetPed.Handle);
+    }
+    /**
+     * @param amount - the amount of armour to add to the ped
+     */
+    addArmour(amount) {
+      AddArmourToPed(this.handle, amount);
+    }
+    applyDamage(damageAmount, boneId = 0, pedKiller = null) {
+      ApplyDamageToPed(this.handle, damageAmount, 0, boneId, pedKiller ? pedKiller.Handle : 0);
+    }
+    /**
+     * @param damagePack - the damage decal to apply see [here](https://github.com/femga/rdr3_discoveries/blob/master/peds_customization/ped_decals.lua) for more documentation
+     * @param damage - the damage to apply
+     * @param mult - the multiplier?
+     */
+    applyDamagePack(damagePack, damage, mult) {
+      ApplyPedDamagePack(this.handle, damagePack, damage, mult);
+    }
+    get CurrentVehicle() {
+      const veh = GetVehiclePedIsIn(this.handle, false);
+      if (veh === 0) return null;
+      return new Vehicle(veh);
+    }
+    // No documentation
+    // applyBloodSpecific() {
+    // 	ApplyPedBloodSpecific
+    // }
+    giveHashCommand(commandHash, activationDuration) {
+      Citizen.invokeNative("0xD65FDC686A031C83", this.handle, commandHash, activationDuration);
+    }
+    /**
+     * Adds or removes the ped stamina, depending on of the amount is positive or negative.
+     * @param amount the amount of stamina to add/remove
+     */
+    changeStamina(amount) {
+      _N("0xC3D4B754C0E86B9E", this.handle, amount);
+    }
+    get MaxStamina() {
+      return _N("0xCB42AFE2B613EE55", this.handle);
+    }
+    /**
+     * Returns the amount of stamina the ped has
+     */
+    get Stamina() {
+      return _N("0x775A1CA7893AA8B5", this.handle);
+    }
+    /**
+     * returns the normalized stamina for the player, taking into account their unlocked stamina
+     */
+    get StaminaNormalized() {
+      return _N("0x22F2A386D43048A9", this.handle);
+    }
+    resetStamina() {
+      _N("0x36513AFFC703C60D", this.handle);
+    }
+    setOwnsAnimal(ped, p2 = 0) {
+      _N("0x931B241409216C1F", this.handle, ped.Handle, p2);
+    }
+    // WEAPON NAMESPACE
+    addAmmo(weapon, amount, addReason = ItemAddReason.Default) {
+      Citizen.invokeNative("0xB190BCA3F4042F95", this.handle, weapon.Hash, amount, addReason);
+    }
+    clearLastDamage() {
+      Citizen.invokeNative("0x087D8F4BC65F68E4", this.handle);
+    }
+    disableAmmoType(ammo) {
+      Citizen.invokeNative("0xAA5A52204E077883", this.handle, ammo.Hash);
+    }
+    disableAmmoForWeapon(weapon, ammo) {
+      Citizen.invokeNative("0xF0D728EEA3C99775", this.handle, weapon.Hash, ammo.Hash);
+    }
+    get HasPistol() {
+      return Citizen.invokeNative("0xBFCA7AFABF9D7967", this.handle);
+    }
+    get HasRepeater() {
+      return Citizen.invokeNative("0x495A04CAEC263AF8", this.handle);
+    }
+    get CurrentWeapon() {
+      const weapon = Citizen.invokeNative("0x8425C5F057012DAB", this.handle);
+      return new WeaponModel(weapon);
+    }
+    async giveWeapon(weapon, ammoCount, forceInHand = true, forceInHolster = false, attachPoint = void 0, allowMultipleCopies = false, p7 = 0.5, p8 = 1, addReason = ItemAddReason.Default, ignoreUnlocks = true, permanentDegradation = 0.5, p12 = false) {
+      if (!await weapon.request()) {
+        return false;
+      }
+      attachPoint = attachPoint ?? weapon.DefaultAttachPoint;
+      Citizen.invokeNative(
+        "0x5E3BDDBCB83F3D84",
+        this.handle,
+        weapon.Hash,
+        ammoCount,
+        forceInHand,
+        forceInHolster,
+        attachPoint,
+        allowMultipleCopies,
+        p7,
+        p8,
+        addReason,
+        ignoreUnlocks,
+        permanentDegradation,
+        p12
+      );
+      return true;
+    }
+    setCurrentWeapon(weapon, equipNow = true, attachPoint = WeaponAttachPoints.HandPrimary, p4 = false, p5 = false) {
+      Citizen.invokeNative("0xADF692B254977C0C", this.handle, weapon.Hash, equipNow, attachPoint, p4, p5);
+    }
+    holsterWeapon() {
+      Citizen.invokeNative("0x94A3C1B804D291EC", this.handle, true, true, true, true);
+    }
+    setWeaponOnBack(disableAnim = false) {
+      Citizen.invokeNative("0x4820A6939D7CEF28", this.handle, disableAnim);
+    }
+    isHoldingWeapon(weapon) {
+      return Citizen.invokeNative("0x07E1C35F0078C3F9", this.handle, weapon.Hash);
+    }
+    isHolsterStateChanging() {
+      return Citizen.invokeNative("0x2387D6E9C6B478AA", this.handle);
+    }
+  };
+  __name(_Ped, "Ped");
+  __name24(_Ped, "Ped");
+  var Ped = _Ped;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/entities/Player.js
+  var __defProp25 = Object.defineProperty;
+  var __name25 = /* @__PURE__ */ __name((target, value) => __defProp25(target, "name", { value, configurable: true }), "__name");
+  var handleUpgrade = /* @__PURE__ */ __name25((name, amount) => {
+    const b1 = new ArrayBuffer(8 * 24);
+    const a2 = new DataView(b1);
+    const b2 = new ArrayBuffer(8 * 12);
+    const a3 = new DataView(b2);
+    _N("0xCB5D11F9508A928D", 1, a2, a3, GetHashKey(name), 1084182731, amount, 752097756);
+  }, "handleUpgrade");
+  var _Player = class _Player {
+    /**
+     * @param handle the player handle
+     */
+    constructor(handle) {
+      __publicField(this, "handle");
+      this.handle = handle;
+    }
+    static *AllPlayers(excludeLocalPlayer = true) {
+      for (const ply of GetActivePlayers()) {
+        if (excludeLocalPlayer && ply === GameConstants.PlayerId) {
+          continue;
+        }
+        yield new _Player(ply);
+      }
+    }
+    static fromPedHandle(handle) {
+      return new _Player(NetworkGetPlayerIndexFromPed(handle));
+    }
+    /**
+     * Gets the player from the specified {@param serverId}
+     * @returns the player object, or null if the player didn't exist
+     */
+    static fromServerId(serverId) {
+      if (serverId === GameConstants.ServerId) {
+        return GameConstants.Player;
+      }
+      const player = GetPlayerFromServerId(serverId);
+      if (player === -1) return null;
+      return new _Player(player);
+    }
+    /**
+     * @param [minimumDistance=Number.MAX_VALUE] the minimum distance this should check
+     * @param [fromPlayer=GameConstants.Player] the player to get the distance from
+     * @returns the closest player from {@param fromPlayer} and the distance the player was
+     */
+    static getClosestPlayerWithDistance(minimumDistance = Number.MAX_VALUE, fromPlayer = GameConstants.Player) {
+      const ped = fromPlayer.Ped;
+      const pos = ped.Position;
+      const data = [null, Number.MAX_VALUE];
+      for (const ply of _Player.AllPlayers(true)) {
+        const tgtPed = ply.Ped;
+        const dist = pos.distance(tgtPed.Position);
+        if (dist < data[1] && dist < minimumDistance) {
+          data[0] = ply;
+          data[1] = dist;
+        }
+      }
+      return data;
+    }
+    /**
+     * @param [minimumDistance=Number.MAX_VALUE] the minimum distance this should check
+     * @param [fromPlayer=GameConstants.Player] the player to get the distance from
+     * @returns the closest player from {@param fromPlayer} and the distance the player was
+     */
+    static getClosestPlayer(minimumDistance = Number.MAX_VALUE, fromPlayer = GameConstants.Player) {
+      const data = this.getClosestPlayerWithDistance(minimumDistance, fromPlayer);
+      return data[0];
+    }
+    get Handle() {
+      return this.handle;
+    }
+    get Ped() {
+      return new Ped(GetPlayerPed(this.handle));
+    }
+    get ServerId() {
+      return GetPlayerServerId(this.handle);
+    }
+    /**
+     * Adds the amount of stamina player has on the hud
+     * @param amount the amount of upgrade to give 6 is half the bar while 12 is the full bar
+     */
+    addStaminaUpgrade(amount) {
+      handleUpgrade("UPGRADE_STAMINA_TANK_1", amount);
+    }
+    addHealthUpgrade(amount) {
+      handleUpgrade("UPGRADE_HEALTH_TANK_1", amount);
+    }
+    addDeadeyeUpgrade(amount) {
+      handleUpgrade("UPGRADE_DEADEYE_TANK_1", amount);
+    }
+    setOwnsMount(mount) {
+      _N("0xE6D4E435B56D5BD0", this.handle, mount.Handle);
+    }
+  };
+  __name(_Player, "Player");
+  __name25(_Player, "Player");
+  var Player2 = _Player;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/GameConstants.js
+  var __defProp26 = Object.defineProperty;
+  var __name26 = /* @__PURE__ */ __name((target, value) => __defProp26(target, "name", { value, configurable: true }), "__name");
+  var _GameConstants = class _GameConstants {
+    // The player class of the local object
+    static get Player() {
+      if (_GameConstants.player === null) {
+        _GameConstants.player = new Player2(_GameConstants.PlayerId);
+      }
+      return _GameConstants.player;
+    }
+  };
+  __name(_GameConstants, "GameConstants");
+  __name26(_GameConstants, "GameConstants");
+  // the actual player object that will get initialized on the first call to the `get Player()`
+  __publicField(_GameConstants, "player", null);
+  // The player id of the local client
+  __publicField(_GameConstants, "PlayerId", PlayerId());
+  // The server id of the local client.
+  __publicField(_GameConstants, "ServerId", GetPlayerServerId(_GameConstants.PlayerId));
+  var GameConstants = _GameConstants;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/world/createPed.js
+  var __defProp27 = Object.defineProperty;
+  var __name27 = /* @__PURE__ */ __name((target, value) => __defProp27(target, "name", { value, configurable: true }), "__name");
+  async function createPed(model, spawnPos, heading, isNetwork = false, bScriptHostPed = true, p7 = true, p8 = true) {
+    if (!model.IsPed || !model.request(1e3)) {
+      return null;
+    }
+    const pedHandle = CreatePed(
+      model.Hash,
+      spawnPos.x,
+      spawnPos.y,
+      spawnPos.z,
+      heading,
+      isNetwork,
+      bScriptHostPed,
+      p7,
+      p8
+    );
+    if (pedHandle !== 0) {
+      model.markAsNoLongerNeeded();
+      return new Ped(pedHandle);
+    }
+    return null;
+  }
+  __name(createPed, "createPed");
+  __name27(createPed, "createPed");
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/entities/Prop.js
+  var __defProp28 = Object.defineProperty;
+  var __name28 = /* @__PURE__ */ __name((target, value) => __defProp28(target, "name", { value, configurable: true }), "__name");
+  var _Prop = class _Prop extends BaseEntity {
+    constructor() {
+      super(...arguments);
+      __publicField(this, "type", ClassTypes.Prop);
+      __publicField(this, "bones");
+    }
+    get Bones() {
+      this.bones = this.bones ?? new CommonEntityBoneCollection(this);
+      return this.bones;
+    }
+  };
+  __name(_Prop, "Prop");
+  __name28(_Prop, "Prop");
+  var Prop = _Prop;
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/world/createProp.js
+  var __defProp29 = Object.defineProperty;
+  var __name29 = /* @__PURE__ */ __name((target, value) => __defProp29(target, "name", { value, configurable: true }), "__name");
+  async function createProp(model, spawnPos, heading, isNetwork = false, bScriptHostProp = true, dynamic = true, p7 = true, p8 = true) {
+    if (!model.IsProp || !model.request(1e3)) {
+      return null;
+    }
+    const propHandle = CreateObject(
+      model.Hash,
+      spawnPos.x,
+      spawnPos.y,
+      spawnPos.z,
+      isNetwork,
+      bScriptHostProp,
+      dynamic,
+      p7,
+      p8
+    );
+    if (propHandle !== 0) {
+      model.markAsNoLongerNeeded();
+      return new Prop(propHandle);
+    }
+    return null;
+  }
+  __name(createProp, "createProp");
+  __name29(createProp, "createProp");
+
+  // node_modules/.pnpm/@nativewrappers+redm@0.0.141/node_modules/@nativewrappers/redm/enums/AnimationFlags.js
+  var AnimationFlags = /* @__PURE__ */ ((AnimationFlags2) => {
+    AnimationFlags2[AnimationFlags2["Looping"] = 1] = "Looping";
+    AnimationFlags2[AnimationFlags2["HoldLastFrame"] = 2] = "HoldLastFrame";
+    AnimationFlags2[AnimationFlags2["NotInterruptable"] = 4] = "NotInterruptable";
+    AnimationFlags2[AnimationFlags2["UpperBody"] = 8] = "UpperBody";
+    AnimationFlags2[AnimationFlags2["Secondary"] = 16] = "Secondary";
+    AnimationFlags2[AnimationFlags2["AbortOnPedMovement"] = 32] = "AbortOnPedMovement";
+    AnimationFlags2[AnimationFlags2["Additive"] = 64] = "Additive";
+    AnimationFlags2[AnimationFlags2["OverridePhysics"] = 128] = "OverridePhysics";
+    AnimationFlags2[AnimationFlags2["ExtractInitialOffset"] = 256] = "ExtractInitialOffset";
+    AnimationFlags2[AnimationFlags2["ExitAfterInterrupted"] = 512] = "ExitAfterInterrupted";
+    AnimationFlags2[AnimationFlags2["TagSyncIn"] = 1024] = "TagSyncIn";
+    AnimationFlags2[AnimationFlags2["TagSyncOut"] = 2048] = "TagSyncOut";
+    AnimationFlags2[AnimationFlags2["TagSyncContinuous"] = 4096] = "TagSyncContinuous";
+    AnimationFlags2[AnimationFlags2["ForceStart"] = 8192] = "ForceStart";
+    AnimationFlags2[AnimationFlags2["UseKinematicPhysic"] = 16384] = "UseKinematicPhysic";
+    AnimationFlags2[AnimationFlags2["UseMoverExtractions"] = 32768] = "UseMoverExtractions";
+    AnimationFlags2[AnimationFlags2["DontSuppressLoco"] = 65536] = "DontSuppressLoco";
+    AnimationFlags2[AnimationFlags2["EndsInDeadPose"] = 131072] = "EndsInDeadPose";
+    AnimationFlags2[AnimationFlags2["ActivateRagdollOnCollision"] = 262144] = "ActivateRagdollOnCollision";
+    AnimationFlags2[AnimationFlags2["DontExitOnDeath"] = 524288] = "DontExitOnDeath";
+    AnimationFlags2[AnimationFlags2["AbortOnWeaponDamage"] = 1048576] = "AbortOnWeaponDamage";
+    AnimationFlags2[AnimationFlags2["DisableForcedPhysicsUpdate"] = 2097152] = "DisableForcedPhysicsUpdate";
+    AnimationFlags2[AnimationFlags2["Gesture"] = 4194304] = "Gesture";
+    AnimationFlags2[AnimationFlags2["SkipIfBlockedByHigherPriorityTask"] = 8388608] = "SkipIfBlockedByHigherPriorityTask";
+    AnimationFlags2[AnimationFlags2["UseAbsoluteMover"] = 16777216] = "UseAbsoluteMover";
+    AnimationFlags2[AnimationFlags2["_0xC57F16E7"] = 33554432] = "_0xC57F16E7";
+    AnimationFlags2[AnimationFlags2["UpperBodyTags"] = 67108864] = "UpperBodyTags";
+    AnimationFlags2[AnimationFlags2["ProcessAttachmentOnStart"] = 134217728] = "ProcessAttachmentOnStart";
+    AnimationFlags2[AnimationFlags2["ExpandPedCapsuleFromSkeleton"] = 268435456] = "ExpandPedCapsuleFromSkeleton";
+    AnimationFlags2[AnimationFlags2["BlendoutWrtLastFrame"] = 536870912] = "BlendoutWrtLastFrame";
+    AnimationFlags2[AnimationFlags2["DisablePhysicalActivation"] = 1073741824] = "DisablePhysicalActivation";
+    AnimationFlags2[AnimationFlags2["DisableReleaseEvents"] = -2147483648] = "DisableReleaseEvents";
+    return AnimationFlags2;
+  })(AnimationFlags || {});
+  var IkControlFlags = /* @__PURE__ */ ((IkControlFlags2) => {
+    IkControlFlags2[IkControlFlags2["DisableLegIK"] = 1] = "DisableLegIK";
+    IkControlFlags2[IkControlFlags2["DisableArmIK"] = 2] = "DisableArmIK";
+    IkControlFlags2[IkControlFlags2["DisableHeadIK"] = 4] = "DisableHeadIK";
+    IkControlFlags2[IkControlFlags2["DisableTorsoIK"] = 8] = "DisableTorsoIK";
+    IkControlFlags2[IkControlFlags2["DisableTorsoReact"] = 16] = "DisableTorsoReact";
+    IkControlFlags2[IkControlFlags2["UseLegAllowTags"] = 32] = "UseLegAllowTags";
+    IkControlFlags2[IkControlFlags2["UseLegBlockTags"] = 64] = "UseLegBlockTags";
+    IkControlFlags2[IkControlFlags2["UseArmAllowTags"] = 128] = "UseArmAllowTags";
+    IkControlFlags2[IkControlFlags2["UseArmBlockTags"] = 256] = "UseArmBlockTags";
+    IkControlFlags2[IkControlFlags2["ProcessWeaponHandGrip"] = 512] = "ProcessWeaponHandGrip";
+    IkControlFlags2[IkControlFlags2["UseFPArmLeft"] = 1024] = "UseFPArmLeft";
+    IkControlFlags2[IkControlFlags2["UseFPArmRight"] = 2048] = "UseFPArmRight";
+    IkControlFlags2[IkControlFlags2["_0x88FF50BE"] = 4096] = "_0x88FF50BE";
+    IkControlFlags2[IkControlFlags2["DisableTorsoVehicleIK"] = 8192] = "DisableTorsoVehicleIK";
+    IkControlFlags2[IkControlFlags2["DisableProneIK"] = 16384] = "DisableProneIK";
+    IkControlFlags2[IkControlFlags2["UpperBody"] = 32768] = "UpperBody";
+    IkControlFlags2[IkControlFlags2["UpperBodyTags"] = 65536] = "UpperBodyTags";
+    IkControlFlags2[IkControlFlags2["_0xFCDC149B"] = 131072] = "_0xFCDC149B";
+    IkControlFlags2[IkControlFlags2["_0x5465E64A"] = 262144] = "_0x5465E64A";
+    IkControlFlags2[IkControlFlags2["DisableLegPostureIK"] = 524288] = "DisableLegPostureIK";
+    IkControlFlags2[IkControlFlags2["_0x32939A0E"] = 1048576] = "_0x32939A0E";
+    IkControlFlags2[IkControlFlags2["BlockNonAnimSceneLooks"] = 2097152] = "BlockNonAnimSceneLooks";
+    IkControlFlags2[IkControlFlags2["_0x3CC5DD38"] = 4194304] = "_0x3CC5DD38";
+    IkControlFlags2[IkControlFlags2["_0xB819088C"] = 8388608] = "_0xB819088C";
+    IkControlFlags2[IkControlFlags2["DisableContourIk"] = 16777216] = "DisableContourIk";
+    IkControlFlags2[IkControlFlags2["_0xF9E28A5F"] = 33554432] = "_0xF9E28A5F";
+    IkControlFlags2[IkControlFlags2["_0x983AE6C1"] = 67108864] = "_0x983AE6C1";
+    IkControlFlags2[IkControlFlags2["_0x5B5D2BEF"] = 134217728] = "_0x5B5D2BEF";
+    IkControlFlags2[IkControlFlags2["_0xA4F64B54"] = 268435456] = "_0xA4F64B54";
+    IkControlFlags2[IkControlFlags2["DisableTwoBokeIK"] = 536870912] = "DisableTwoBokeIK";
+    IkControlFlags2[IkControlFlags2["_0x0C1380EC"] = 1073741824] = "_0x0C1380EC";
+    return IkControlFlags2;
+  })(IkControlFlags || {});
+
+  // client/ped-handler.ts
+  var pedConfigs = [];
+  var activePeds = /* @__PURE__ */ new Map();
+  function getConfigKey(config) {
+    return `${config.coords.x}_${config.coords.y}_${config.coords.z}`;
+  }
+  __name(getConfigKey, "getConfigKey");
+  function isPlayerNearCoords(playerPos, targetPos, distance) {
+    const dx = playerPos.x - targetPos.x;
+    const dy = playerPos.y - targetPos.y;
+    const dz = playerPos.z - targetPos.z;
+    return Math.sqrt(dx * dx + dy * dy + dz * dz) <= distance;
+  }
+  __name(isPlayerNearCoords, "isPlayerNearCoords");
+  async function processSpawning(playerPos) {
+    for (const config of pedConfigs) {
+      const key = getConfigKey(config);
+      const isNear = isPlayerNearCoords(playerPos, config.coords, config.spawnDistance);
+      const isSpawned = activePeds.has(key);
+      if (isNear && !isSpawned) {
+        await spawnPed(config, key);
+      } else if (!isNear && isSpawned) {
+        despawnPed(key);
+      }
+    }
+  }
+  __name(processSpawning, "processSpawning");
+  async function spawnPed(config, key) {
+    const ped = await createPed(new Model(config.modelName), config.coords, 0, false, true);
+    if (!ped) return;
+    SetRandomOutfitVariation(ped.Handle, true);
+    if (config.heading) {
+      ped.Heading = config.heading;
+    }
+    if (config.animation) {
+      await ped.Tasks.playAnimation(
+        config.animation.dict,
+        config.animation.anim,
+        8,
+        8,
+        -1,
+        1,
+        AnimationFlags.Looping,
+        IkControlFlags.UpperBody
+      );
+    }
+    let prop = null;
+    if (config.propData) {
+      prop = await createProp(new Model(config.propData.model), ped.Position, 0, true, true);
+      if (prop) {
+        AttachEntityToEntity(
+          prop.Handle,
+          ped.Handle,
+          config.propData.boneId,
+          config.propData.offset[0],
+          config.propData.offset[1],
+          config.propData.offset[2],
+          config.propData.rotation[0],
+          config.propData.rotation[1],
+          config.propData.rotation[2],
+          true,
+          false,
+          false,
+          true,
+          1,
+          true
+        );
+      }
+    }
+    activePeds.set(key, { ped, config, prop });
+  }
+  __name(spawnPed, "spawnPed");
+  function despawnPed(key) {
+    const activePed = activePeds.get(key);
+    if (!activePed) return;
+    if (activePed.prop) {
+      activePed.prop.delete();
+    }
+    if (activePed.ped) {
+      activePed.ped.delete();
+    }
+    activePeds.delete(key);
+  }
+  __name(despawnPed, "despawnPed");
+  function cleanupPeds() {
+    for (const [key, activePed] of activePeds) {
+      if (activePed.prop) {
+        activePed.prop.delete();
+      }
+      if (activePed.ped) {
+        activePed.ped.delete();
+      }
+      activePeds.delete(key);
+    }
+  }
+  __name(cleanupPeds, "cleanupPeds");
+
+  // client/main.ts
+  setTick(async () => {
+    const playerPed = PlayerPedId();
+    if (!playerPed) {
+      await Delay(500);
+      return;
+    }
+    const coords = GetEntityCoords(playerPed, true, true);
+    const playerPos = new Vector3(coords[0], coords[1], coords[2]);
+    await processSpawning(playerPos);
+    await Delay(500);
+  });
+  on("onResourceStop", (resourceName) => {
+    if (resourceName !== GetCurrentResourceName()) return;
+    console.log(`Restarting ${resourceName}`);
+    cleanupPeds();
+  });
+})();