neozipkit 0.2.1 → 0.3.0

package/dist/core/components/HashCalculator.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Unified hash calculator supporting:
+ * - Incremental CRC-32 and SHA-256 calculation from raw data chunks
+ * - Accumulation of pre-computed SHA-256 hashes with XOR and Merkle tree operations
+ * - Merkle tree construction, proof generation, and verification
+ *
+ * Usage examples:
+ *
+ * Incremental hash calculation:
+ * ```typescript
+ * const calculator = new HashCalculator({ useSHA256: true });
+ * calculator.update(dataChunk);
+ * const crc32 = calculator.finalizeCRC32();
+ * const sha256 = calculator.finalizeSHA256();
+ * ```
+ *
+ * Hash accumulation:
+ * ```typescript
+ * const calculator = new HashCalculator({ enableAccumulation: true });
+ * calculator.addHash(sha256Hash1);
+ * calculator.addHash(sha256Hash2);
+ * const xor = calculator.xorHash();
+ * const merkle = calculator.merkleRoot();
+ * ```
+ */
+export declare class HashCalculator {
+    private crc32State;
+    private sha256Hash;
+    private useSHA256;
+    private hashes;
+    private xorResult;
+    private enableAccumulation;
+    private merkleLeaves;
+    private merkleLayers;
+    private merkleOptions;
+    /**
+     * Creates a new HashCalculator instance
+     * @param options - Configuration options:
+     *   - useSHA256: Enable SHA-256 calculation for incremental mode (default: false)
+     *   - enableAccumulation: Enable hash accumulation mode (default: false)
+     */
+    constructor(options?: {
+        useSHA256?: boolean;
+        enableAccumulation?: boolean;
+    });
+    /**
+     * Update hash state with a new chunk of data
+     * Updates both CRC-32 and SHA-256 (if enabled) incrementally
+     * @param chunk - Data chunk to process
+     */
+    update(chunk: Buffer): void;
+    /**
+     * Get final CRC-32 value
+     * @returns Final CRC-32 value as unsigned 32-bit integer
+     */
+    finalizeCRC32(): number;
+    /**
+     * Get final SHA-256 hash as hex string
+     * @returns SHA-256 hash as hex string, or null if SHA-256 not enabled
+     */
+    finalizeSHA256(): string | null;
+    /**
+     * Reset the incremental hash calculation state
+     */
+    reset(): void;
+    /**
+     * Adds a pre-computed SHA-256 hash to both the XOR accumulation and hash array
+     * @param hash - Hash value as hex string or Buffer (must be 32 bytes for SHA-256)
+     */
+    addHash(hash: string | Buffer): void;
+    /**
+     * Gets the accumulated XOR of all added hashes
+     * @returns Hex string of XOR result
+     */
+    xorHash(): string;
+    /**
+     * Creates a Merkle tree from accumulated hashes and returns the root
+     * @returns Hex string of Merkle root, or null if no hashes added
+     */
+    merkleRoot(): string | null;
+    /**
+     * Gets the number of hashes accumulated
+     * @returns Number of accumulated hashes
+     */
+    leafCount(): number;
+    /**
+     * Clears the accumulated hashes and resets XOR buffer
+     */
+    clear(): void;
+    /**
+     * Combines multiple hash results into a single Merkle root
+     * Static method for combining results from multiple HashCalculator instances
+     * @param results - Array of objects containing merkleRoot properties
+     * @returns Combined Merkle root as hex string, or null if no valid roots
+     */
+    static combineResults(results: {
+        merkleRoot?: string;
+    }[]): string | null;
+    /**
+     * Computes SHA-256 hash of input data
+     * @param data - Data to hash
+     * @returns Buffer containing hash
+     */
+    private hash;
+    /**
+     * Combines two child hashes to create parent hash
+     * @param left - Left child hash
+     * @param right - Right child hash
+     * @returns Combined hash of children
+     */
+    private combinedHash;
+    /**
+     * Builds the Merkle tree by creating successive layers of hashes
+     * @param nodes - Array of nodes in current layer
+     */
+    private createHashes;
+    /**
+     * Rebuilds the Merkle tree from current leaves
+     */
+    private rebuildMerkleTree;
+    /**
+     * Generates a proof of inclusion for a leaf node
+     * @param leaf - The leaf node to generate proof for
+     * @returns Array of sibling hashes needed to reconstruct root
+     * @throws Error if leaf not found in tree or accumulation not enabled
+     */
+    getProof(leaf: Buffer): Buffer[];
+    /**
+     * Verifies a proof of inclusion for a leaf node
+     * @param proof - Array of sibling hashes from getProof()
+     * @param targetHash - Hash of the leaf node being verified
+     * @param root - Expected root hash
+     * @returns boolean indicating if proof is valid
+     */
+    verify(proof: Buffer[], targetHash: Buffer, root: Buffer): boolean;
+}
+export default HashCalculator;
+//# sourceMappingURL=HashCalculator.d.ts.map

