gitx.do 0.1.0 → 0.1.2

package/dist/types/storage.js

@@ -1,191 +0,0 @@
-/**
- * @fileoverview Storage Interface Types
- *
- * This module defines the canonical interfaces for object storage and commit providers.
- * All storage-related interfaces are defined here as the single source of truth.
- *
- * The interfaces follow a layered design:
- * - {@link BasicObjectStore} - Core object CRUD operations
- * - {@link RefObjectStore} - Adds ref management capabilities
- * - {@link TreeDiffObjectStore} - Specialized for tree diff operations
- * - {@link ObjectStore} - Full-featured store combining all capabilities
- *
- * Similarly for commit providers:
- * - {@link BasicCommitProvider} - Core commit retrieval
- * - {@link CommitProvider} - Extended with path filtering and tree access
- *
- * @module types/storage
- *
- * @example
- * ```typescript
- * import type { ObjectStore, CommitProvider } from './types/storage'
- *
- * // Implement a storage backend
- * class MyObjectStore implements ObjectStore {
- *   async getObject(sha: string) { ... }
- *   async storeObject(type: string, data: Uint8Array) { ... }
- *   // ... other methods
- * }
- * ```
- */
-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 +0,0 @@
-{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../src/types/storage.ts"],"names":[],"mappings":"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"}

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

@@ -1,60 +0,0 @@
-/**
- * @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

@@ -1 +0,0 @@
-{"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,OAAO,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU;CAsBhE;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,YAAY,CAgB1E"}

package/dist/types/worker-loader.js

@@ -1,62 +0,0 @@
-/**
- * @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

@@ -1 +0,0 @@
-{"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,OAAkC;QAChD,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,OAAgB,EAAqB,EAAE;gBACnD,OAAO,IAAI,QAAQ,CAAC,2BAA2B,CAAC,CAAA;YAClD,CAAC;YACD,aAAa,EAAE,CAAC,IAAa,EAAoB,EAAE;gBACjD,OAAO;oBACL,KAAK,EAAE,KAAK,EAAE,OAAgB,EAAqB,EAAE;wBACnD,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

@@ -1,197 +0,0 @@
-/**
- * @fileoverview SHA Hashing Utilities for Git Objects
- *
- * This module provides cryptographic hashing functions used for Git object
- * identification and verification. Git uses SHA-1 as its primary hash algorithm,
- * with SHA-256 available as an optional newer algorithm (Git v2.29+).
- *
- * Core hash primitives are re-exported from fsx.do, with gitx-specific
- * utilities like HashCache and hashObject defined here.
- *
- * @module utils/hash
- *
- * @example
- * ```typescript
- * import { sha1, hashObject, hexToBytes, bytesToHex } from './utils/hash'
- *
- * // Hash raw data
- * const hash = await sha1('Hello, World!')
- *
- * // Hash as a Git object (includes type header)
- * const content = new TextEncoder().encode('file content')
- * const blobSha = await hashObject('blob', content)
- * console.log(`blob ${blobSha}`)
- * ```
- */
-export { sha1, sha256, hexToBytes, bytesToHex } from '../../../fsx/src/cas/hash';
-/**
- * Hash a Git object with its type header.
- *
- * @description
- * Computes the SHA-1 hash of a Git object including its header.
- * The header format is: "{type} {size}\0" followed by the content.
- *
- * This matches the output of `git hash-object` command and is the
- * standard way Git computes object identifiers.
- *
- * @param type - Object type ('blob', 'tree', 'commit', 'tag')
- * @param data - Object content as binary data (without header)
- * @returns 40-character lowercase hexadecimal SHA-1 hash
- *
- * @example
- * ```typescript
- * // Hash a blob (equivalent to `echo -n "hello" | git hash-object --stdin`)
- * const content = new TextEncoder().encode('hello')
- * const sha = await hashObject('blob', content)
- * console.log(sha) // 'b6fc4c620b67d95f953a5c1c1230aaab5db5a1b0'
- *
- * // Verify with git:
- * // $ echo -n "hello" | git hash-object --stdin
- * // b6fc4c620b67d95f953a5c1c1230aaab5db5a1b0
- * ```
- */
-export declare function hashObject(type: string, data: Uint8Array): Promise<string>;
-/**
- * LRU cache for storing computed hashes.
- *
- * @description
- * 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.
- *
- * **Thread Safety**: This implementation is NOT thread-safe. In multi-threaded
- * environments, external synchronization is required.
- *
- * @class HashCache
- *
- * @example
- * ```typescript
- * const cache = new HashCache(1000) // Cache up to 1000 hashes
- *
- * // 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 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;
-    };
-}
-/**
- * Global hash cache instance for common use cases.
- *
- * @description
- * 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.
- *
- * **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
- * import { globalHashCache, sha1 } from './utils/hash'
- *
- * // Use the global cache
- * const hash = await globalHashCache.getOrCompute(data, () => sha1(data))
- *
- * // Check cache stats
- * console.log(globalHashCache.getStats())
- * ```
- */
-export declare const globalHashCache: HashCache;
-//# sourceMappingURL=hash.d.ts.map

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

@@ -1 +0,0 @@
-{"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,2BAA2B,CAAA;AAKhF;;;;;;;;;;;;;;;;;;;;;;;;;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"}