v 1.0

Author: coyotte508

packages/gearhash-wasm/README.md

@@ -1,3 +1,57 @@
 JS and WASM implementations of https://github.com/srijs/rust-gearhash
 
-Using [AssemblyScript](https://www.assemblyscript.org/) to generate a lean WASM.
+Using [AssemblyScript](https://www.assemblyscript.org/) to generate a lean WASM.
+
+## Usage
+
+```javascript
+import { nextMatch } from '@huggingface/gearhash-wasm';
+
+// Create a Uint8Array of data to search through
+const data = new Uint8Array(1000000); // Example: 1MB of data
+// ... fill data with your content ...
+
+// Search for a pattern with a specific mask
+const mask = 0x0000d90003530000n; // Example mask as a BigInt
+const matchResult = nextMatch(data, mask);
+
+// matchIndex will be the position where the pattern was found
+// or -1 if no match was found
+```
+
+The `nextMatch` function takes two parameters:
+- `data`: A Uint8Array containing the data to search through
+- `mask`: A BigInt representing the pattern mask to search for
+
+The function returns an object with the `position` (i32) and `hash` (u64) properties
+
+You can continuously feed data like this:
+
+```javascript
+let hash = 0n;
+const mask = 0x0000d90003530000n;
+
+let position = 0;
+for await (const chunk of dataSource) {
+  let index = 0;
+  while (1) {
+    let match = nextMatch(chunk.subArray(index), mask, hash);
+
+    if (match.position !== -1) {
+      console.log({
+        position: match.position + position,
+        hash: match.hash
+      })
+
+      index += match.position;
+      position = 0;
+      hash = 0n;
+    } else {
+      position += chunk.length - index;
+      break;
+    }
+  }
+}
+
+console.log(position, "bytes without a match, ending hash: ", hash);
+```

packages/gearhash-wasm/assembly/next-match.ts

@@ -2,16 +2,22 @@
 
 import { DEFAULT_TABLE } from "./table";
 
+// Interface for the match result
+export class MatchResult {
+	position: i32 = -1;
+	hash: u64 = 0;
+}
+
 // Function to find the next match in the buffer
-export function nextMatch(buf: Uint8Array, mask: u64, hash: u64 = 0, table: StaticArray<u64> = DEFAULT_TABLE): i32 {
+export function nextMatch(buf: Uint8Array, mask: u64, hash: u64 = 0): MatchResult {
 	for (let i = 0; i < buf.length; i++) {
 		const b = buf[i];
-		hash = (hash << 1) + table[b];
+		hash = (hash << 1) + DEFAULT_TABLE[b];
 
 		if ((hash & mask) == 0) {
-			return i + 1;
+			return { position: i + 1, hash };
 		}
 	}
 
-	return -1; // Return -1 to indicate no match found (equivalent to None in Rust)
+	return { position: -1, hash }; // Return -1 position to indicate no match found, along with the final hash
 }

packages/gearhash-wasm/tests/index.js

@@ -1,4 +1,20 @@
 import assert from "assert";
 import { nextMatch } from "../build/debug.js";
-assert.strictEqual(nextMatch(new Uint8Array([1, 2, 3]), 0xaf2900n), 3);
+
+// Simple seeded random number generator
+function seededRandom(seed) {
+	return function () {
+		seed = (seed * 16807) % 2147483647;
+		return (seed - 1) / 2147483646;
+	};
+}
+
+// Create seeded random data
+const seed = 12345; // Fixed seed for deterministic results
+const random = seededRandom(seed);
+const randomData = new Uint8Array(1000000).map(() => Math.floor(random() * 256));
+
+// Test with a known mask
+assert.deepStrictEqual(nextMatch(randomData, 0xaf2900n), { position: 128, hash: 11757411513747408525n });
+assert.deepStrictEqual(nextMatch(randomData.subarray(128), 0xaf2900n), { position: 184, hash: 7438883163016807155n });
 console.log("ok");