package/dist/core/components/HashCalculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HashCalculator.d.ts","sourceRoot":"","sources":["../../../src/core/components/HashCalculator.ts"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,cAAc;IAEzB,OAAO,CAAC,UAAU,CAAc;IAChC,OAAO,CAAC,UAAU,CAA4B;IAC9C,OAAO,CAAC,SAAS,CAAkB;IAGnC,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,SAAS,CAA+B;IAChD,OAAO,CAAC,kBAAkB,CAAkB;IAG5C,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,YAAY,CAAkB;IACtC,OAAO,CAAC,aAAa,CAKnB;IAEF;;;;;OAKG;gBACS,OAAO,CAAC,EAAE;QACpB,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,kBAAkB,CAAC,EAAE,OAAO,CAAC;KAC9B;IAaD;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAY3B;;;OAGG;IACH,aAAa,IAAI,MAAM;IAIvB;;;OAGG;IACH,cAAc,IAAI,MAAM,GAAG,IAAI;IAO/B;;OAEG;IACH,KAAK,IAAI,IAAI;IAWb;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAuBpC;;;OAGG;IACH,OAAO,IAAI,MAAM;IAOjB;;;OAGG;IACH,UAAU,IAAI,MAAM,GAAG,IAAI;IAsB3B;;;OAGG;IACH,SAAS,IAAI,MAAM;IAOnB;;OAEG;IACH,KAAK,IAAI,IAAI;IAUb;;;;;OAKG;IACH,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,GAAG,MAAM,GAAG,IAAI;IAiBxE;;;;OAIG;IACH,OAAO,CAAC,IAAI;IAIZ;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAOpB;;;OAGG;IACH,OAAO,CAAC,YAAY;IA8BpB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAsBzB;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE;IA2BhC;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO;CAWnE;AAGD,eAAe,cAAc,CAAC"}

package/dist/core/components/HashCalculator.js

