bun-memory 1.1.47 → 1.1.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun-memory",
-  "version": "1.1.47",
+  "version": "1.1.49",
   "author": "Stev Peifer <stev@bell.net>",
   "repository": {
     "type": "git",

package/structs/Memory.ts

@@ -1533,26 +1533,71 @@ class Memory {
   }
 
   /**
-   * Reads or writes a TArray (Data at 0x00, Count at 0x08, Max at 0x0c) as an Int16Array.
+   * Reads or writes a TArray (Data at 0x00, Count at 0x08, Max at 0x0c) as a UTF-8 string.
    * @param address Address of the TArray structure.
-   * @param values Optional Int16Array to write.
+   * @param value Optional string to write.
    * @param force When writing, if true temporarily changes page protection to allow the write.
-   * @returns An Int16Array containing the elements, or this instance if writing.
+   * @returns The string, or this instance if writing.
    * @example
    * ```ts
    * const rl = new Memory('RocketLeague.exe');
-   * const myArray = rl.tArrayI16(0x12345678n);
-   * rl.tArrayI16(0x12345678n, new Int16Array([1, 2, 3]));
+   * const myString = rl.tArrayChar(0x12345678n);
+   * rl.tArrayChar(0x12345678n, 'hello');
    * ```
    */
-  public tArrayI16(address: bigint): Int16Array;
-  public tArrayI16(address: bigint, values: Int16Array, force?: boolean): this;
-  public tArrayI16(address: bigint, values?: Int16Array, force?: boolean): Int16Array | this {
+  public tArrayChar(address: bigint): string;
+  public tArrayChar(address: bigint, value: string, force?: boolean): this;
+  public tArrayChar(address: bigint, value?: string, force?: boolean): string | this {
     const dataPtr = this.u64(address);
 
-    if (values === undefined) {
+    if (value === undefined) {
       const count = this.u32(address + 0x08n);
-      const scratch = new Int16Array(count);
+
+      if (count === 0x00) {
+        return '';
+      }
+
+      const scratch = Buffer.allocUnsafe(count - 0x01);
+
+      void this.read(dataPtr, scratch);
+
+      return scratch.toString('utf8');
+    }
+
+    const scratch = Buffer.from(value, 'utf8');
+
+    this.u32(address + 0x08n, scratch.length + 0x01, force);
+
+    void this.write(dataPtr, scratch, force);
+
+    return this;
+  }
+
+  /**
+   * Reads or writes a TArray (Data at 0x00, Count at 0x08, Max at 0x0c) as a Float32Array.
+   * @param address Address of the TArray structure.
+   * @param values Optional Float32Array to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
+   * @returns A Float32Array containing the elements, or this instance if writing.
+   * @example
+   * ```ts
+   * const rl = new Memory('RocketLeague.exe');
+   * const myArray = rl.tArrayF32(0x12345678n);
+   * rl.tArrayF32(0x12345678n, new Float32Array([1.0, 2.0, 3.0]));
+   * ```
+   */
+  public tArrayF32(address: bigint): Float32Array;
+  public tArrayF32(address: bigint, values: Float32Array, force?: boolean): this;
+  public tArrayF32(address: bigint, values?: Float32Array, force?: boolean): Float32Array | this {
+    const dataPtr = this.u64(address);
+
+    if (values === undefined) {
+      const count = this.u32(address + 0x08n),
+            scratch = new Float32Array(count); // prettier-ignore
+
+      if (count === 0) {
+        return scratch;
+      }
 
       void this.read(dataPtr, scratch);
 
@@ -1567,26 +1612,30 @@ class Memory {
   }
 
   /**
-   * Reads or writes a TArray (Data at 0x00, Count at 0x08, Max at 0x0c) as an Int32Array.
+   * Reads or writes a TArray (Data at 0x00, Count at 0x08, Max at 0x0c) as a Float64Array.
    * @param address Address of the TArray structure.
-   * @param values Optional Int32Array to write.
+   * @param values Optional Float64Array to write.
    * @param force When writing, if true temporarily changes page protection to allow the write.
-   * @returns An Int32Array containing the elements, or this instance if writing.
+   * @returns A Float64Array containing the elements, or this instance if writing.
    * @example
    * ```ts
    * const rl = new Memory('RocketLeague.exe');
-   * const myArray = rl.tArrayI32(0x12345678n);
-   * rl.tArrayI32(0x12345678n, new Int32Array([1, 2, 3]));
+   * const myArray = rl.tArrayF64(0x12345678n);
+   * rl.tArrayF64(0x12345678n, new Float64Array([1.0, 2.0, 3.0]));
    * ```
    */
-  public tArrayI32(address: bigint): Int32Array;
-  public tArrayI32(address: bigint, values: Int32Array, force?: boolean): this;
-  public tArrayI32(address: bigint, values?: Int32Array, force?: boolean): Int32Array | this {
+  public tArrayF64(address: bigint): Float64Array;
+  public tArrayF64(address: bigint, values: Float64Array, force?: boolean): this;
+  public tArrayF64(address: bigint, values?: Float64Array, force?: boolean): Float64Array | this {
     const dataPtr = this.u64(address);
 
     if (values === undefined) {
-      const count = this.u32(address + 0x08n);
-      const scratch = new Int32Array(count);
+      const count = this.u32(address + 0x08n),
+            scratch = new Float64Array(count); // prettier-ignore
+
+      if (count === 0) {
+        return scratch;
+      }
 
       void this.read(dataPtr, scratch);
 
@@ -1601,26 +1650,30 @@ class Memory {
   }
 
   /**
-   * Reads or writes a TArray (Data at 0x00, Count at 0x08, Max at 0x0c) as a BigInt64Array.
+   * Reads or writes a TArray (Data at 0x00, Count at 0x08, Max at 0x0c) as an Int16Array.
    * @param address Address of the TArray structure.
-   * @param values Optional BigInt64Array to write.
+   * @param values Optional Int16Array to write.
    * @param force When writing, if true temporarily changes page protection to allow the write.
-   * @returns A BigInt64Array containing the elements, or this instance if writing.
+   * @returns An Int16Array containing the elements, or this instance if writing.
    * @example
    * ```ts
    * const rl = new Memory('RocketLeague.exe');
-   * const myArray = rl.tArrayI64(0x12345678n);
-   * rl.tArrayI64(0x12345678n, new BigInt64Array([1n, 2n, 3n]));
+   * const myArray = rl.tArrayI16(0x12345678n);
+   * rl.tArrayI16(0x12345678n, new Int16Array([1, 2, 3]));
    * ```
    */
-  public tArrayI64(address: bigint): BigInt64Array;
-  public tArrayI64(address: bigint, values: BigInt64Array, force?: boolean): this;
-  public tArrayI64(address: bigint, values?: BigInt64Array, force?: boolean): BigInt64Array | this {
+  public tArrayI16(address: bigint): Int16Array;
+  public tArrayI16(address: bigint, values: Int16Array, force?: boolean): this;
+  public tArrayI16(address: bigint, values?: Int16Array, force?: boolean): Int16Array | this {
     const dataPtr = this.u64(address);
 
     if (values === undefined) {
-      const count = this.u32(address + 0x08n);
-      const scratch = new BigInt64Array(count);
+      const count = this.u32(address + 0x08n),
+            scratch = new Int16Array(count); // prettier-ignore
+
+      if (count === 0) {
+        return scratch;
+      }
 
       void this.read(dataPtr, scratch);
 
@@ -1635,26 +1688,30 @@ class Memory {
   }
 
   /**
-   * Reads or writes a TArray (Data at 0x00, Count at 0x08, Max at 0x0c) as a Float32Array.
+   * Reads or writes a TArray (Data at 0x00, Count at 0x08, Max at 0x0c) as an Int32Array.
    * @param address Address of the TArray structure.
-   * @param values Optional Float32Array to write.
+   * @param values Optional Int32Array to write.
    * @param force When writing, if true temporarily changes page protection to allow the write.
-   * @returns A Float32Array containing the elements, or this instance if writing.
+   * @returns An Int32Array containing the elements, or this instance if writing.
    * @example
    * ```ts
    * const rl = new Memory('RocketLeague.exe');
-   * const myArray = rl.tArrayF32(0x12345678n);
-   * rl.tArrayF32(0x12345678n, new Float32Array([1.0, 2.0, 3.0]));
+   * const myArray = rl.tArrayI32(0x12345678n);
+   * rl.tArrayI32(0x12345678n, new Int32Array([1, 2, 3]));
    * ```
    */
-  public tArrayF32(address: bigint): Float32Array;
-  public tArrayF32(address: bigint, values: Float32Array, force?: boolean): this;
-  public tArrayF32(address: bigint, values?: Float32Array, force?: boolean): Float32Array | this {
+  public tArrayI32(address: bigint): Int32Array;
+  public tArrayI32(address: bigint, values: Int32Array, force?: boolean): this;
+  public tArrayI32(address: bigint, values?: Int32Array, force?: boolean): Int32Array | this {
     const dataPtr = this.u64(address);
 
     if (values === undefined) {
-      const count = this.u32(address + 0x08n);
-      const scratch = new Float32Array(count);
+      const count = this.u32(address + 0x08n),
+            scratch = new Int32Array(count); // prettier-ignore
+
+      if (count === 0) {
+        return scratch;
+      }
 
       void this.read(dataPtr, scratch);
 
@@ -1669,26 +1726,30 @@ class Memory {
   }
 
   /**
-   * Reads or writes a TArray (Data at 0x00, Count at 0x08, Max at 0x0c) as a Float64Array.
+   * Reads or writes a TArray (Data at 0x00, Count at 0x08, Max at 0x0c) as a BigInt64Array.
    * @param address Address of the TArray structure.
-   * @param values Optional Float64Array to write.
+   * @param values Optional BigInt64Array to write.
    * @param force When writing, if true temporarily changes page protection to allow the write.
-   * @returns A Float64Array containing the elements, or this instance if writing.
+   * @returns A BigInt64Array containing the elements, or this instance if writing.
    * @example
    * ```ts
    * const rl = new Memory('RocketLeague.exe');
-   * const myArray = rl.tArrayF64(0x12345678n);
-   * rl.tArrayF64(0x12345678n, new Float64Array([1.0, 2.0, 3.0]));
+   * const myArray = rl.tArrayI64(0x12345678n);
+   * rl.tArrayI64(0x12345678n, new BigInt64Array([1n, 2n, 3n]));
    * ```
    */
-  public tArrayF64(address: bigint): Float64Array;
-  public tArrayF64(address: bigint, values: Float64Array, force?: boolean): this;
-  public tArrayF64(address: bigint, values?: Float64Array, force?: boolean): Float64Array | this {
+  public tArrayI64(address: bigint): BigInt64Array;
+  public tArrayI64(address: bigint, values: BigInt64Array, force?: boolean): this;
+  public tArrayI64(address: bigint, values?: BigInt64Array, force?: boolean): BigInt64Array | this {
     const dataPtr = this.u64(address);
 
     if (values === undefined) {
-      const count = this.u32(address + 0x08n);
-      const scratch = new Float64Array(count);
+      const count = this.u32(address + 0x08n),
+            scratch = new BigInt64Array(count); // prettier-ignore
+
+      if (count === 0) {
+        return scratch;
+      }
 
       void this.read(dataPtr, scratch);
 
@@ -1721,8 +1782,12 @@ class Memory {
     const dataPtr = this.u64(address);
 
     if (values === undefined) {
-      const count = this.u32(address + 0x08n);
-      const scratch = new Int8Array(count);
+      const count = this.u32(address + 0x08n),
+            scratch = new Int8Array(count); // prettier-ignore
+
+      if (count === 0) {
+        return scratch;
+      }
 
       void this.read(dataPtr, scratch);
 
@@ -1736,6 +1801,62 @@ class Memory {
     return this;
   }
 
+  /**
+   * Reads or writes a TArray (Data at 0x00, Count at 0x08, Max at 0x0c) as an array of raw buffers.
+   * Useful for reading/writing arrays of structs or custom-sized elements.
+   * @param address Address of the TArray structure.
+   * @param dataSize Size in bytes of each element.
+   * @param values Optional array of Buffers to write.
+   * @param force When writing, if true temporarily changes page protection to allow the write.
+   * @returns An array of Buffers, one per element, or this instance if writing.
+   * @example
+   * ```ts
+   * const rl = new Memory('RocketLeague.exe');
+   * const structs = rl.tArrayRaw(0x12345678n, 0x18); // Array of 0x18-byte buffers
+   * rl.tArrayRaw(0x12345678n, [buffer1, buffer2]);
+   * ```
+   */
+  public tArrayRaw(address: bigint, dataSize: number): Buffer[];
+  public tArrayRaw(address: bigint, values: Buffer[], force?: boolean): this;
+  public tArrayRaw(address: bigint, dataSizeOrValues: number | Buffer[], force?: boolean): Buffer[] | this {
+    const dataPtr = this.u64(address);
+
+    if (typeof dataSizeOrValues === 'number') {
+      const count = this.u32(address + 0x08n),
+            dataSize = dataSizeOrValues; // prettier-ignore
+
+      if (count === 0) {
+        return [];
+      }
+
+      const scratch = Buffer.allocUnsafe(count * dataSize);
+
+      void this.read(dataPtr, scratch);
+
+      const result: Buffer[] = new Array(count);
+
+      for (let i = 0; i < count; i++) {
+        result[i] = scratch.subarray(i * dataSize, (i + 1) * dataSize);
+      }
+
+      return result;
+    }
+
+    const values = dataSizeOrValues;
+    const dataSize = values[0].length;
+    const scratch = Buffer.allocUnsafe(values.length * dataSize);
+
+    for (let i = 0; i < values.length; i++) {
+      values[i].copy(scratch, i * dataSize);
+    }
+
+    this.u32(address + 0x08n, values.length, force);
+
+    void this.write(dataPtr, scratch, force);
+
+    return this;
+  }
+
   /**
    * Reads or writes a TArray (Data at 0x00, Count at 0x08, Max at 0x0c) as a Uint16Array.
    * @param address Address of the TArray structure.
@@ -1755,8 +1876,12 @@ class Memory {
     const dataPtr = this.u64(address);
 
     if (values === undefined) {
-      const count = this.u32(address + 0x08n);
-      const scratch = new Uint16Array(count);
+      const count = this.u32(address + 0x08n),
+            scratch = new Uint16Array(count); // prettier-ignore
+
+      if (count === 0) {
+        return scratch;
+      }
 
       void this.read(dataPtr, scratch);
 
@@ -1789,8 +1914,12 @@ class Memory {
     const dataPtr = this.u64(address);
 
     if (values === undefined) {
-      const count = this.u32(address + 0x08n);
-      const scratch = new Uint32Array(count);
+      const count = this.u32(address + 0x08n),
+            scratch = new Uint32Array(count); // prettier-ignore
+
+      if (count === 0) {
+        return scratch;
+      }
 
       void this.read(dataPtr, scratch);
 
@@ -1823,8 +1952,12 @@ class Memory {
     const dataPtr = this.u64(address);
 
     if (values === undefined) {
-      const count = this.u32(address + 0x08n);
-      const scratch = new BigUint64Array(count);
+      const count = this.u32(address + 0x08n),
+            scratch = new BigUint64Array(count); // prettier-ignore
+
+      if (count === 0) {
+        return scratch;
+      }
 
       void this.read(dataPtr, scratch);
 
@@ -1857,8 +1990,12 @@ class Memory {
     const dataPtr = this.u64(address);
 
     if (values === undefined) {
-      const count = this.u32(address + 0x08n);
-      const scratch = new Uint8Array(count);
+      const count = this.u32(address + 0x08n),
+            scratch = new Uint8Array(count); // prettier-ignore
+
+      if (count === 0) {
+        return scratch;
+      }
 
       void this.read(dataPtr, scratch);
 
@@ -1896,47 +2033,6 @@ class Memory {
     return this.tArrayU64(address, values, force);
   }
 
-  /**
-   * Reads or writes a TArray (Data at 0x00, Count at 0x08, Max at 0x0c) as a UTF-8 string.
-   * @param address Address of the TArray structure.
-   * @param value Optional string to write.
-   * @param force When writing, if true temporarily changes page protection to allow the write.
-   * @returns The string, or this instance if writing.
-   * @example
-   * ```ts
-   * const rl = new Memory('RocketLeague.exe');
-   * const myString = rl.tArrayChar(0x12345678n);
-   * rl.tArrayChar(0x12345678n, 'hello');
-   * ```
-   */
-  public tArrayChar(address: bigint): string;
-  public tArrayChar(address: bigint, value: string, force?: boolean): this;
-  public tArrayChar(address: bigint, value?: string, force?: boolean): string | this {
-    const dataPtr = this.u64(address);
-
-    if (value === undefined) {
-      const count = this.u32(address + 0x08n);
-
-      if (count === 0x00) {
-        return '';
-      }
-
-      const scratch = Buffer.allocUnsafe(count - 0x01);
-
-      void this.read(dataPtr, scratch);
-
-      return scratch.toString('utf8');
-    }
-
-    const scratch = Buffer.from(value, 'utf8');
-
-    this.u32(address + 0x08n, scratch.length + 0x01, force);
-
-    void this.write(dataPtr, scratch, force);
-
-    return this;
-  }
-
   /**
    * Reads or writes a TArray (Data at 0x00, Count at 0x08, Max at 0x0c) as a UTF-16LE string.
    * This is the format used by FName/FString in Unreal Engine.