gitx.do 0.0.3 → 0.1.1

package/dist/types/storage.js

@@ -28,5 +28,164 @@
  * }
  * ```
  */
-export {};
+import { isValidSha, isValidObjectType } from './objects';
+/**
+ * Validate a ref name.
+ *
+ * @description
+ * Checks if a ref name follows Git ref naming conventions:
+ * - Cannot start with '.' or end with '/'
+ * - Cannot contain '..' or '//'
+ * - Cannot contain control characters, spaces, or special chars
+ * - Cannot end with '.lock'
+ *
+ * @param refName - The ref name to validate
+ * @returns Validation result
+ *
+ * @example
+ * ```typescript
+ * validateRefName('refs/heads/main') // { isValid: true }
+ * validateRefName('refs/heads/../foo') // { isValid: false, error: '...' }
+ * ```
+ */
+export function validateRefName(refName) {
+    if (!refName || typeof refName !== 'string') {
+        return { isValid: false, error: 'Ref name is required and must be a string' };
+    }
+    if (refName.startsWith('.') || refName.startsWith('/')) {
+        return { isValid: false, error: 'Ref name cannot start with "." or "/"' };
+    }
+    if (refName.endsWith('/') || refName.endsWith('.')) {
+        return { isValid: false, error: 'Ref name cannot end with "/" or "."' };
+    }
+    if (refName.includes('..')) {
+        return { isValid: false, error: 'Ref name cannot contain ".."' };
+    }
+    if (refName.includes('//')) {
+        return { isValid: false, error: 'Ref name cannot contain "//"' };
+    }
+    if (refName.endsWith('.lock')) {
+        return { isValid: false, error: 'Ref name cannot end with ".lock"' };
+    }
+    // Check for control characters and special chars
+    if (/[\x00-\x1f\x7f ~^:?*\[\\]/.test(refName)) {
+        return { isValid: false, error: 'Ref name contains invalid characters (control chars, space, ~, ^, :, ?, *, [, or \\)' };
+    }
+    return { isValid: true };
+}
+/**
+ * Validate a ref update operation.
+ *
+ * @description
+ * Validates a reference update operation including:
+ * - Ref name format
+ * - Old and new SHA validity (or zero SHA for create/delete)
+ *
+ * @param refName - The ref name to update
+ * @param oldSha - The expected current SHA (or zero SHA if creating)
+ * @param newSha - The new SHA to set (or zero SHA if deleting)
+ * @returns Validation result
+ *
+ * @example
+ * ```typescript
+ * // Creating a new ref
+ * validateRefUpdate('refs/heads/feature', ZERO_SHA, 'abc123...')
+ *
+ * // Updating a ref
+ * validateRefUpdate('refs/heads/main', 'old123...', 'new456...')
+ *
+ * // Deleting a ref
+ * validateRefUpdate('refs/heads/old', 'abc123...', ZERO_SHA)
+ * ```
+ */
+export function validateRefUpdate(refName, oldSha, newSha) {
+    const refResult = validateRefName(refName);
+    if (!refResult.isValid) {
+        return refResult;
+    }
+    const ZERO_SHA = '0000000000000000000000000000000000000000';
+    if (oldSha !== ZERO_SHA && !isValidSha(oldSha)) {
+        return { isValid: false, error: `Invalid old SHA: ${oldSha}. Must be 40 hex chars or zero SHA` };
+    }
+    if (newSha !== ZERO_SHA && !isValidSha(newSha)) {
+        return { isValid: false, error: `Invalid new SHA: ${newSha}. Must be 40 hex chars or zero SHA` };
+    }
+    if (oldSha === ZERO_SHA && newSha === ZERO_SHA) {
+        return { isValid: false, error: 'Cannot have both old and new SHA as zero (no-op)' };
+    }
+    return { isValid: true };
+}
+/**
+ * Validate object storage parameters.
+ *
+ * @description
+ * Validates parameters for storeObject operations:
+ * - Object type must be valid
+ * - Data must be a Uint8Array
+ *
+ * @param type - The object type
+ * @param data - The object data
+ * @returns Validation result
+ *
+ * @example
+ * ```typescript
+ * const result = validateStoreParams('blob', new Uint8Array([1, 2, 3]))
+ * if (!result.isValid) {
+ *   throw new Error(result.error)
+ * }
+ * ```
+ */
+export function validateStoreParams(type, data) {
+    if (!isValidObjectType(type)) {
+        return { isValid: false, error: `Invalid object type: ${type}. Must be blob, tree, commit, or tag` };
+    }
+    if (!(data instanceof Uint8Array)) {
+        return { isValid: false, error: 'Data must be a Uint8Array' };
+    }
+    return { isValid: true };
+}
+/**
+ * Assert that a SHA is valid, throwing if not.
+ *
+ * @description
+ * Throws a descriptive error if the SHA is invalid.
+ * Use this for input validation in API boundaries.
+ *
+ * @param sha - The SHA to validate
+ * @param context - Optional context for the error message (e.g., 'tree', 'parent')
+ * @throws Error if SHA is invalid
+ *
+ * @example
+ * ```typescript
+ * assertValidSha(treeSha, 'tree') // Throws: "Invalid tree SHA: ..."
+ * ```
+ */
+export function assertValidSha(sha, context) {
+    if (!isValidSha(sha)) {
+        const prefix = context ? `Invalid ${context} SHA` : 'Invalid SHA';
+        throw new Error(`${prefix}: ${sha}. Must be 40 lowercase hexadecimal characters`);
+    }
+}
+/**
+ * Assert that a ref name is valid, throwing if not.
+ *
+ * @description
+ * Throws a descriptive error if the ref name is invalid.
+ * Use this for input validation in API boundaries.
+ *
+ * @param refName - The ref name to validate
+ * @throws Error if ref name is invalid
+ *
+ * @example
+ * ```typescript
+ * assertValidRefName('refs/heads/main') // OK
+ * assertValidRefName('refs/../bad') // Throws
+ * ```
+ */
+export function assertValidRefName(refName) {
+    const result = validateRefName(refName);
+    if (!result.isValid) {
+        throw new Error(result.error);
+    }
+}
 //# sourceMappingURL=storage.js.map

package/dist/types/storage.js.map

@@ -1 +1 @@
-{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../src/types/storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG"}
+{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../src/types/storage.ts"],"names":[],"mappings":"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"}

package/dist/types/worker-loader.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview Worker Loader Types
+ *
+ * This module defines types for loading and interacting with Cloudflare Workers
+ * in the gitdo environment. Based on patterns from mongo.do research.
+ *
+ * @module types/worker-loader
+ */
+/**
+ * WorkerLoader interface for managing worker instances.
+ */
+export interface WorkerLoader {
+    get(id: string, getCode: () => Promise<WorkerCode>): WorkerStub;
+}
+/**
+ * WorkerCode defines the configuration and modules for a worker.
+ */
+export interface WorkerCode {
+    compatibilityDate: string;
+    compatibilityFlags?: string[];
+    mainModule: string;
+    modules: Record<string, string | {
+        js: string;
+    } | {
+        text: string;
+    }>;
+    globalOutbound?: null;
+    env?: Record<string, unknown>;
+}
+/**
+ * WorkerStub provides methods to interact with a worker instance.
+ */
+export interface WorkerStub {
+    fetch?(request: Request): Promise<Response>;
+    getEntrypoint?(name?: string): WorkerEntrypoint;
+}
+/**
+ * WorkerEntrypoint represents a worker's entrypoint.
+ */
+export interface WorkerEntrypoint {
+    fetch(request: Request): Promise<Response>;
+}
+/**
+ * MockWorkerLoader provides a mock implementation of the WorkerLoader interface
+ * for testing purposes. It caches WorkerStubs by ID.
+ */
+export declare class MockWorkerLoader implements WorkerLoader {
+    private cache;
+    get(id: string, _getCode: () => Promise<WorkerCode>): WorkerStub;
+}
+/**
+ * Type guard to check if a loader is a real Cloudflare worker loader.
+ * Returns false for MockWorkerLoader instances, null, undefined, or non-WorkerLoader objects.
+ * Returns true only for real Cloudflare worker_loaders that have the internal marker.
+ *
+ * @param loader - The loader to check
+ * @returns true if the loader is a real Cloudflare worker loader
+ */
+export declare function isRealWorkerLoader(loader: unknown): loader is WorkerLoader;
+//# sourceMappingURL=worker-loader.d.ts.map

package/dist/types/worker-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-loader.d.ts","sourceRoot":"","sources":["../../src/types/worker-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU,CAAA;CAChE;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,iBAAiB,EAAE,MAAM,CAAA;IACzB,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC7B,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IACnE,cAAc,CAAC,EAAE,IAAI,CAAA;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;IAC3C,aAAa,CAAC,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAAA;CAChD;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;CAC3C;AAOD;;;GAGG;AACH,qBAAa,gBAAiB,YAAW,YAAY;IACnD,OAAO,CAAC,KAAK,CAAgC;IAE7C,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU;CAsBjE;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,YAAY,CAgB1E"}

package/dist/types/worker-loader.js

@@ -0,0 +1,62 @@
+/**
+ * @fileoverview Worker Loader Types
+ *
+ * This module defines types for loading and interacting with Cloudflare Workers
+ * in the gitdo environment. Based on patterns from mongo.do research.
+ *
+ * @module types/worker-loader
+ */
+/**
+ * Internal marker symbol for identifying real Cloudflare worker loaders.
+ */
+const REAL_WORKER_LOADER_MARKER = Symbol.for('cloudflare.worker_loader');
+/**
+ * MockWorkerLoader provides a mock implementation of the WorkerLoader interface
+ * for testing purposes. It caches WorkerStubs by ID.
+ */
+export class MockWorkerLoader {
+    cache = new Map();
+    get(id, _getCode) {
+        const cached = this.cache.get(id);
+        if (cached) {
+            return cached;
+        }
+        const stub = {
+            fetch: async (_request) => {
+                return new Response('MockWorkerLoader response');
+            },
+            getEntrypoint: (_name) => {
+                return {
+                    fetch: async (_request) => {
+                        return new Response('MockWorkerLoader entrypoint response');
+                    }
+                };
+            }
+        };
+        this.cache.set(id, stub);
+        return stub;
+    }
+}
+/**
+ * Type guard to check if a loader is a real Cloudflare worker loader.
+ * Returns false for MockWorkerLoader instances, null, undefined, or non-WorkerLoader objects.
+ * Returns true only for real Cloudflare worker_loaders that have the internal marker.
+ *
+ * @param loader - The loader to check
+ * @returns true if the loader is a real Cloudflare worker loader
+ */
+export function isRealWorkerLoader(loader) {
+    if (loader === null || loader === undefined) {
+        return false;
+    }
+    if (loader instanceof MockWorkerLoader) {
+        return false;
+    }
+    if (typeof loader !== 'object') {
+        return false;
+    }
+    // Check for the internal marker that real Cloudflare worker loaders would have
+    const obj = loader;
+    return obj[REAL_WORKER_LOADER_MARKER] === true;
+}
+//# sourceMappingURL=worker-loader.js.map

package/dist/types/worker-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-loader.js","sourceRoot":"","sources":["../../src/types/worker-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAoCH;;GAEG;AACH,MAAM,yBAAyB,GAAG,MAAM,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAA;AAExE;;;GAGG;AACH,MAAM,OAAO,gBAAgB;IACnB,KAAK,GAAG,IAAI,GAAG,EAAsB,CAAA;IAE7C,GAAG,CAAC,EAAU,EAAE,QAAmC;QACjD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;QACjC,IAAI,MAAM,EAAE,CAAC;YACX,OAAO,MAAM,CAAA;QACf,CAAC;QAED,MAAM,IAAI,GAAe;YACvB,KAAK,EAAE,KAAK,EAAE,QAAiB,EAAqB,EAAE;gBACpD,OAAO,IAAI,QAAQ,CAAC,2BAA2B,CAAC,CAAA;YAClD,CAAC;YACD,aAAa,EAAE,CAAC,KAAc,EAAoB,EAAE;gBAClD,OAAO;oBACL,KAAK,EAAE,KAAK,EAAE,QAAiB,EAAqB,EAAE;wBACpD,OAAO,IAAI,QAAQ,CAAC,sCAAsC,CAAC,CAAA;oBAC7D,CAAC;iBACF,CAAA;YACH,CAAC;SACF,CAAA;QAED,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,CAAA;QACxB,OAAO,IAAI,CAAA;IACb,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAe;IAChD,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QAC5C,OAAO,KAAK,CAAA;IACd,CAAC;IAED,IAAI,MAAM,YAAY,gBAAgB,EAAE,CAAC;QACvC,OAAO,KAAK,CAAA;IACd,CAAC;IAED,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;QAC/B,OAAO,KAAK,CAAA;IACd,CAAC;IAED,+EAA+E;IAC/E,MAAM,GAAG,GAAG,MAA0C,CAAA;IACtD,OAAO,GAAG,CAAC,yBAAyB,CAAC,KAAK,IAAI,CAAA;AAChD,CAAC"}

package/dist/utils/hash.d.ts

@@ -5,8 +5,8 @@
  * identification and verification. Git uses SHA-1 as its primary hash algorithm,
  * with SHA-256 available as an optional newer algorithm (Git v2.29+).
  *
- * The hash functions work with the Web Crypto API for broad compatibility
- * with browsers and edge runtimes like Cloudflare Workers.
+ * Core hash primitives are imported from fsx.do which uses the Web Crypto API.
+ * Sync primitives are kept local for pack operations that need streaming SHA1.
  *
  * @module utils/hash
  *
@@ -23,55 +23,8 @@
  * console.log(`blob ${blobSha}`)
  * ```
  */
