inray 0.0.2 → 0.0.3

package/dist/caching/src/hashing/providers/djb2.js

@@ -0,0 +1,92 @@
+/**
+ * DJB2 hash algorithm implementation.
+ *
+ * DJB2 is a non-cryptographic hash function created by Daniel J. Bernstein.
+ * It produces a 32-bit hash value, making it suitable for hash tables and checksums,
+ * but NOT for cryptographic purposes.
+ *
+ * Algorithm: hash = hash * 33 + c (where c is each byte)
+ * Initial value: 5381
+ *
+ * @example
+ * ```typescript
+ * import { Hashery } from 'hashery';
+ * import { DJB2 } from 'hashery/providers/djb2';
+ *
+ * const hashery = new Hashery();
+ * hashery.providers.add(new DJB2());
+ *
+ * const hash = await hashery.toHash({ data: 'hello' }, 'djb2');
+ * console.log(hash); // "7c9df5ea"
+ * ```
+ */
+export class DJB2 {
+    /**
+     * The name identifier for this hash provider.
+     */
+    get name() {
+        return 'djb2';
+    }
+    /**
+     * Computes the DJB2 hash of the provided data synchronously.
+     *
+     * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
+     * @returns An 8-character lowercase hexadecimal string
+     *
+     * @example
+     * ```typescript
+     * const djb2 = new DJB2();
+     * const data = new TextEncoder().encode('hello');
+     * const hash = djb2.toHashSync(data);
+     * console.log(hash); // "7c9df5ea"
+     * ```
+     */
+    toHashSync(data) {
+        // Convert BufferSource to Uint8Array for consistent processing
+        let bytes;
+        if (data instanceof Uint8Array) {
+            bytes = data;
+        }
+        else if (data instanceof ArrayBuffer) {
+            bytes = new Uint8Array(data);
+        }
+        else if (data instanceof DataView) {
+            bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        else {
+            // Fallback for other ArrayBufferView types (e.g., Int8Array, Uint16Array, etc.)
+            const view = data;
+            bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+        }
+        // DJB2 algorithm
+        // Initial hash value: 5381
+        let hash = 5381;
+        // Process each byte: hash = hash * 33 + byte
+        for (let i = 0; i < bytes.length; i++) {
+            hash = (hash << 5) + hash + bytes[i]; // hash * 33 + c
+            // Keep it as a 32-bit unsigned integer
+            hash = hash >>> 0;
+        }
+        // Convert to 8-character lowercase hexadecimal string
+        const hashHex = hash.toString(16).padStart(8, '0');
+        return hashHex;
+    }
+    /**
+     * Computes the DJB2 hash of the provided data.
+     *
+     * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
+     * @returns A Promise resolving to an 8-character lowercase hexadecimal string
+     *
+     * @example
+     * ```typescript
+     * const djb2 = new DJB2();
+     * const data = new TextEncoder().encode('hello');
+     * const hash = await djb2.toHash(data);
+     * console.log(hash); // "7c9df5ea"
+     * ```
+     */
+    async toHash(data) {
+        return this.toHashSync(data);
+    }
+}
+//# sourceMappingURL=djb2.js.map

package/dist/caching/src/hashing/providers/djb2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"djb2.js","sourceRoot":"","sources":["../../../../../src/caching/src/hashing/providers/djb2.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,IAAI;IACf;;OAEG;IACH,IAAW,IAAI;QACb,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;;;;;;;;;;OAaG;IACI,UAAU,CAAC,IAAkB;QAClC,+DAA+D;QAC/D,IAAI,KAAiB,CAAC;QAEtB,IAAI,IAAI,YAAY,UAAU,EAAE,CAAC;YAC/B,KAAK,GAAG,IAAI,CAAC;QACf,CAAC;aAAM,IAAI,IAAI,YAAY,WAAW,EAAE,CAAC;YACvC,KAAK,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC;QAC/B,CAAC;aAAM,IAAI,IAAI,YAAY,QAAQ,EAAE,CAAC;YACpC,KAAK,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QACxE,CAAC;aAAM,CAAC;YACN,gFAAgF;YAChF,MAAM,IAAI,GAAG,IAAuB,CAAC;YACrC,KAAK,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QACxE,CAAC;QAED,iBAAiB;QACjB,2BAA2B;QAC3B,IAAI,IAAI,GAAG,IAAI,CAAC;QAEhB,6CAA6C;QAC7C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACtC,IAAI,GAAG,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,gBAAgB;YACtD,uCAAuC;YACvC,IAAI,GAAG,IAAI,KAAK,CAAC,CAAC;QACpB,CAAC;QAED,sDAAsD;QACtD,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAEnD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;;;;;;;;;;OAaG;IACI,KAAK,CAAC,MAAM,CAAC,IAAkB;QACpC,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;CACF"}

package/dist/caching/src/hashing/providers/fnv1.d.ts

@@ -0,0 +1,33 @@
+import type { HashProvider } from '../types.ts';
+/**
+ * FNV-1 (Fowler-Noll-Vo) hash algorithm implementation.
+ *
+ * FNV-1 is a non-cryptographic hash function created by Glenn Fowler, Landon Curt Noll,
+ * and Kiem-Phong Vo. It produces a 32-bit hash value, making it suitable for hash tables
+ * and checksums, but NOT for cryptographic purposes.
+ *
+ * Algorithm: hash = (hash * FNV_prime) XOR octet_of_data
+ * FNV-1 32-bit offset basis: 2166136261
+ * FNV-1 32-bit prime: 16777619
+ */
+export declare class FNV1 implements HashProvider {
+    /**
+     * The name identifier for this hash provider.
+     */
+    get name(): string;
+    /**
+     * Computes the FNV-1 hash of the provided data synchronously.
+     *
+     * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
+     * @returns An 8-character lowercase hexadecimal string
+     */
+    toHashSync(data: BufferSource): string;
+    /**
+     * Computes the FNV-1 hash of the provided data.
+     *
+     * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
+     * @returns A Promise resolving to an 8-character lowercase hexadecimal string
+     */
+    toHash(data: BufferSource): Promise<string>;
+}
+//# sourceMappingURL=fnv1.d.ts.map

package/dist/caching/src/hashing/providers/fnv1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fnv1.d.ts","sourceRoot":"","sources":["../../../../../src/caching/src/hashing/providers/fnv1.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;;;;;;;;GAUG;AACH,qBAAa,IAAK,YAAW,YAAY;IACvC;;OAEG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;;;;OAKG;IACI,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM;IAqC7C;;;;;OAKG;IACU,MAAM,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;CAGzD"}

package/dist/caching/src/hashing/providers/fnv1.js

@@ -0,0 +1,68 @@
+/**
+ * FNV-1 (Fowler-Noll-Vo) hash algorithm implementation.
+ *
+ * FNV-1 is a non-cryptographic hash function created by Glenn Fowler, Landon Curt Noll,
+ * and Kiem-Phong Vo. It produces a 32-bit hash value, making it suitable for hash tables
+ * and checksums, but NOT for cryptographic purposes.
+ *
+ * Algorithm: hash = (hash * FNV_prime) XOR octet_of_data
+ * FNV-1 32-bit offset basis: 2166136261
+ * FNV-1 32-bit prime: 16777619
+ */
+export class FNV1 {
+    /**
+     * The name identifier for this hash provider.
+     */
+    get name() {
+        return 'fnv1';
+    }
+    /**
+     * Computes the FNV-1 hash of the provided data synchronously.
+     *
+     * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
+     * @returns An 8-character lowercase hexadecimal string
+     */
+    toHashSync(data) {
+        // Convert BufferSource to Uint8Array for consistent processing
+        let bytes;
+        if (data instanceof Uint8Array) {
+            bytes = data;
+        }
+        else if (data instanceof ArrayBuffer) {
+            bytes = new Uint8Array(data);
+        }
+        else if (data instanceof DataView) {
+            bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        else {
+            // Fallback for other ArrayBufferView types (e.g., Int8Array, Uint16Array, etc.)
+            const view = data;
+            bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+        }
+        // FNV-1 algorithm constants
+        const FNV_OFFSET_BASIS = 2166136261; // 32-bit offset basis
+        const FNV_PRIME = 16777619; // 32-bit FNV prime
+        // Initialize hash with FNV offset basis
+        let hash = FNV_OFFSET_BASIS;
+        // Process each byte: hash = (hash * FNV_prime) XOR byte
+        for (let i = 0; i < bytes.length; i++) {
+            hash = hash * FNV_PRIME;
+            hash = hash ^ bytes[i];
+            // Keep it as a 32-bit unsigned integer
+            hash = hash >>> 0;
+        }
+        // Convert to 8-character lowercase hexadecimal string
+        const hashHex = hash.toString(16).padStart(8, '0');
+        return hashHex;
+    }
+    /**
+     * Computes the FNV-1 hash of the provided data.
+     *
+     * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
+     * @returns A Promise resolving to an 8-character lowercase hexadecimal string
+     */
+    async toHash(data) {
+        return this.toHashSync(data);
+    }
+}
+//# sourceMappingURL=fnv1.js.map

package/dist/caching/src/hashing/providers/fnv1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fnv1.js","sourceRoot":"","sources":["../../../../../src/caching/src/hashing/providers/fnv1.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,MAAM,OAAO,IAAI;IACf;;OAEG;IACH,IAAW,IAAI;QACb,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;;OAKG;IACI,UAAU,CAAC,IAAkB;QAClC,+DAA+D;QAC/D,IAAI,KAAiB,CAAC;QAEtB,IAAI,IAAI,YAAY,UAAU,EAAE,CAAC;YAC/B,KAAK,GAAG,IAAI,CAAC;QACf,CAAC;aAAM,IAAI,IAAI,YAAY,WAAW,EAAE,CAAC;YACvC,KAAK,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC;QAC/B,CAAC;aAAM,IAAI,IAAI,YAAY,QAAQ,EAAE,CAAC;YACpC,KAAK,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QACxE,CAAC;aAAM,CAAC;YACN,gFAAgF;YAChF,MAAM,IAAI,GAAG,IAAuB,CAAC;YACrC,KAAK,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QACxE,CAAC;QAED,4BAA4B;QAC5B,MAAM,gBAAgB,GAAG,UAAU,CAAC,CAAC,sBAAsB;QAC3D,MAAM,SAAS,GAAG,QAAQ,CAAC,CAAC,mBAAmB;QAE/C,wCAAwC;QACxC,IAAI,IAAI,GAAG,gBAAgB,CAAC;QAE5B,wDAAwD;QACxD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACtC,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC;YACxB,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACvB,uCAAuC;YACvC,IAAI,GAAG,IAAI,KAAK,CAAC,CAAC;QACpB,CAAC;QAED,sDAAsD;QACtD,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAEnD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,MAAM,CAAC,IAAkB;QACpC,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;CACF"}

package/dist/caching/src/hashing/providers/murmur.d.ts

@@ -0,0 +1,81 @@
+import type { HashProvider } from '../types.ts';
+/**
+ * Murmur 32-bit hash algorithm implementation.
+ *
+ * Murmur is a non-cryptographic hash function based on MurmurHash3 by Austin Appleby.
+ * It produces a 32-bit hash value with excellent distribution and performance,
+ * making it suitable for hash tables, bloom filters, and checksums,
+ * but NOT for cryptographic purposes.
+ *
+ * This implementation uses the MurmurHash3_x86_32 variant.
+ *
+ * @example
+ * ```typescript
+ * import { Hashery } from 'hashery';
+ * import { Murmur } from 'hashery/providers/murmur';
+ *
+ * const hashery = new Hashery();
+ * hashery.providers.add(new Murmur());
+ *
+ * const hash = await hashery.toHash({ data: 'hello' }, 'murmur');
+ * console.log(hash); // "248bfa47"
+ * ```
+ */
+export declare class Murmur implements HashProvider {
+    private _seed;
+    /**
+     * Creates a new Murmur instance.
+     *
+     * @param seed - Optional seed value for the hash (default: 0)
+     */
+    constructor(seed?: number);
+    /**
+     * The name identifier for this hash provider.
+     */
+    get name(): string;
+    /**
+     * Gets the current seed value used for hashing.
+     */
+    get seed(): number;
+    /**
+     * Computes the Murmur 32-bit hash of the provided data synchronously.
+     *
+     * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
+     * @returns An 8-character lowercase hexadecimal string
+     *
+     * @example
+     * ```typescript
+     * const murmur = new Murmur();
+     * const data = new TextEncoder().encode('hello');
+     * const hash = murmur.toHashSync(data);
+     * console.log(hash); // "248bfa47"
+     * ```
+     */
+    toHashSync(data: BufferSource): string;
+    /**
+     * Computes the Murmur 32-bit hash of the provided data.
+     *
+     * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
+     * @returns A Promise resolving to an 8-character lowercase hexadecimal string
+     *
+     * @example
+     * ```typescript
+     * const murmur = new Murmur();
+     * const data = new TextEncoder().encode('hello');
+     * const hash = await murmur.toHash(data);
+     * console.log(hash); // "248bfa47"
+     * ```
+     */
+    toHash(data: BufferSource): Promise<string>;
+    /**
+     * 32-bit integer multiplication with proper overflow handling.
+     * @private
+     */
+    private _imul;
+    /**
+     * Left rotate a 32-bit integer.
+     * @private
+     */
+    private _rotl32;
+}
+//# sourceMappingURL=murmur.d.ts.map

package/dist/caching/src/hashing/providers/murmur.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"murmur.d.ts","sourceRoot":"","sources":["../../../../../src/caching/src/hashing/providers/murmur.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,MAAO,YAAW,YAAY;IACzC,OAAO,CAAC,KAAK,CAAS;IAEtB;;;;OAIG;gBACS,IAAI,GAAE,MAAU;IAI5B;;OAEG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;OAEG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;;;;;;;;;;;;OAaG;IACI,UAAU,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM;IA+E7C;;;;;;;;;;;;;OAaG;IACU,MAAM,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;IAIxD;;;OAGG;IACH,OAAO,CAAC,KAAK;IAqBb;;;OAGG;IACH,OAAO,CAAC,OAAO;CAGhB"}

package/dist/caching/src/hashing/providers/murmur.js

@@ -0,0 +1,173 @@
+/**
+ * Murmur 32-bit hash algorithm implementation.
+ *
+ * Murmur is a non-cryptographic hash function based on MurmurHash3 by Austin Appleby.
+ * It produces a 32-bit hash value with excellent distribution and performance,
+ * making it suitable for hash tables, bloom filters, and checksums,
+ * but NOT for cryptographic purposes.
+ *
+ * This implementation uses the MurmurHash3_x86_32 variant.
+ *
+ * @example
+ * ```typescript
+ * import { Hashery } from 'hashery';
+ * import { Murmur } from 'hashery/providers/murmur';
+ *
+ * const hashery = new Hashery();
+ * hashery.providers.add(new Murmur());
+ *
+ * const hash = await hashery.toHash({ data: 'hello' }, 'murmur');
+ * console.log(hash); // "248bfa47"
+ * ```
+ */
+export class Murmur {
+    _seed;
+    /**
+     * Creates a new Murmur instance.
+     *
+     * @param seed - Optional seed value for the hash (default: 0)
+     */
+    constructor(seed = 0) {
+        this._seed = seed >>> 0; // Ensure it's a 32-bit unsigned integer
+    }
+    /**
+     * The name identifier for this hash provider.
+     */
+    get name() {
+        return 'murmur';
+    }
+    /**
+     * Gets the current seed value used for hashing.
+     */
+    get seed() {
+        return this._seed;
+    }
+    /**
+     * Computes the Murmur 32-bit hash of the provided data synchronously.
+     *
+     * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
+     * @returns An 8-character lowercase hexadecimal string
+     *
+     * @example
+     * ```typescript
+     * const murmur = new Murmur();
+     * const data = new TextEncoder().encode('hello');
+     * const hash = murmur.toHashSync(data);
+     * console.log(hash); // "248bfa47"
+     * ```
+     */
+    toHashSync(data) {
+        // Convert BufferSource to Uint8Array for consistent processing
+        let bytes;
+        if (data instanceof Uint8Array) {
+            bytes = data;
+        }
+        else if (data instanceof ArrayBuffer) {
+            bytes = new Uint8Array(data);
+        }
+        else if (data instanceof DataView) {
+            bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        else {
+            // Fallback for other ArrayBufferView types (e.g., Int8Array, Uint16Array, etc.)
+            const view = data;
+            bytes = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+        }
+        // MurmurHash3_x86_32 algorithm
+        const c1 = 0xcc9e2d51;
+        const c2 = 0x1b873593;
+        const length = bytes.length;
+        const nblocks = Math.floor(length / 4);
+        let h1 = this._seed;
+        // Process 4-byte blocks
+        for (let i = 0; i < nblocks; i++) {
+            const index = i * 4;
+            let k1 = (bytes[index] & 0xff) |
+                ((bytes[index + 1] & 0xff) << 8) |
+                ((bytes[index + 2] & 0xff) << 16) |
+                ((bytes[index + 3] & 0xff) << 24);
+            k1 = this._imul(k1, c1);
+            k1 = this._rotl32(k1, 15);
+            k1 = this._imul(k1, c2);
+            h1 ^= k1;
+            h1 = this._rotl32(h1, 13);
+            h1 = this._imul(h1, 5) + 0xe6546b64;
+        }
+        // Process remaining bytes
+        const tail = nblocks * 4;
+        let k1 = 0;
+        switch (length & 3) {
+            case 3:
+                k1 ^= (bytes[tail + 2] & 0xff) << 16;
+            // fallthrough
+            case 2:
+                k1 ^= (bytes[tail + 1] & 0xff) << 8;
+            // fallthrough
+            case 1:
+                k1 ^= bytes[tail] & 0xff;
+                k1 = this._imul(k1, c1);
+                k1 = this._rotl32(k1, 15);
+                k1 = this._imul(k1, c2);
+                h1 ^= k1;
+        }
+        // Finalization
+        h1 ^= length;
+        h1 ^= h1 >>> 16;
+        h1 = this._imul(h1, 0x85ebca6b);
+        h1 ^= h1 >>> 13;
+        h1 = this._imul(h1, 0xc2b2ae35);
+        h1 ^= h1 >>> 16;
+        // Convert to unsigned 32-bit integer
+        h1 = h1 >>> 0;
+        // Convert to 8-character lowercase hexadecimal string
+        const hashHex = h1.toString(16).padStart(8, '0');
+        return hashHex;
+    }
+    /**
+     * Computes the Murmur 32-bit hash of the provided data.
+     *
+     * @param data - The data to hash (Uint8Array, ArrayBuffer, or DataView)
+     * @returns A Promise resolving to an 8-character lowercase hexadecimal string
+     *
+     * @example
+     * ```typescript
+     * const murmur = new Murmur();
+     * const data = new TextEncoder().encode('hello');
+     * const hash = await murmur.toHash(data);
+     * console.log(hash); // "248bfa47"
+     * ```
+     */
+    async toHash(data) {
+        return this.toHashSync(data);
+    }
+    /**
+     * 32-bit integer multiplication with proper overflow handling.
+     * @private
+     */
+    _imul(a, b) {
+        // Use Math.imul if available, otherwise fallback to manual implementation
+        /* v8 ignore next -- @preserve */
+        if (Math.imul) {
+            return Math.imul(a, b);
+        }
+        // Manual 32-bit multiplication
+        /* v8 ignore next -- @preserve */
+        const ah = (a >>> 16) & 0xffff;
+        /* v8 ignore next -- @preserve */
+        const al = a & 0xffff;
+        /* v8 ignore next -- @preserve */
+        const bh = (b >>> 16) & 0xffff;
+        /* v8 ignore next -- @preserve */
+        const bl = b & 0xffff;
+        /* v8 ignore next -- @preserve */
+        return (al * bl + (((ah * bl + al * bh) << 16) >>> 0)) | 0;
+    }
+    /**
+     * Left rotate a 32-bit integer.
+     * @private
+     */
+    _rotl32(x, r) {
+        return (x << r) | (x >>> (32 - r));
+    }
+}
+//# sourceMappingURL=murmur.js.map

package/dist/caching/src/hashing/providers/murmur.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"murmur.js","sourceRoot":"","sources":["../../../../../src/caching/src/hashing/providers/murmur.ts"],"names":[],"mappings":"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"}

package/dist/caching/src/hashing/providers.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Original library: hashery (v1.5.1)
+ * - Copyright (c) 2025 Jared Wray
+ *
+ * Modified and integrated in "Inray":
+ * - Evgeniy Bushin
+ */
+/***/
+import type { HashProvider, HashProvidersGetOptions, HashProvidersOptions } from './types.ts';
+/**
+ * Manages a collection of hash providers for the Hashery system.
+ * Provides methods to add, remove, and load multiple hash providers.
+ */
+export declare class HashProviders {
+    private _providers;
+    private _getFuzzy;
+    /**
+     * Creates a new HashProviders instance.
+     * @param options - Optional configuration including initial providers to load
+     * @example
+     * ```ts
+     * const providers = new HashProviders({
+     *   providers: [{ name: 'custom', toHash: async (data) => '...' }]
+     * });
+     * ```
+     */
+    constructor(options?: HashProvidersOptions);
+    /**
+     * Loads multiple hash providers at once.
+     * Each provider is added to the internal map using its name as the key.
+     * @param providers - Array of HashProvider objects to load
+     * @example
+     * ```ts
+     * const providers = new HashProviders();
+     * providers.loadProviders([
+     *   { name: 'md5', toHash: async (data) => '...' },
+     *   { name: 'sha1', toHash: async (data) => '...' }
+     * ]);
+     * ```
+     */
+    loadProviders(providers: Array<HashProvider>): void;
+    /**
+     * Gets the internal Map of all registered hash providers.
+     * @returns Map of provider names to HashProvider objects
+     */
+    get providers(): Map<string, HashProvider>;
+    /**
+     * Sets the internal Map of hash providers, replacing all existing providers.
+     * @param providers - Map of provider names to HashProvider objects
+     */
+    set providers(providers: Map<string, HashProvider>);
+    /**
+     * Gets an array of all provider names.
+     * @returns Array of provider names
+     * @example
+     * ```ts
+     * const providers = new HashProviders();
+     * providers.add({ name: 'sha256', toHash: async (data) => '...' });
+     * providers.add({ name: 'md5', toHash: async (data) => '...' });
+     * console.log(providers.names); // ['sha256', 'md5']
+     * ```
+     */
+    get names(): Array<string>;
+    /**
+     * Gets a hash provider by name with optional fuzzy matching.
+     *
+     * Fuzzy matching (enabled by default) attempts to find providers by:
+     * 1. Exact match (after trimming whitespace)
+     * 2. Case-insensitive match (lowercase)
+     * 3. Dash-removed match (e.g., "SHA-256" matches "sha256")
+     *
+     * @param name - The name of the provider to retrieve
+     * @param options - Optional configuration for the get operation
+     * @param options.fuzzy - Enable/disable fuzzy matching (overrides constructor setting)
+     * @returns The HashProvider if found, undefined otherwise
+     * @example
+     * ```ts
+     * const providers = new HashProviders();
+     * providers.add({ name: 'sha256', toHash: async (data) => '...' });
+     *
+     * // Exact match
+     * const provider = providers.get('sha256');
+     *
+     * // Fuzzy match (case-insensitive)
+     * const provider2 = providers.get('SHA256');
+     *
+     * // Fuzzy match (with dash)
+     * const provider3 = providers.get('SHA-256');
+     *
+     * // Disable fuzzy matching
+     * const provider4 = providers.get('SHA256', { fuzzy: false }); // returns undefined
+     * ```
+     */
+    get(name: string, options?: HashProvidersGetOptions): HashProvider | undefined;
+    /**
+     * Adds a single hash provider to the collection.
+     * If a provider with the same name already exists, it will be replaced.
+     * @param provider - The HashProvider object to add
+     * @example
+     * ```ts
+     * const providers = new HashProviders();
+     * providers.add({
+     *   name: 'custom-hash',
+     *   toHash: async (data) => {
+     *     // Custom hashing logic
+     *     return 'hash-result';
+     *   }
+     * });
+     * ```
+     */
+    add(provider: HashProvider): void;
+    /**
+     * Removes a hash provider from the collection by name.
+     * @param name - The name of the provider to remove
+     * @returns true if the provider was found and removed, false otherwise
+     * @example
+     * ```ts
+     * const providers = new HashProviders();
+     * providers.add({ name: 'custom', toHash: async (data) => '...' });
+     * const removed = providers.remove('custom'); // returns true
+     * const removed2 = providers.remove('nonexistent'); // returns false
+     * ```
+     */
+    remove(name: string): boolean;
+}
+//# sourceMappingURL=providers.d.ts.map

package/dist/caching/src/hashing/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../../../src/caching/src/hashing/providers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,KAAK;AAEL,OAAO,KAAK,EAAE,YAAY,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAE9F;;;GAGG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,UAAU,CAAwC;IAC1D,OAAO,CAAC,SAAS,CAAQ;IAEzB;;;;;;;;;OASG;gBACS,OAAO,CAAC,EAAE,oBAAoB;IAU1C;;;;;;;;;;;;OAYG;IACI,aAAa,CAAC,SAAS,EAAE,KAAK,CAAC,YAAY,CAAC;IAMnD;;;OAGG;IACH,IAAW,SAAS,IAAI,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAEhD;IAED;;;OAGG;IACH,IAAW,SAAS,CAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EAExD;IAED;;;;;;;;;;OAUG;IACH,IAAW,KAAK,IAAI,KAAK,CAAC,MAAM,CAAC,CAEhC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACI,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,uBAAuB,GAAG,YAAY,GAAG,SAAS;IAwBrF;;;;;;;;;;;;;;;OAeG;IACI,GAAG,CAAC,QAAQ,EAAE,YAAY,GAAG,IAAI;IAIxC;;;;;;;;;;;OAWG;IACI,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAGrC"}