@@ -0,0 +1,360 @@
+"use strict";
+// ======================================
+//  HashCalculator.ts - Unified Hash Component
+//  Combines StreamHashCalculator, HashAccumulator, and MerkleTree functionality
+// ======================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashCalculator = void 0;
+const crypto = __importStar(require("crypto"));
+const ZipCrypto_1 = require("../encryption/ZipCrypto");
+/**
+ * Unified hash calculator supporting:
+ * - Incremental CRC-32 and SHA-256 calculation from raw data chunks
+ * - Accumulation of pre-computed SHA-256 hashes with XOR and Merkle tree operations
+ * - Merkle tree construction, proof generation, and verification
+ *
+ * Usage examples:
+ *
+ * Incremental hash calculation:
+ * ```typescript
+ * const calculator = new HashCalculator({ useSHA256: true });
+ * calculator.update(dataChunk);
+ * const crc32 = calculator.finalizeCRC32();
+ * const sha256 = calculator.finalizeSHA256();
+ * ```
+ *
+ * Hash accumulation:
+ * ```typescript
+ * const calculator = new HashCalculator({ enableAccumulation: true });
+ * calculator.addHash(sha256Hash1);
+ * calculator.addHash(sha256Hash2);
+ * const xor = calculator.xorHash();
+ * const merkle = calculator.merkleRoot();
+ * ```
+ */
+class HashCalculator {
+    /**
+     * Creates a new HashCalculator instance
+     * @param options - Configuration options:
+     *   - useSHA256: Enable SHA-256 calculation for incremental mode (default: false)
+     *   - enableAccumulation: Enable hash accumulation mode (default: false)
+     */
+    constructor(options) {
+        // Incremental hash calculation state (from StreamHashCalculator)
+        this.crc32State = ~0;
+        this.sha256Hash = null;
+        this.useSHA256 = false;
+        // Hash accumulation state (from HashAccumulator)
+        this.hashes = [];
+        this.xorResult = Buffer.alloc(32, 0);
+        this.enableAccumulation = false;
+        // Merkle tree state (from MerkleTree)
+        this.merkleLeaves = [];
+        this.merkleLayers = [];
+        this.merkleOptions = {
+            hashLeaves: false,
+            sortLeaves: true,
+            sortPairs: true,
+            duplicateOdd: true
+        };
+        this.useSHA256 = options?.useSHA256 || false;
+        this.enableAccumulation = options?.enableAccumulation || false;
+        if (this.useSHA256) {
+            this.sha256Hash = crypto.createHash('sha256');
+        }
+    }
+    // ============================================================================
+    // Incremental Hash Calculation Methods (from StreamHashCalculator)
+    // ============================================================================
+    /**
+     * Update hash state with a new chunk of data
+     * Updates both CRC-32 and SHA-256 (if enabled) incrementally
+     * @param chunk - Data chunk to process
+     */
+    update(chunk) {
+        // Update CRC-32 incrementally using existing crc32update function
+        for (let i = 0; i < chunk.length; i++) {
+            this.crc32State = (0, ZipCrypto_1.crc32update)(this.crc32State, chunk[i]);
+        }
+        // Update SHA-256 incrementally
+        if (this.sha256Hash) {
+            this.sha256Hash.update(chunk);
+        }
+    }
+    /**
+     * Get final CRC-32 value
+     * @returns Final CRC-32 value as unsigned 32-bit integer
+     */
+    finalizeCRC32() {
+        return ~this.crc32State >>> 0; // Finalize with ~0 like the existing crc32 function
+    }
+    /**
+     * Get final SHA-256 hash as hex string
+     * @returns SHA-256 hash as hex string, or null if SHA-256 not enabled
+     */
+    finalizeSHA256() {
+        if (this.sha256Hash) {
+            return this.sha256Hash.digest('hex');
+        }
+        return null;
+    }
+    /**
+     * Reset the incremental hash calculation state
+     */
+    reset() {
+        this.crc32State = ~0;
+        if (this.sha256Hash) {
+            this.sha256Hash = crypto.createHash('sha256');
+        }
+    }
+    // ============================================================================
+    // Hash Accumulation Methods (from HashAccumulator)
+    // ============================================================================
+    /**
+     * Adds a pre-computed SHA-256 hash to both the XOR accumulation and hash array
+     * @param hash - Hash value as hex string or Buffer (must be 32 bytes for SHA-256)
+     */
+    addHash(hash) {
+        if (!this.enableAccumulation) {
+            throw new Error('Hash accumulation not enabled. Set enableAccumulation: true in constructor.');
+        }
+        // Convert hash to Buffer if it's a string
+        const hashBuffer = typeof hash === 'string'
+            ? Buffer.from(hash, 'hex')
+            : hash;
+        // Add to array for Merkle tree
+        this.hashes.push(hashBuffer);
+        this.merkleLeaves.push(hashBuffer);
+        // XOR accumulation
+        for (let i = 0; i < 32; i++) {
+            this.xorResult[i] ^= hashBuffer[i];
+        }
+        // Rebuild Merkle tree when hash is added
+        this.rebuildMerkleTree();
+    }
+    /**
+     * Gets the accumulated XOR of all added hashes
+     * @returns Hex string of XOR result
+     */
+    xorHash() {
+        if (!this.enableAccumulation) {
+            throw new Error('Hash accumulation not enabled. Set enableAccumulation: true in constructor.');
+        }
+        return this.xorResult.toString('hex');
+    }
+    /**
+     * Creates a Merkle tree from accumulated hashes and returns the root
+     * @returns Hex string of Merkle root, or null if no hashes added
+     */
+    merkleRoot() {
+        if (!this.enableAccumulation) {
+            throw new Error('Hash accumulation not enabled. Set enableAccumulation: true in constructor.');
+        }
+        if (this.merkleLeaves.length === 0) {
+            return null;
+        }
+        // If Merkle tree not built yet, build it
+        if (this.merkleLayers.length === 0) {
+            this.rebuildMerkleTree();
+        }
+        const root = this.merkleLayers[this.merkleLayers.length - 1];
+        if (root && root.length > 0) {
+            return root[0].toString('hex');
+        }
+        return null;
+    }
+    /**
+     * Gets the number of hashes accumulated
+     * @returns Number of accumulated hashes
+     */
+    leafCount() {
+        if (!this.enableAccumulation) {
+            throw new Error('Hash accumulation not enabled. Set enableAccumulation: true in constructor.');
+        }
+        return this.hashes.length;
+    }
+    /**
+     * Clears the accumulated hashes and resets XOR buffer
+     */
+    clear() {
+        if (!this.enableAccumulation) {
+            throw new Error('Hash accumulation not enabled. Set enableAccumulation: true in constructor.');
+        }
+        this.hashes = [];
+        this.merkleLeaves = [];
+        this.merkleLayers = [];
+        this.xorResult = Buffer.alloc(32, 0);
+    }
+    /**
+     * Combines multiple hash results into a single Merkle root
+     * Static method for combining results from multiple HashCalculator instances
+     * @param results - Array of objects containing merkleRoot properties
+     * @returns Combined Merkle root as hex string, or null if no valid roots
+     */
+    static combineResults(results) {
+        const calculator = new HashCalculator({ enableAccumulation: true });
+        // Combine all hashes
+        for (const result of results) {
+            if (result.merkleRoot) {
+                calculator.addHash(result.merkleRoot);
+            }
+        }
+        return calculator.merkleRoot();
+    }
+    // ============================================================================
+    // Merkle Tree Methods (from MerkleTree)
+    // ============================================================================
+    /**
+     * Computes SHA-256 hash of input data
+     * @param data - Data to hash
+     * @returns Buffer containing hash
+     */
+    hash(data) {
+        return crypto.createHash('sha256').update(data).digest();
+    }
+    /**
+     * Combines two child hashes to create parent hash
+     * @param left - Left child hash
+     * @param right - Right child hash
+     * @returns Combined hash of children
+     */
+    combinedHash(left, right) {
+        if (this.merkleOptions.sortPairs && Buffer.compare(left, right) > 0) {
+            [left, right] = [right, left];
+        }
+        return this.hash(Buffer.concat([left, right]));
+    }
+    /**
+     * Builds the Merkle tree by creating successive layers of hashes
+     * @param nodes - Array of nodes in current layer
+     */
+    createHashes(nodes) {
+        while (nodes.length > 1) {
+            const layerIndex = this.merkleLayers.length;
+            this.merkleLayers.push([]);
+            // Process pairs of nodes
+            for (let i = 0; i < nodes.length - 1; i += 2) {
+                const left = nodes[i];
+                const right = nodes[i + 1];
+                const hash = this.combinedHash(left, right);
+                this.merkleLayers[layerIndex].push(hash);
+            }
+            // Handle odd number of nodes
+            if (nodes.length % 2 === 1) {
+                const last = nodes[nodes.length - 1];
+                if (this.merkleOptions.duplicateOdd) {
+                    // Duplicate the last node if odd
+                    const hash = this.combinedHash(last, last);
+                    this.merkleLayers[layerIndex].push(hash);
+                }
+                else {
+                    // Push last node up to next layer
+                    this.merkleLayers[layerIndex].push(last);
+                }
+            }
+            nodes = this.merkleLayers[layerIndex];
+        }
+    }
+    /**
+     * Rebuilds the Merkle tree from current leaves
+     */
+    rebuildMerkleTree() {
+        if (this.merkleLeaves.length === 0) {
+            this.merkleLayers = [];
+            return;
+        }
+        // Process leaves according to options
+        const processedLeaves = this.merkleLeaves.map(leaf => {
+            if (this.merkleOptions.hashLeaves) {
+                return this.hash(leaf);
+            }
+            return Buffer.isBuffer(leaf) ? leaf : Buffer.from(leaf);
+        });
+        if (this.merkleOptions.sortLeaves) {
+            processedLeaves.sort(Buffer.compare);
+        }
+        this.merkleLayers = [processedLeaves];
+        this.createHashes(processedLeaves);
+    }
+    /**
+     * Generates a proof of inclusion for a leaf node
+     * @param leaf - The leaf node to generate proof for
+     * @returns Array of sibling hashes needed to reconstruct root
+     * @throws Error if leaf not found in tree or accumulation not enabled
+     */
+    getProof(leaf) {
+        if (!this.enableAccumulation) {
+            throw new Error('Hash accumulation not enabled. Set enableAccumulation: true in constructor.');
+        }
+        if (this.merkleLayers.length === 0) {
+            this.rebuildMerkleTree();
+        }
+        let index = this.merkleLeaves.findIndex(item => item.equals(leaf));
+        if (index === -1) {
+            throw new Error('Leaf not found in tree');
+        }
+        return this.merkleLayers.reduce((proof, layer) => {
+            if (layer.length === 1)
+                return proof;
+            const pairIndex = index % 2 === 0 ? index + 1 : index - 1;
+            if (pairIndex < layer.length) {
+                proof.push(layer[pairIndex]);
+            }
+            index = Math.floor(index / 2);
+            return proof;
+        }, []);
+    }
+    /**
+     * Verifies a proof of inclusion for a leaf node
+     * @param proof - Array of sibling hashes from getProof()
+     * @param targetHash - Hash of the leaf node being verified
+     * @param root - Expected root hash
+     * @returns boolean indicating if proof is valid
+     */
+    verify(proof, targetHash, root) {
+        let computedHash = targetHash;
+        for (const proofElement of proof) {
+            computedHash = Buffer.compare(computedHash, proofElement) <= 0
+                ? this.combinedHash(computedHash, proofElement)
+                : this.combinedHash(proofElement, computedHash);
+        }
+        return computedHash.equals(root);
+    }
+}
+exports.HashCalculator = HashCalculator;
+// Default export
+exports.default = HashCalculator;
+//# sourceMappingURL=HashCalculator.js.map