-/**
- * Compute the SHA-1 hash of data.
- *
- * @description
- * Computes a SHA-1 digest of the input data using the Web Crypto API.
- * This is the standard hash algorithm used by Git for object identification.
- *
- * **Note**: SHA-1 is considered cryptographically weak. Git uses it for
- * content addressing, not security. For new security-sensitive applications,
- * use SHA-256.
- *
- * @param data - Input data as Uint8Array or string (UTF-8 encoded)
- * @returns 40-character lowercase hexadecimal hash string
- *
- * @example
- * ```typescript
- * // Hash a string
- * const hash1 = await sha1('Hello, World!')
- * console.log(hash1) // '0a0a9f2a6772942557ab5355d76af442f8f65e01'
- *
- * // Hash binary data
- * const data = new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f])
- * const hash2 = await sha1(data)
- * ```
- */
-export declare function sha1(data: Uint8Array | string): Promise<string>;
-/**
- * Compute the SHA-256 hash of data.
- *
- * @description
- * Computes a SHA-256 digest of the input data using the Web Crypto API.
- * SHA-256 is the newer, more secure hash algorithm supported by Git v2.29+
- * as an alternative to SHA-1.
- *
- * @param data - Input data as Uint8Array or string (UTF-8 encoded)
- * @returns 64-character lowercase hexadecimal hash string
- *
- * @example
- * ```typescript
- * // Hash a string
- * const hash = await sha256('Hello, World!')
- * console.log(hash) // 'dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f'
- *
- * // Hash binary data
- * const data = new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f])
- * const hash2 = await sha256(data)
- * ```
- */
-export declare function sha256(data: Uint8Array | string): Promise<string>;
+export { sha1, sha256, bytesToHex, hexToBytes } from 'fsx.do';
+export { sha1Hex } from './sha1';
 /**
  * Hash a Git object with its type header.
  *
@@ -100,53 +53,146 @@ export declare function sha256(data: Uint8Array | string): Promise<string>;
  */
 export declare function hashObject(type: string, data: Uint8Array): Promise<string>;
 /**
- * Convert a hexadecimal string to a Uint8Array.
+ * LRU cache for storing computed hashes.
  *
  * @description
- * Parses a hexadecimal string and returns the corresponding bytes.
- * Each pair of hex characters becomes one byte.
+ * A Least Recently Used (LRU) cache implementation for caching SHA-1 hashes.
+ * This is useful when the same data is hashed multiple times, such as during
+ * pack file operations or object store lookups.
+ *
+ * **Key Strategy**: The cache key is derived from the first few bytes of the
+ * data combined with its length, which provides a fast key generation while
+ * avoiding collisions for different data.
  *
- * **Edge Cases**:
- * - Empty string returns empty Uint8Array
- * - Hex string should have even length (odd length may produce unexpected results)
+ * **Thread Safety**: This implementation is NOT thread-safe. In multi-threaded
+ * environments, external synchronization is required.
  *
- * @param hex - Hexadecimal string (case-insensitive)
- * @returns Binary data as Uint8Array
+ * @class HashCache
  *
  * @example
  * ```typescript
- * const bytes = hexToBytes('48656c6c6f')
- * console.log(new TextDecoder().decode(bytes)) // 'Hello'
+ * const cache = new HashCache(1000) // Cache up to 1000 hashes
  *
- * // Convert SHA back to bytes (useful for tree entries)
- * const sha = 'abc123def456...'
- * const sha20 = hexToBytes(sha) // 20 bytes for SHA-1
+ * // Use with getOrCompute for automatic caching
+ * const hash1 = await cache.getOrCompute(data, async () => sha1(data))
+ * const hash2 = await cache.getOrCompute(data, async () => sha1(data)) // Returns cached
+ *
+ * // Check stats
+ * console.log(`Hit rate: ${cache.hitRate}%`)
  * ```
  */
