bun-memory 1.1.34 → 1.1.35

package/README.md

@@ -52,7 +52,8 @@ cs2.close();
 ## API Highlights
 
 - `follow(address, offsets)` — Follow a pointer chain
-- `pattern(needle, address, length)` — Find a byte pattern in memory (supports wildcards)
+- `indexOf(needle, address, length, [all])` — Search for a buffer or array in memory (returns all matches if all=true)
+- `pattern(needle, address, length, [all])` — Find a byte pattern in memory (supports wildcards, returns all matches if all=true)
 - `read(address, scratch)` — Read memory into a scratch (no allocations)
 - `write(address, scratch)` — Write a scratch to memory
 - Module map: `memory.modules['client.dll']`
@@ -83,10 +84,16 @@ void cs2.read(0x12345678n, array); // Fills array in-place
 const needle = 'deadbeef';
 // const needle = 'de**beef';
 // const needle = 'de????ef';
+// Find first match
 const address = cs2.pattern(needle, 0x10000000n, 0x1000);
 if (address !== -1n) {
   console.log(`Found at 0x${address.toString(16)}`);
 }
+// Find all matches
+const allAddresses = cs2.pattern(needle, 0x10000000n, 0x1000, true);
+for (const addr of allAddresses) {
+  console.log(`Found at 0x${addr.toString(16)}`);
+}
 ```
 
 ## Example: Pointer Chains
@@ -103,11 +110,16 @@ const address = cs2.follow(0x10000000n, [0x10n, 0x20n]);
 const needle = Buffer.from([0x01, 0x02, 0x03]);
 // const needle = new Uint8Array([0x01, 0x02, 0x03]);
 // const needle = new Uint32Array([0x012345, 0x123456, 0x234567]);
-// …etc…
+// Find first match
 const address = cs2.indexOf(needle, 0x10000000n, 0x1000);
 if (address !== -1n) {
   console.log(`Found at 0x${address.toString(16)}`);
 }
+// Find all matches
+const allAddresses = cs2.indexOf(needle, 0x10000000n, 0x1000, true);
+for (const addr of allAddresses) {
+  console.log(`Found at 0x${addr.toString(16)}`);
+}
 ```
 
 ## Example: Typed Arrays
@@ -117,7 +129,6 @@ if (address !== -1n) {
 const array = cs2.f32Array(0x12345678n, 4); // Float32Array of length 4
 // const array = cs2.u64Array(0x12345678n, 4);
 // const array = cs2.vector3Array(0x12345678n, 4);
-// …etc…
 cs2.i32Array(0x12345678n, new Int32Array([1, 2, 3, 4]));
 cs2.u64Array(0x12345678n, new BigUint64Array([1, 2, 3, 4]));
 cs2.vector3Array(0x12345678n, [{ x: 1, y: 2, z: 3 }]);

package/example/trigger-bot.ts

@@ -38,23 +38,6 @@ if (ClientPtr === undefined) {
   throw new TypeError('ClientPtr must not be undefined.');
 }
 
-// Get client.dll…
-const client = cs2.modules['client.dll'];
-
-if (client === undefined) {
-  throw new Error('client must not be undefined…');
-}
-
-// Byte pattern for AddNametag
-const needle = '40555356488dac24????????4881ec????????488bda488bf14885c9';
-
-// Find a byte pattern in memory (supports wildcards: ** and ??)…
-const addNametag = cs2.pattern(needle, client.base, client.size);
-
-if (addNametag !== -1n) {
-  console.log(`Found at 0x${addNametag.toString(16)}`); // Found at 0x7ffc8964e490
-}
-
 // Create a cache for class name strings… 🫠…
 const Cache_Names = new Map<bigint, string>();
 

package/package.json

@@ -22,7 +22,7 @@
     "url": "git://github.com/obscuritysrl/bun-memory.git"
   },
   "type": "module",