package/dist/core/components/HashCalculator.js.map

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

package/dist/core/components/Logger.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Global Logger Utility for NeoZipKit
+ * Provides centralized console control with configurable log levels
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+export interface LoggerConfig {
+    enabled: boolean;
+    level: LogLevel;
+}
+/**
+ * Global Logger class for controlling console output throughout NeoZipKit
+ */
+export declare class Logger {
+    private static config;
+    private static originalConsole;
+    /**
+     * Configure the logger
+     */
+    static configure(config: Partial<LoggerConfig>): void;
+    /**
+     * Get current logger configuration
+     */
+    static getConfig(): LoggerConfig;
+    /**
+     * Enable logging
+     */
+    static enable(): void;
+    /**
+     * Disable all logging
+     */
+    static disable(): void;
+    /**
+     * Set log level
+     */
+    static setLevel(level: LogLevel): void;
+    /**
+     * Check if a log level should be output
+     */
+    private static shouldLog;
+    /**
+     * Log a message
+     */
+    static log(...args: any[]): void;
+    /**
+     * Log an error message
+     */
+    static error(...args: any[]): void;
+    /**
+     * Log a warning message
+     */
+    static warn(...args: any[]): void;
+    /**
+     * Log a debug message
+     */
+    static debug(...args: any[]): void;
+    /**
+     * Log an info message
+     */
+    static info(...args: any[]): void;
+    /**
+     * Override console methods globally (use with caution)
+     */
+    static overrideConsole(): void;
+    /**
+     * Restore original console methods
+     */
+    static restoreConsole(): void;
+}
+/**
+ * Environment-based configuration
+ */
+export declare function configureLoggerFromEnvironment(): void;
+//# sourceMappingURL=Logger.d.ts.map

package/dist/core/components/Logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.d.ts","sourceRoot":"","sources":["../../../src/core/components/Logger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEtE,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,QAAQ,CAAC;CACjB;AAED;;GAEG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAC,MAAM,CAGnB;IAEF,OAAO,CAAC,MAAM,CAAC,eAAe,CAM5B;IAEF;;OAEG;IACH,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI;IAIrD;;OAEG;IACH,MAAM,CAAC,SAAS,IAAI,YAAY;IAIhC;;OAEG;IACH,MAAM,CAAC,MAAM,IAAI,IAAI;IAIrB;;OAEG;IACH,MAAM,CAAC,OAAO,IAAI,IAAI;IAItB;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAKtC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,SAAS;IAUxB;;OAEG;IACH,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAMhC;;OAEG;IACH,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAMlC;;OAEG;IACH,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAMjC;;OAEG;IACH,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAOlC;;OAEG;IACH,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAOjC;;OAEG;IACH,MAAM,CAAC,eAAe,IAAI,IAAI;IAQ9B;;OAEG;IACH,MAAM,CAAC,cAAc,IAAI,IAAI;CAQ9B;AAED;;GAEG;AACH,wBAAgB,8BAA8B,IAAI,IAAI,CAuBrD"}