@btc-vision/bitcoin 6.5.6 → 7.0.0-alpha.1

package/build/io/MemoryPool.d.ts

@@ -0,0 +1,220 @@
+/**
+ * Memory pool using SharedArrayBuffer for zero-allocation operations.
+ *
+ * Provides thread-safe memory allocation using Atomics for concurrent access.
+ * Ideal for parsing operations where temporary buffers are needed.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Thread-safe memory pool using SharedArrayBuffer.
+ *
+ * Allocates memory from a pre-allocated SharedArrayBuffer pool,
+ * eliminating garbage collection pressure from repeated allocations.
+ *
+ * Uses Atomics for thread-safe allocation when used with Workers.
+ *
+ * @example
+ * ```typescript
+ * import { MemoryPool } from '@btc-vision/bitcoin';
+ *
+ * // Create a 1MB pool
+ * const pool = new MemoryPool(1024 * 1024);
+ *
+ * // Allocate memory for transaction parsing
+ * const txBuffer = pool.alloc(500);
+ * // ... use txBuffer ...
+ *
+ * // Reset pool when done (all allocations become invalid)
+ * pool.reset();
+ * ```
+ */
+export declare class MemoryPool {
+    #private;
+    /**
+     * Creates a new MemoryPool.
+     *
+     * @param size - Size of the pool in bytes (default 4MB)
+     *
+     * @example
+     * ```typescript
+     * import { MemoryPool } from '@btc-vision/bitcoin';
+     *
+     * // 4MB pool (default)
+     * const pool = new MemoryPool();
+     *
+     * // 16MB pool
+     * const largePool = new MemoryPool(16 * 1024 * 1024);
+     * ```
+     */
+    constructor(size?: number);
+    /**
+     * Total capacity of the pool in bytes.
+     */
+    get capacity(): number;
+    /**
+     * Current allocation offset (bytes used).
+     *
+     * Uses Atomics for thread-safe reading.
+     */
+    get used(): number;
+    /**
+     * Remaining available bytes.
+     */
+    get available(): number;
+    /**
+     * The underlying SharedArrayBuffer.
+     *
+     * Can be transferred to Workers for shared memory access.
+     */
+    get sharedBuffer(): SharedArrayBuffer;
+    /**
+     * Creates a MemoryPool from an existing SharedArrayBuffer.
+     *
+     * Useful for sharing a pool between Workers.
+     *
+     * @param buffer - Existing SharedArrayBuffer
+     * @returns A new MemoryPool instance wrapping the buffer
+     *
+     * @example
+     * ```typescript
+     * // Main thread
+     * const pool = new MemoryPool(1024 * 1024);
+     * worker.postMessage({ buffer: pool.sharedBuffer });
+     *
+     * // Worker thread
+     * self.onmessage = (e) => {
+     *     const pool = MemoryPool.fromSharedBuffer(e.data.buffer);
+     *     const mem = pool.alloc(100);
+     * };
+     * ```
+     */
+    static fromSharedBuffer(buffer: SharedArrayBuffer): MemoryPool;
+    /**
+     * Allocates memory from the pool.
+     *
+     * Thread-safe using Atomics.add for concurrent access.
+     *
+     * @param size - Number of bytes to allocate
+     * @returns Uint8Array view into the pool
+     * @throws RangeError if pool is exhausted
+     *
+     * @example
+     * ```typescript
+     * const pool = new MemoryPool(1024);
+     * const buf1 = pool.alloc(100); // First 100 bytes
+     * const buf2 = pool.alloc(200); // Next 200 bytes
+     * ```
+     */
+    alloc(size: number): Uint8Array;
+    /**
+     * Allocates memory and fills it with zeros.
+     *
+     * @param size - Number of bytes to allocate
+     * @returns Uint8Array view into the pool, filled with zeros
+     * @throws RangeError if pool is exhausted
+     */
+    allocZeroed(size: number): Uint8Array;
+    /**
+     * Allocates memory for a specific typed array.
+     *
+     * @param length - Number of elements
+     * @param bytesPerElement - Size of each element in bytes
+     * @returns Uint8Array view (use constructor of target type on underlying buffer)
+     * @throws RangeError if pool is exhausted
+     *
+     * @example
+     * ```typescript
+     * const pool = new MemoryPool(1024);
+     * const bytes = pool.allocTyped(10, 4); // 40 bytes for 10 Uint32
+     * const u32View = new Uint32Array(bytes.buffer, bytes.byteOffset, 10);
+     * ```
+     */
+    allocTyped(length: number, bytesPerElement: number): Uint8Array;
+    /**
+     * Resets the pool, making all memory available again.
+     *
+     * WARNING: All previously allocated views become invalid.
+     * Only call when you're sure no references are held.
+     *
+     * Thread-safe using Atomics.store.
+     *
+     * @example
+     * ```typescript
+     * const pool = new MemoryPool(1024);
+     * const buf = pool.alloc(100);
+     * // ... use buf ...
+     * pool.reset(); // buf is now invalid!
+     * ```
+     */
+    reset(): void;
+    /**
+     * Checks if the pool can accommodate an allocation.
+     *
+     * @param size - Number of bytes needed
+     * @returns True if allocation would succeed
+     */
+    canAlloc(size: number): boolean;
+}
+/**
+ * Non-shared memory pool using regular ArrayBuffer.
+ *
+ * Use when SharedArrayBuffer is not available (e.g., browsers without
+ * proper COOP/COEP headers) or when thread-safety is not needed.
+ *
+ * @example
+ * ```typescript
+ * import { SimpleMemoryPool } from '@btc-vision/bitcoin';
+ *
+ * const pool = new SimpleMemoryPool(1024 * 1024);
+ * const buf = pool.alloc(100);
+ * ```
+ */
+export declare class SimpleMemoryPool {
+    #private;
+    /**
+     * Creates a new SimpleMemoryPool.
+     *
+     * @param size - Size of the pool in bytes
+     */
+    constructor(size: number);
+    /**
+     * Total capacity of the pool in bytes.
+     */
+    get capacity(): number;
+    /**
+     * Current allocation offset (bytes used).
+     */
+    get used(): number;
+    /**
+     * Remaining available bytes.
+     */
+    get available(): number;
+    /**
+     * Allocates memory from the pool.
+     *
+     * @param size - Number of bytes to allocate
+     * @returns Uint8Array view into the pool
+     * @throws RangeError if pool is exhausted
+     */
+    alloc(size: number): Uint8Array;
+    /**
+     * Allocates memory and fills it with zeros.
+     *
+     * @param size - Number of bytes to allocate
+     * @returns Uint8Array view into the pool, filled with zeros
+     */
+    allocZeroed(size: number): Uint8Array;
+    /**
+     * Resets the pool, making all memory available again.
+     */
+    reset(): void;
+    /**
+     * Checks if the pool can accommodate an allocation.
+     *
+     * @param size - Number of bytes needed
+     * @returns True if allocation would succeed
+     */
+    canAlloc(size: number): boolean;
+}
+//# sourceMappingURL=MemoryPool.d.ts.map