-export declare function hexToBytes(hex: string): Uint8Array;
+export declare class HashCache {
+    private cache;
+    private maxSize;
+    private hits;
+    private misses;
+    /**
+     * Creates a new HashCache with the specified maximum size.
+     *
+     * @param {number} maxSize - Maximum number of hashes to cache (default: 10000)
+     */
+    constructor(maxSize?: number);
+    /**
+     * Generates a cache key for the given data.
+     *
+     * @description Uses length + first 32 bytes (if available) to create a unique key.
+     * This is fast while providing good collision resistance.
+     *
+     * @param {Uint8Array} data - Data to generate key for
+     * @returns {string} Cache key
+     * @internal
+     */
+    private generateKey;
+    /**
+     * Gets a cached hash if available.
+     *
+     * @param {Uint8Array} data - Data to look up
+     * @returns {string | undefined} Cached hash or undefined if not cached
+     */
+    get(data: Uint8Array): string | undefined;
+    /**
+     * Stores a hash in the cache.
+     *
+     * @param {Uint8Array} data - Original data
+     * @param {string} hash - Computed hash to cache
+     */
+    set(data: Uint8Array, hash: string): void;
+    /**
+     * Gets a hash from cache or computes and caches it.
+     *
+     * @description This is the recommended way to use the cache. It automatically
+     * handles cache lookup, computation, and storage.
+     *
+     * @param {Uint8Array} data - Data to hash
+     * @param {() => Promise<string> | string} compute - Function to compute hash if not cached
+     * @returns {Promise<string>} The hash (from cache or newly computed)
+     *
+     * @example
+     * ```typescript
+     * const hash = await cache.getOrCompute(data, () => sha1(data))
+     * ```
+     */
+    getOrCompute(data: Uint8Array, compute: () => Promise<string> | string): Promise<string>;
+    /**
+     * Synchronous version of getOrCompute for use with synchronous hash functions.
+     *
+     * @param {Uint8Array} data - Data to hash
+     * @param {() => string} compute - Function to compute hash if not cached
+     * @returns {string} The hash (from cache or newly computed)
+     *
+     * @example
+     * ```typescript
+     * import { sha1Hex } from './sha1'
+     * const hash = cache.getOrComputeSync(data, () => sha1Hex(data))
+     * ```
+     */
+    getOrComputeSync(data: Uint8Array, compute: () => string): string;
+    /**
+     * Clears all entries from the cache.
+     */
+    clear(): void;
+    /**
+     * Gets the current number of cached entries.
+     */
+    get size(): number;
+    /**
+     * Gets the cache hit rate as a percentage.
+     */
+    get hitRate(): number;
+    /**
+     * Gets cache statistics.
+     *
+     * @returns {{ hits: number; misses: number; size: number; hitRate: number }}
+     */
+    getStats(): {
+        hits: number;
+        misses: number;
+        size: number;
+        hitRate: number;
+    };
+}
 /**
- * Convert a Uint8Array to a hexadecimal string.
+ * Global hash cache instance for common use cases.
  *
  * @description
- * Converts binary data to a lowercase hexadecimal string representation.
- * Each byte becomes two hex characters (zero-padded).
- *
- * **Edge Cases**:
- * - Empty Uint8Array returns empty string
+ * A shared cache instance that can be used across the application for
+ * caching object hashes. This is particularly useful for pack file
+ * operations where the same objects are hashed multiple times.
  *
- * @param bytes - Binary data to convert
- * @returns Lowercase hexadecimal string
+ * **Memory Management**: The cache has a default limit of 10,000 entries.
+ * For applications with different requirements, create a custom HashCache
+ * instance with appropriate size.
  *
  * @example
  * ```typescript
- * const hello = new TextEncoder().encode('Hello')
- * const hex = bytesToHex(hello)
- * console.log(hex) // '48656c6c6f'
+ * import { globalHashCache, sha1 } from './utils/hash'
+ *
+ * // Use the global cache
+ * const hash = await globalHashCache.getOrCompute(data, () => sha1(data))
  *
- * // Convert SHA-1 bytes to string
- * const hashBytes = new Uint8Array(20) // ... from crypto
- * const sha = bytesToHex(hashBytes) // 40-char hex string
+ * // Check cache stats
+ * console.log(globalHashCache.getStats())
  * ```
  */
-export declare function bytesToHex(bytes: Uint8Array): string;
+export declare const globalHashCache: HashCache;
 //# sourceMappingURL=hash.d.ts.map

package/dist/utils/hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/utils/hash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAIrE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAIvE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAOhF;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAOlD;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAKpD"}
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/utils/hash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AAG7D,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAA;AAOhC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAOhF;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,KAAK,CAAqB;IAClC,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,IAAI,CAAY;IACxB,OAAO,CAAC,MAAM,CAAY;IAE1B;;;;OAIG;gBACS,OAAO,GAAE,MAAc;IAKnC;;;;;;;;;OASG;IACH,OAAO,CAAC,WAAW;IAQnB;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS;IAgBzC;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAczC;;;;;;;;;;;;;;OAcG;IACG,YAAY,CAChB,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,GACtC,OAAO,CAAC,MAAM,CAAC;IAWlB;;;;;;;;;;;;OAYG;IACH,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,MAAM,GAAG,MAAM;IAWjE;;OAEG;IACH,KAAK,IAAI,IAAI;IAMb;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,MAAM,CAGpB;IAED;;;;OAIG;IACH,QAAQ,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;CAQ5E;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,eAAe,WAAkB,CAAA"}