gitx.do 0.0.3 → 0.1.1

package/dist/utils/hash.js

@@ -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,63 +23,14 @@
  * 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 async function sha1(data) {
-    const bytes = typeof data === 'string' ? new TextEncoder().encode(data) : data;
-    const hashBuffer = await crypto.subtle.digest('SHA-1', bytes);
-    return bytesToHex(new Uint8Array(hashBuffer));
-}
-/**
- * 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 async function sha256(data) {
-    const bytes = typeof data === 'string' ? new TextEncoder().encode(data) : data;
-    const hashBuffer = await crypto.subtle.digest('SHA-256', bytes);
-    return bytesToHex(new Uint8Array(hashBuffer));
-}
+// Re-export hash functions from fsx.do - now works in Workers environment
+export { sha1, sha256, bytesToHex, hexToBytes } from 'fsx.do';
+// Keep local sync implementations for pack operations that need streaming SHA1
+export { sha1Hex } from './sha1';
+// Import local bytesToHex for cache key generation (synchronous)
+import { bytesToHex as localBytesToHex } from './sha1';
+// Import sha1 from fsx.do for the hashObject function
+import { sha1 } from 'fsx.do';
 /**
  * Hash a Git object with its type header.
  *
@@ -114,68 +65,208 @@ export async function hashObject(type, data) {
     combined.set(data, headerBytes.length);
     return sha1(combined);
 }
+// ============================================================================
+// Hash Caching
+// ============================================================================
 /**
- * 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 function hexToBytes(hex) {
-    if (hex.length === 0)
-        return new Uint8Array(0);
-    const bytes = new Uint8Array(hex.length / 2);
-    for (let i = 0; i < hex.length; i += 2) {
-        bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+export class HashCache {
+    cache;
+    maxSize;
+    hits = 0;
+    misses = 0;
+    /**
+     * Creates a new HashCache with the specified maximum size.
+     *
+     * @param {number} maxSize - Maximum number of hashes to cache (default: 10000)
+     */
+    constructor(maxSize = 10000) {
+        this.cache = new Map();
+        this.maxSize = maxSize;
+    }
+    /**
+     * 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
+     */
+    generateKey(data) {
+        // Use length + first 32 bytes as key (fast and reasonably unique)
+        const prefix = data.length <= 32
+            ? localBytesToHex(data)
+            : localBytesToHex(data.subarray(0, 32));
+        return `${data.length}:${prefix}`;
+    }
+    /**
+     * 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) {
+        const key = this.generateKey(data);
+        const value = this.cache.get(key);
+        if (value !== undefined) {
+            this.hits++;
+            // Move to end (most recently used)
+            this.cache.delete(key);
+            this.cache.set(key, value);
+            return value;
+        }
+        this.misses++;
+        return undefined;
+    }
+    /**
+     * Stores a hash in the cache.
+     *
+     * @param {Uint8Array} data - Original data
+     * @param {string} hash - Computed hash to cache
+     */
+    set(data, hash) {
+        const key = this.generateKey(data);
+        // Remove oldest entry if at capacity
+        if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey !== undefined) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(key, hash);
+    }
+    /**
+     * 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))
+     * ```
+     */
+    async getOrCompute(data, compute) {
+        const cached = this.get(data);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const hash = await compute();
+        this.set(data, hash);
+        return hash;
+    }
+    /**
+     * 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, compute) {
+        const cached = this.get(data);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const hash = compute();
+        this.set(data, hash);
+        return hash;
+    }
+    /**
+     * Clears all entries from the cache.
+     */
+    clear() {
+        this.cache.clear();
+        this.hits = 0;
+        this.misses = 0;
+    }
+    /**
+     * Gets the current number of cached entries.
+     */
+    get size() {
+        return this.cache.size;
+    }
+    /**
+     * Gets the cache hit rate as a percentage.
+     */
+    get hitRate() {
+        const total = this.hits + this.misses;
+        return total === 0 ? 0 : (this.hits / total) * 100;
+    }
+    /**
+     * Gets cache statistics.
+     *
+     * @returns {{ hits: number; misses: number; size: number; hitRate: number }}
+     */
+    getStats() {
+        return {
+            hits: this.hits,
+            misses: this.misses,
+            size: this.cache.size,
+            hitRate: this.hitRate
+        };
     }
-    return bytes;
 }
 /**
- * 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'
  *
- * // Convert SHA-1 bytes to string
- * const hashBytes = new Uint8Array(20) // ... from crypto
- * const sha = bytesToHex(hashBytes) // 40-char hex string
+ * // Use the global cache
+ * const hash = await globalHashCache.getOrCompute(data, () => sha1(data))
+ *
+ * // Check cache stats
+ * console.log(globalHashCache.getStats())
  * ```
  */
-export function bytesToHex(bytes) {
-    if (bytes.length === 0)
-        return '';
-    return Array.from(bytes)
-        .map(b => b.toString(16).padStart(2, '0'))
-        .join('');
-}
+export const globalHashCache = new HashCache();
 //# sourceMappingURL=hash.js.map

package/dist/utils/hash.js.map