package/build/io/MemoryPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryPool.d.ts","sourceRoot":"","sources":["../../src/io/MemoryPool.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,UAAU;;IAsBnB;;;;;;;;;;;;;;;OAeG;gBACgB,IAAI,GAAE,MAAwB;IASjD;;OAEG;IACH,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED;;;;OAIG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;OAEG;IACH,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED;;;;OAIG;IACH,IAAW,YAAY,IAAI,iBAAiB,CAE3C;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;WACW,gBAAgB,CAAC,MAAM,EAAE,iBAAiB,GAAG,UAAU;IAarE;;;;;;;;;;;;;;;OAeG;IACI,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAmBtC;;;;;;OAMG;IACI,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAM5C;;;;;;;;;;;;;;OAcG;IACI,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,UAAU;IAItE;;;;;;;;;;;;;;;OAeG;IACI,KAAK,IAAI,IAAI;IAIpB;;;;;OAKG;IACI,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAGzC;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,gBAAgB;;IAIzB;;;;OAIG;gBACgB,IAAI,EAAE,MAAM;IAI/B;;OAEG;IACH,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED;;OAEG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;OAEG;IACH,IAAW,SAAS,IAAI,MAAM,CAE7B;IAED;;;;;;OAMG;IACI,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAgBtC;;;;;OAKG;IACI,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAM5C;;OAEG;IACI,KAAK,IAAI,IAAI;IAIpB;;;;;OAKG;IACI,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAGzC"}

package/build/io/MemoryPool.js