-  "version": "1.1.34",
+  "version": "1.1.35",
   "main": "./index.ts",
   "keywords": [
     "bun",

package/structs/Memory.ts

@@ -124,7 +124,8 @@ class Memory {
    */
   private static readonly Patterns = {
     MatchAll: /(?:[0-9A-Fa-f]{2})+/g,
-    Test: /^(?:\*{2}|[0-9A-Fa-f]{2}|\?{2})+$/,
+    Test: /^(?=.*[0-9A-Fa-f]{2})(?:\*{2}|\?{2}|[0-9A-Fa-f]{2})+$/,
+    // Test: /^(?:\*{2}|[0-9A-Fa-f]{2}|\?{2})+$/,
   };
 
   /**
@@ -316,100 +317,6 @@ class Memory {
     return;
   }
 
-  /**
-   * Follows a pointer chain with offsets.
-   * @param address Base address.
-   * @param offsets Array of pointer offsets.
-   * @returns Final address after following the chain, or -1n if any pointer is null.
-   * @example
-   * ```ts
-   * const cs2 = new Memory('cs2.exe');
-   * const myAddress = cs2.follow(0x10000000n, [0x10n, 0x20n]);
-   * ```
-   */
-  public follow(address: bigint, offsets: readonly bigint[]): bigint {
-    const last = offsets.length - 1;
-
-    for (let i = 0; i < last; i++) {
-      address = this.u64(address + offsets[i]);
-
-      if (address === 0n) {
-        return -1n;
-      }
-    }
-
-    return address + (offsets[last] ?? 0n);
-  }
-
-  /**
-   * Finds the address of a byte pattern in memory. `**` and `??` match any byte.
-   * @param needle Hex string pattern to search for (e.g., 'deadbeed', 'dead**ef', 'dead??ef').
-   * @param address Start address to search.
-   * @param length Number of bytes to search.
-   * @returns Address of the pattern if found, or -1n.
-   * @example
-   * ```ts
-   * const cs2 = new Memory('cs2.exe');
-   * const addr = cs2.pattern('dead**ef', 0x10000000n, 0x1000);
-   * ```
-   */
-  public pattern(needle: string, address: bigint, length: number): bigint {
-    const test = Memory.Patterns.Test.test(needle);
-
-    if (!test) {
-      return -1n;
-    }
-
-    const tokens = [...needle.matchAll(Memory.Patterns.MatchAll)]
-      .map((match) => ({ buffer: Buffer.from(match[0], 'hex'), index: match.index >>> 1, length: match[0].length >>> 1 })) //
-      .sort(({ length: a }, { length: b }) => b - a);
-
-    if (tokens.length === 0) {
-      return needle.length >>> 1 <= length ? address : -1n;
-    }
-
-    const anchor = tokens.shift()!;
-
-    const haystack = this.buffer(address, length);
-
-    const end = length - (needle.length >>> 1);
-    let   start = haystack.indexOf(anchor.buffer); // prettier-ignore
-
-    if (start === -1) {
-      return -1n;
-    }
-
-    outer: do {
-      const base = start - anchor.index;
-
-      if (base < 0) {
-        continue;
-      } else if (base > end) {
-        return -1n;
-      }
-
-      for (const { buffer, index, length } of tokens) {
-        const sourceEnd = base + index + length,
-          sourceStart = base + index,
-          target = buffer,
-          targetEnd = length,
-          targetStart = 0;
-
-        const compare = haystack.compare(target, targetStart, targetEnd, sourceStart, sourceEnd);
-
-        if (compare !== 0) {
-          continue outer;
-        }
-      }
-
-      return address + BigInt(base);
-
-      // Finish…
-    } while ((start = haystack.indexOf(anchor.buffer, start + 0x01)) !== -1);
-
-    return -1n;
-  }
-
   /**
    * Reads memory into a buffer.
    * @param address Address to read from.
@@ -2002,30 +1909,190 @@ class Memory {
 
   // Public utility methods…
 
+  /**
+   * Follows a pointer chain with offsets.
+   * @param address Base address.
+   * @param offsets Array of pointer offsets.
+   * @returns Final address after following the chain, or -1n if any pointer is null.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * const myAddress = cs2.follow(0x10000000n, [0x10n, 0x20n]);
+   * ```
+   */
+  public follow(address: bigint, offsets: readonly bigint[]): bigint {
+    const last = offsets.length - 1;
+
+    for (let i = 0; i < last; i++) {
+      address = this.u64(address + offsets[i]);
+
+      if (address === 0n) {
+        return -1n;
+      }
+    }
+
+    return address + (offsets[last] ?? 0n);
+  }
+
   /**
    * Finds the address of a buffer within a memory region.
-   * @param needle Buffer to search for.
+   * @param needle Buffer or typed array to search for.
    * @param address Start address.
    * @param length Number of bytes to search.
-   * @returns Address of the buffer if found, or -1n.
+   * @param all If true, returns all matches as an array. If false or omitted, returns the first match or -1n.
+   * @returns Address of the buffer if found, or -1n. If all is true, returns an array of addresses.
    * @example
    * ```ts
    * const cs2 = new Memory('cs2.exe');
-   * const myAddress = cs2.indexOf(new Uint8Array([1,2,3]), 0x10000000n, 100);
+   * const needle = Buffer.from('Hello world!');
+   * // const needle = Buffer.from([0x01, 0x02, 0x03]);
+   * // const needle = new Uint8Array([0x01, 0x02, 0x03]);
+   * // const needle = new Float32Array([0x01, 0x02, 0x03]);
+   * // Find first match
+   * const address = cs2.indexOf(needle, 0x10000000n, 100);
+   * // Find all matches
+   * const allAddressess = cs2.indexOf(needle, 0x10000000n, 100, true);
    * ```
    */
-  public indexOf(needle: Scratch, address: bigint, length: number): bigint {
+  public indexOf(needle: Scratch, address: bigint, length: number): bigint;
+  public indexOf(needle: Scratch, address: bigint, length: number, all: false): bigint;
+  public indexOf(needle: Scratch, address: bigint, length: number, all: true): bigint[];
+  public indexOf(needle: Scratch, address: bigint, length: number, all: boolean = false): bigint | bigint[] {
     const haystack = Buffer.allocUnsafe(length);
 
-    this.read(address, haystack);
-
     const needleBuffer = ArrayBuffer.isView(needle) //
       ? Buffer.from(needle.buffer, needle.byteOffset, needle.byteLength)
       : Buffer.from(needle);
 
-    const indexOf = haystack.indexOf(needleBuffer);
+    this.read(address, haystack);
+
+    if (!all) {
+      const indexOf = haystack.indexOf(needleBuffer);
+
+      return indexOf !== -1 ? BigInt(indexOf) + address : -1n;
+    }
+
+    const results: bigint[] = [];
+
+    let start = haystack.indexOf(needleBuffer);
+
+    if (start === -1) {
+      return results;
+    }
+
+    do {
+      results.push(address + BigInt(start));
+    } while ((start = haystack.indexOf(needleBuffer, start + 0x01)) !== -1);
+
+    return results;
+  }
+
+  /**
+   * Finds the address of a byte pattern in memory. `**` and `??` match any byte.
+   * @param needle Hex string pattern to search for (e.g., 'deadbeed', 'dead**ef', 'dead??ef').
+   * @param address Start address to search.
+   * @param length Number of bytes to search.
+   * @param all If true, returns all matches as an array. If false or omitted, returns the first match or -1n.
+   * @returns Address of the pattern if found, or -1n. If all is true, returns an array of addresses.
+   * @example
+   * ```ts
+   * const cs2 = new Memory('cs2.exe');
+   * // Find first match
+   * const address = cs2.pattern('dead**ef', 0x10000000n, 0x1000);
+   * // Find all matches
+   * const allAddresses = cs2.pattern('dead**ef', 0x10000000n, 0x1000, true);
+   * ```
+   */
+  public pattern(needle: string, address: bigint, length: number): bigint;
+  public pattern(needle: string, address: bigint, length: number, all: false): bigint;
+  public pattern(needle: string, address: bigint, length: number, all: true): bigint[];
+  public pattern(needle: string, address: bigint, length: number, all: boolean = false): bigint | bigint[] {
+    const test = Memory.Patterns.Test.test(needle);
+
+    if (!test) {
+      return !all ? -1n : [];
+    }
+
+    // The RegExp test ensures that we have at least one token…
+
+    const tokens = [...needle.matchAll(Memory.Patterns.MatchAll)]
+      .map((match) => ({ buffer: Buffer.from(match[0], 'hex'), index: match.index >>> 1, length: match[0].length >>> 1 })) //
+      .sort(({ length: a }, { length: b }) => b - a);
+
+    const anchor = tokens.shift()!;
+
+    const haystack = this.buffer(address, length);
+
+    const end = length - (needle.length >>> 1);
+    let   start = haystack.indexOf(anchor.buffer); // prettier-ignore
+
+    if (start === -1) {
+      return !all ? -1n : [];
+    }
+
+    if (!all) {
+      outer: do {
+        const base = start - anchor.index;
+
+        if (base < 0) {
+          continue;
+        }
+
+        if (base > end) {
+          return -1n;
+        }
+
+        for (const { buffer, index, length } of tokens) {
+          const sourceEnd = base + index + length,
+                sourceStart = base + index,
+                target = buffer,
+                targetEnd = length,
+                targetStart = 0; // prettier-ignore
+
+          const compare = haystack.compare(target, targetStart, targetEnd, sourceStart, sourceEnd);
+
+          if (compare !== 0) {
+            continue outer;
+          }
+        }
+
+        return address + BigInt(base);
+      } while ((start = haystack.indexOf(anchor.buffer, start + 0x01)) !== -1);
+
+      return -1n;
+    }
+
+    const results: bigint[] = [];
+
+    outer: do {
+      const base = start - anchor.index;
+
+      if (base < 0) {
+        continue;
+      }
+
+      if (base > end) {
+        return results;
+      }
+
+      for (const { buffer, index, length } of tokens) {
+        const sourceEnd = base + index + length,
+              sourceStart = base + index,
+              target = buffer,
+              targetEnd = length,
+              targetStart = 0; // prettier-ignore
+
+        const compare = haystack.compare(target, targetStart, targetEnd, sourceStart, sourceEnd);
+
+        if (compare !== 0) {
+          continue outer;
+        }
+      }
+
+      results.push(address + BigInt(base));
+    } while ((start = haystack.indexOf(anchor.buffer, start + 0x01)) !== -1);
 
-    return indexOf !== -1 ? BigInt(indexOf) + address : -1n;
+    return results;
   }
 }