@@ -1 +1 @@
-{"version":3,"file":"hash.js","sourceRoot":"","sources":["../../src/utils/hash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,KAAK,UAAU,IAAI,CAAC,IAAyB;IAClD,MAAM,KAAK,GAAG,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;IAC9E,MAAM,UAAU,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;IAC7D,OAAO,UAAU,CAAC,IAAI,UAAU,CAAC,UAAU,CAAC,CAAC,CAAA;AAC/C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,KAAK,UAAU,MAAM,CAAC,IAAyB;IACpD,MAAM,KAAK,GAAG,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;IAC9E,MAAM,UAAU,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;IAC/D,OAAO,UAAU,CAAC,IAAI,UAAU,CAAC,UAAU,CAAC,CAAC,CAAA;AAC/C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAAC,IAAY,EAAE,IAAgB;IAC7D,MAAM,MAAM,GAAG,GAAG,IAAI,IAAI,IAAI,CAAC,MAAM,IAAI,CAAA;IACzC,MAAM,WAAW,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IACpD,MAAM,QAAQ,GAAG,IAAI,UAAU,CAAC,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,CAAA;IACjE,QAAQ,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC,CAAA;IAC5B,QAAQ,CAAC,GAAG,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IACtC,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAA;AACvB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,UAAU,CAAC,GAAW;IACpC,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,UAAU,CAAC,CAAC,CAAC,CAAA;IAC9C,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;IAC5C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QACvC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;IAClD,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,UAAU,CAAC,KAAiB;IAC1C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAA;IACjC,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC;SACrB,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;SACzC,IAAI,CAAC,EAAE,CAAC,CAAA;AACb,CAAC"}
+{"version":3,"file":"hash.js","sourceRoot":"","sources":["../../src/utils/hash.ts"],"names":[],"mappings":"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"}

package/dist/utils/sha1.d.ts

@@ -116,4 +116,210 @@ export declare function sha1Hex(data: Uint8Array): string;
  * ```
  */
 export declare function sha1Verify(data: Uint8Array, expected: Uint8Array): boolean;
+/**
+ * Convert bytes to hexadecimal string.
+ *
+ * @description Efficiently converts a Uint8Array to its hexadecimal
+ * representation. Each byte becomes two hex characters (00-ff).
+ *
+ * @param bytes - Input bytes to convert
+ * @returns Lowercase hexadecimal string (2 chars per byte)
+ *
+ * @example
+ * ```typescript
+ * const bytes = new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f])
+ * const hex = bytesToHex(bytes)
+ * console.log(hex) // '48656c6c6f'
+ * ```
+ */
+export declare function bytesToHex(bytes: Uint8Array): string;
+/**
+ * Convert hexadecimal string to bytes.
+ *
+ * @description Converts a hexadecimal string back to its binary representation.
+ * Each pair of hex characters becomes one byte.
+ *
+ * @param hex - Hexadecimal string (case-insensitive)
+ * @returns Uint8Array of bytes
+ * @throws {Error} If hex string has odd length
+ *
+ * @example
+ * ```typescript
+ * const hex = '48656c6c6f'
+ * const bytes = hexToBytes(hex)
+ * console.log(new TextDecoder().decode(bytes)) // 'Hello'
+ * ```
+ */
+export declare function hexToBytes(hex: string): Uint8Array;
+/**
+ * Streaming SHA-1 hasher for processing large data incrementally.
+ *
+ * @description
+ * This class allows hashing data in chunks, which is essential for:
+ * - Processing large files without loading everything into memory
+ * - Computing hashes of data streams
+ * - Pack file generation and verification
+ *
+ * The hasher maintains internal state and can accept data through the
+ * `update()` method before finalizing with `digest()` or `digestHex()`.
+ *
+ * **Performance Note**: For small data (< 64 bytes), the non-streaming
+ * `sha1()` function may be slightly faster due to lower overhead.
+ *
+ * @class StreamingSHA1
+ *
+ * @example
+ * ```typescript
+ * // Hash a large file in chunks
+ * const hasher = new StreamingSHA1()
+ *
+ * for await (const chunk of fileStream) {
+ *   hasher.update(chunk)
+ * }
+ *
+ * const hash = hasher.digestHex()
+ * console.log(`File hash: ${hash}`)
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Hash Git object with header
+ * const hasher = new StreamingSHA1()
+ * hasher.update(new TextEncoder().encode(`blob ${size}\0`))
+ * hasher.update(content)
+ * const objectId = hasher.digestHex()
+ * ```
+ */
+export declare class StreamingSHA1 {
+    /** Hash state */
+    private h;
+    /** Working array for chunk processing */
+    private w;
+    /** Buffer for incomplete chunks */
+    private buffer;
+    /** Current position in buffer */
+    private bufferLength;
+    /** Total bytes processed */
+    private totalLength;
+    /** Whether digest has been called */
+    private finalized;
+    /**
+     * Creates a new StreamingSHA1 hasher instance.
+     */
+    constructor();
+    /**
+     * Resets the hasher to its initial state.
+     *
+     * @description Allows reusing the same hasher instance for a new hash
+     * computation without creating a new object.
+     *
+     * @example
+     * ```typescript
+     * const hasher = new StreamingSHA1()
+     * hasher.update(data1)
+     * const hash1 = hasher.digestHex()
+     *
+     * hasher.reset()
+     * hasher.update(data2)
+     * const hash2 = hasher.digestHex()
+     * ```
+     */
+    reset(): void;
+    /**
+     * Updates the hash with additional data.
+     *
+     * @description Processes the input data, updating the internal hash state.
+     * Data is buffered internally until a complete 64-byte chunk is available,
+     * then processed immediately.
+     *
+     * This method can be called multiple times before finalizing with `digest()`.
+     *
+     * @param {Uint8Array} data - Data to add to the hash computation
+     * @returns {this} The hasher instance for method chaining
+     * @throws {Error} If called after digest() without reset()
+     *
+     * @example
+     * ```typescript
+     * const hasher = new StreamingSHA1()
+     *   .update(header)
+     *   .update(content)
+     *   .update(footer)
+     * const hash = hasher.digestHex()
+     * ```
+     */
+    update(data: Uint8Array): this;
+    /**
+     * Finalizes the hash computation and returns the 20-byte digest.
+     *
+     * @description Applies SHA-1 padding to the remaining data and computes
+     * the final hash. After calling this method, the hasher cannot be updated
+     * unless `reset()` is called.
+     *
+     * @returns {Uint8Array} 20-byte SHA-1 hash
+     *
+     * @example
+     * ```typescript
+     * const hasher = new StreamingSHA1()
+     * hasher.update(data)
+     * const hashBytes = hasher.digest()
+     * console.log(hashBytes.length) // 20
+     * ```
+     */
+    digest(): Uint8Array;
+    /**
+     * Finalizes the hash computation and returns the hex string digest.
+     *
+     * @description Convenience method that calls `digest()` and converts
+     * the result to a 40-character lowercase hexadecimal string.
+     *
+     * @returns {string} 40-character lowercase hexadecimal hash string
+     *
+     * @example
+     * ```typescript
+     * const hasher = new StreamingSHA1()
+     * hasher.update(data)
+     * const hash = hasher.digestHex()
+     * console.log(hash) // 'aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d'
+     * ```
+     */
+    digestHex(): string;
+}
+/**
+ * Hash a Git object with streaming support for large objects.
+ *
+ * @description
+ * Uses the streaming hasher to compute the SHA-1 of a Git object with its header.
+ * This is more memory-efficient than `hashObject` in `hash.ts` for large objects
+ * as it doesn't require concatenating header and data.
+ *
+ * @param type - Object type ('blob', 'tree', 'commit', 'tag')
+ * @param data - Object content as binary data
+ * @returns 20-byte SHA-1 hash as Uint8Array
+ *
+ * @example
+ * ```typescript
+ * const content = new TextEncoder().encode('hello')
+ * const hashBytes = hashObjectStreaming('blob', content)
+ * ```
+ */
+export declare function hashObjectStreaming(type: string, data: Uint8Array): Uint8Array;
+/**
+ * Hash a Git object with streaming support, returning hex string.
+ *
+ * @description
+ * Convenience wrapper that returns the hash as a 40-character hex string
+ * instead of raw bytes.
+ *
+ * @param type - Object type ('blob', 'tree', 'commit', 'tag')
+ * @param data - Object content as binary data
+ * @returns 40-character lowercase hexadecimal SHA-1 hash
+ *
+ * @example
+ * ```typescript
+ * const content = new TextEncoder().encode('hello')
+ * const sha = hashObjectStreamingHex('blob', content)
+ * console.log(sha) // 'b6fc4c620b67d95f953a5c1c1230aaab5db5a1b0'
+ * ```
+ */
+export declare function hashObjectStreamingHex(type: string, data: Uint8Array): string;
 //# sourceMappingURL=sha1.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sha1.d.ts","sourceRoot":"","sources":["../../src/utils/sha1.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAwGjD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAOhD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,GAAG,OAAO,CAgB1E"}
+{"version":3,"file":"sha1.d.ts","sourceRoot":"","sources":["../../src/utils/sha1.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAwGjD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAOhD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,GAAG,OAAO,CAgB1E;AAMD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAMpD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CASlD;AA4FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qBAAa,aAAa;IACxB,iBAAiB;IACjB,OAAO,CAAC,CAAC,CAAa;IACtB,yCAAyC;IACzC,OAAO,CAAC,CAAC,CAAa;IACtB,mCAAmC;IACnC,OAAO,CAAC,MAAM,CAAY;IAC1B,iCAAiC;IACjC,OAAO,CAAC,YAAY,CAAQ;IAC5B,4BAA4B;IAC5B,OAAO,CAAC,WAAW,CAAQ;IAC3B,qCAAqC;IACrC,OAAO,CAAC,SAAS,CAAS;IAE1B;;OAEG;;IAUH;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,IAAI,IAAI;IAWb;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAsC9B;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,IAAI,UAAU;IAmDpB;;;;;;;;;;;;;;;OAeG;IACH,SAAS,IAAI,MAAM;CAQpB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,UAAU,CAM9E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAM7E"}