@@ -0,0 +1,309 @@
+/**
+ * Memory pool using SharedArrayBuffer for zero-allocation operations.
+ *
+ * Provides thread-safe memory allocation using Atomics for concurrent access.
+ * Ideal for parsing operations where temporary buffers are needed.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Thread-safe memory pool using SharedArrayBuffer.
+ *
+ * Allocates memory from a pre-allocated SharedArrayBuffer pool,
+ * eliminating garbage collection pressure from repeated allocations.
+ *
+ * Uses Atomics for thread-safe allocation when used with Workers.
+ *
+ * @example
+ * ```typescript
+ * import { MemoryPool } from '@btc-vision/bitcoin';
+ *
+ * // Create a 1MB pool
+ * const pool = new MemoryPool(1024 * 1024);
+ *
+ * // Allocate memory for transaction parsing
+ * const txBuffer = pool.alloc(500);
+ * // ... use txBuffer ...
+ *
+ * // Reset pool when done (all allocations become invalid)
+ * pool.reset();
+ * ```
+ */
+export class MemoryPool {
+    /**
+     * The underlying SharedArrayBuffer.
+     */
+    #buffer;
+    /**
+     * View for data allocations.
+     */
+    #data;
+    /**
+     * Control array for atomic offset management.
+     * Located at the end of the buffer.
+     */
+    #control;
+    /**
+     * Maximum allocatable size (buffer size minus control bytes).
+     */
+    #maxSize;
+    /**
+     * Creates a new MemoryPool.
+     *
+     * @param size - Size of the pool in bytes (default 4MB)
+     *
+     * @example
+     * ```typescript
+     * import { MemoryPool } from '@btc-vision/bitcoin';
+     *
+     * // 4MB pool (default)
+     * const pool = new MemoryPool();
+     *
+     * // 16MB pool
+     * const largePool = new MemoryPool(16 * 1024 * 1024);
+     * ```
+     */
+    constructor(size = 4 * 1024 * 1024) {
+        // Add 4 bytes for atomic control (current offset)
+        const totalSize = size + 4;
+        this.#buffer = new SharedArrayBuffer(totalSize);
+        this.#data = new Uint8Array(this.#buffer, 0, size);
+        this.#control = new Int32Array(this.#buffer, size, 1);
+        this.#maxSize = size;
+    }
+    /**
+     * Total capacity of the pool in bytes.
+     */
+    get capacity() {
+        return this.#maxSize;
+    }
+    /**
+     * Current allocation offset (bytes used).
+     *
+     * Uses Atomics for thread-safe reading.
+     */
+    get used() {
+        return Atomics.load(this.#control, 0);
+    }
+    /**
+     * Remaining available bytes.
+     */
+    get available() {
+        return this.#maxSize - this.used;
+    }
+    /**
+     * The underlying SharedArrayBuffer.
+     *
+     * Can be transferred to Workers for shared memory access.
+     */
+    get sharedBuffer() {
+        return this.#buffer;
+    }
+    /**
+     * Creates a MemoryPool from an existing SharedArrayBuffer.
+     *
+     * Useful for sharing a pool between Workers.
+     *
+     * @param buffer - Existing SharedArrayBuffer
+     * @returns A new MemoryPool instance wrapping the buffer
+     *
+     * @example
+     * ```typescript
+     * // Main thread
+     * const pool = new MemoryPool(1024 * 1024);
+     * worker.postMessage({ buffer: pool.sharedBuffer });
+     *
+     * // Worker thread
+     * self.onmessage = (e) => {
+     *     const pool = MemoryPool.fromSharedBuffer(e.data.buffer);
+     *     const mem = pool.alloc(100);
+     * };
+     * ```
+     */
+    static fromSharedBuffer(buffer) {
+        const pool = Object.create(MemoryPool.prototype);
+        const size = buffer.byteLength - 4;
+        // Use Object.defineProperty to set private fields on the created object
+        Object.defineProperty(pool, '#buffer', { value: buffer });
+        Object.defineProperty(pool, '#data', { value: new Uint8Array(buffer, 0, size) });
+        Object.defineProperty(pool, '#control', { value: new Int32Array(buffer, size, 1) });
+        Object.defineProperty(pool, '#maxSize', { value: size });
+        return pool;
+    }
+    /**
+     * Allocates memory from the pool.
+     *
+     * Thread-safe using Atomics.add for concurrent access.
+     *
+     * @param size - Number of bytes to allocate
+     * @returns Uint8Array view into the pool
+     * @throws RangeError if pool is exhausted
+     *
+     * @example
+     * ```typescript
+     * const pool = new MemoryPool(1024);
+     * const buf1 = pool.alloc(100); // First 100 bytes
+     * const buf2 = pool.alloc(200); // Next 200 bytes
+     * ```
+     */
+    alloc(size) {
+        if (size <= 0) {
+            throw new RangeError('Allocation size must be positive');
+        }
+        // Atomically reserve space
+        const oldOffset = Atomics.add(this.#control, 0, size);
+        if (oldOffset + size > this.#maxSize) {
+            // Undo the allocation
+            Atomics.sub(this.#control, 0, size);
+            throw new RangeError(`MemoryPool exhausted: requested ${size} bytes, only ${this.#maxSize - oldOffset} available`);
+        }
+        return this.#data.subarray(oldOffset, oldOffset + size);
+    }
+    /**
+     * Allocates memory and fills it with zeros.
+     *
+     * @param size - Number of bytes to allocate
+     * @returns Uint8Array view into the pool, filled with zeros
+     * @throws RangeError if pool is exhausted
+     */
+    allocZeroed(size) {
+        const mem = this.alloc(size);
+        mem.fill(0);
+        return mem;
+    }
+    /**
+     * Allocates memory for a specific typed array.
+     *
+     * @param length - Number of elements
+     * @param bytesPerElement - Size of each element in bytes
+     * @returns Uint8Array view (use constructor of target type on underlying buffer)
+     * @throws RangeError if pool is exhausted
+     *
+     * @example
+     * ```typescript
+     * const pool = new MemoryPool(1024);
+     * const bytes = pool.allocTyped(10, 4); // 40 bytes for 10 Uint32
+     * const u32View = new Uint32Array(bytes.buffer, bytes.byteOffset, 10);
+     * ```
+     */
+    allocTyped(length, bytesPerElement) {
+        return this.alloc(length * bytesPerElement);
+    }
+    /**
+     * Resets the pool, making all memory available again.
+     *
+     * WARNING: All previously allocated views become invalid.
+     * Only call when you're sure no references are held.
+     *
+     * Thread-safe using Atomics.store.
+     *
+     * @example
+     * ```typescript
+     * const pool = new MemoryPool(1024);
+     * const buf = pool.alloc(100);
+     * // ... use buf ...
+     * pool.reset(); // buf is now invalid!
+     * ```
+     */
+    reset() {
+        Atomics.store(this.#control, 0, 0);
+    }
+    /**
+     * Checks if the pool can accommodate an allocation.
+     *
+     * @param size - Number of bytes needed
+     * @returns True if allocation would succeed
+     */
+    canAlloc(size) {
+        return this.available >= size;
+    }
+}
+/**
+ * Non-shared memory pool using regular ArrayBuffer.
+ *
+ * Use when SharedArrayBuffer is not available (e.g., browsers without
+ * proper COOP/COEP headers) or when thread-safety is not needed.
+ *
+ * @example
+ * ```typescript
+ * import { SimpleMemoryPool } from '@btc-vision/bitcoin';
+ *
+ * const pool = new SimpleMemoryPool(1024 * 1024);
+ * const buf = pool.alloc(100);
+ * ```
+ */
+export class SimpleMemoryPool {
+    #data;
+    #offset = 0;
+    /**
+     * Creates a new SimpleMemoryPool.
+     *
+     * @param size - Size of the pool in bytes
+     */
+    constructor(size) {
+        this.#data = new Uint8Array(size);
+    }
+    /**
+     * Total capacity of the pool in bytes.
+     */
+    get capacity() {
+        return this.#data.length;
+    }
+    /**
+     * Current allocation offset (bytes used).
+     */
+    get used() {
+        return this.#offset;
+    }
+    /**
+     * Remaining available bytes.
+     */
+    get available() {
+        return this.#data.length - this.#offset;
+    }
+    /**
+     * Allocates memory from the pool.
+     *
+     * @param size - Number of bytes to allocate
+     * @returns Uint8Array view into the pool
+     * @throws RangeError if pool is exhausted
+     */
+    alloc(size) {
+        if (size <= 0) {
+            throw new RangeError('Allocation size must be positive');
+        }
+        if (this.#offset + size > this.#data.length) {
+            throw new RangeError(`SimpleMemoryPool exhausted: requested ${size} bytes, only ${this.available} available`);
+        }
+        const start = this.#offset;
+        this.#offset += size;
+        return this.#data.subarray(start, this.#offset);
+    }
+    /**
+     * Allocates memory and fills it with zeros.
+     *
+     * @param size - Number of bytes to allocate
+     * @returns Uint8Array view into the pool, filled with zeros
+     */
+    allocZeroed(size) {
+        const mem = this.alloc(size);
+        mem.fill(0);
+        return mem;
+    }
+    /**
+     * Resets the pool, making all memory available again.
+     */
+    reset() {
+        this.#offset = 0;
+    }
+    /**
+     * Checks if the pool can accommodate an allocation.
+     *
+     * @param size - Number of bytes needed
+     * @returns True if allocation would succeed
+     */
+    canAlloc(size) {
+        return this.available >= size;
+    }
+}
+//# sourceMappingURL=MemoryPool.js.map

package/build/io/MemoryPool.js.map

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

package/build/io/base64.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Base64 encoding and decoding utilities.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Decodes a base64 string to a Uint8Array.
+ *
+ * @param base64 - The base64-encoded string to decode
+ * @returns Uint8Array containing the decoded bytes
+ */
+export declare function fromBase64(base64: string): Uint8Array;
+//# sourceMappingURL=base64.d.ts.map

package/build/io/base64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../../src/io/base64.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAOrD"}

package/build/io/base64.js

@@ -0,0 +1,20 @@
+/**
+ * Base64 encoding and decoding utilities.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Decodes a base64 string to a Uint8Array.
+ *
+ * @param base64 - The base64-encoded string to decode
+ * @returns Uint8Array containing the decoded bytes
+ */
+export function fromBase64(base64) {
+    const binaryString = atob(base64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+}
+//# sourceMappingURL=base64.js.map

package/build/io/base64.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.js","sourceRoot":"","sources":["../../src/io/base64.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CAAC,MAAc;IACrC,MAAM,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IAClC,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;IAClD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3C,KAAK,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IAC1C,CAAC;IACD,OAAO,KAAK,CAAC;AACjB,CAAC"}

package/build/io/hex.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Hex encoding and decoding utilities.
+ *
+ * Direct implementations with zero dependencies and no wrappers.
+ * Optimized for performance with lookup tables.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Converts a Uint8Array to a lowercase hex string.
+ *
+ * @param bytes - The byte array to convert
+ * @returns Lowercase hex string representation
+ *
+ * @example
+ * ```typescript
+ * import { toHex } from '@btc-vision/bitcoin';
+ *
+ * const bytes = new Uint8Array([0xde, 0xad, 0xbe, 0xef]);
+ * const hex = toHex(bytes);
+ * console.log(hex); // 'deadbeef'
+ * ```
+ */
+export declare function toHex(bytes: Uint8Array): string;
+/**
+ * Converts a hex string to a Uint8Array.
+ *
+ * Accepts hex strings with or without '0x' prefix.
+ * Case-insensitive (accepts both 'DEADBEEF' and 'deadbeef').
+ *
+ * @param hex - The hex string to convert
+ * @returns Uint8Array containing the decoded bytes
+ * @throws TypeError if hex string has odd length
+ * @throws TypeError if hex string contains invalid characters
+ *
+ * @example
+ * ```typescript
+ * import { fromHex, toHex } from '@btc-vision/bitcoin';
+ *
+ * const bytes = fromHex('deadbeef');
+ * console.log(bytes); // Uint8Array [222, 173, 190, 239]
+ *
+ * // Also works with 0x prefix
+ * const bytes2 = fromHex('0xCAFEBABE');
+ * console.log(toHex(bytes2)); // 'cafebabe'
+ * ```
+ */
+export declare function fromHex(hex: string): Uint8Array;
+/**
+ * Checks if a string is valid hexadecimal.
+ *
+ * @param value - The string to check
+ * @returns True if the string is valid hex (even length, valid chars)
+ *
+ * @example
+ * ```typescript
+ * import { isHex } from '@btc-vision/bitcoin';
+ *
+ * isHex('deadbeef'); // true
+ * isHex('0xdeadbeef'); // true
+ * isHex('DEADBEEF'); // true
+ * isHex('deadbee'); // false (odd length)
+ * isHex('deadbeeg'); // false (invalid char)
+ * ```
+ */
+export declare function isHex(value: string): boolean;
+//# sourceMappingURL=hex.d.ts.map

package/build/io/hex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.d.ts","sourceRoot":"","sources":["../../src/io/hex.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA0BH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAM/C;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAsC/C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAkB5C"}