@uploadista/client-core 0.0.3

package/dist/chunk-buffer.js

@@ -0,0 +1,236 @@
+/**
+ * ChunkBuffer accumulates small chunks until they meet the minimum threshold
+ * required by the datastore (e.g., S3's 5MB minimum part size).
+ *
+ * This prevents inefficient upload/download cycles of incomplete parts by buffering
+ * small chunks in memory until they reach the datastore's minimum size requirement.
+ * The buffer automatically flushes when the threshold is met, the maximum buffer
+ * size is exceeded, or a timeout occurs.
+ *
+ * @example Basic usage with S3's 5MB minimum
+ * ```typescript
+ * const buffer = new ChunkBuffer({
+ *   minThreshold: 5 * 1024 * 1024, // 5MB
+ *   maxBufferSize: 10 * 1024 * 1024, // 10MB
+ *   timeoutMs: 30000, // 30 seconds
+ * });
+ *
+ * // Add chunks as they arrive
+ * const chunk1 = new Uint8Array(2 * 1024 * 1024); // 2MB
+ * buffer.add(chunk1); // Returns null (below threshold)
+ *
+ * const chunk2 = new Uint8Array(3 * 1024 * 1024); // 3MB
+ * const buffered = buffer.add(chunk2); // Returns combined 5MB chunk
+ * ```
+ *
+ * @example Handling incomplete uploads
+ * ```typescript
+ * const buffer = new ChunkBuffer({ minThreshold: 5 * 1024 * 1024 });
+ *
+ * // After adding several small chunks
+ * buffer.add(smallChunk1);
+ * buffer.add(smallChunk2);
+ *
+ * // Force flush remaining data at end of upload
+ * if (buffer.hasPendingData()) {
+ *   const finalChunk = buffer.flush();
+ *   await uploadFinalChunk(finalChunk);
+ * }
+ * ```
+ */
+export class ChunkBuffer {
+    /**
+     * Creates a new ChunkBuffer instance.
+     *
+     * @param config - Buffer configuration including thresholds and timeout
+     */
+    constructor(config) {
+        this.buffer = [];
+        this.currentSize = 0;
+        this.lastAddTime = 0;
+        this.config = {
+            minThreshold: config.minThreshold,
+            maxBufferSize: config.maxBufferSize ?? config.minThreshold * 2,
+            timeoutMs: config.timeoutMs ?? 30000, // 30 seconds
+        };
+    }
+    /**
+     * Adds a chunk to the buffer and returns the accumulated chunk if the flush threshold is met.
+     *
+     * The buffer will automatically flush (return the combined chunk) when:
+     * - The total buffered size meets or exceeds minThreshold
+     * - The total buffered size exceeds maxBufferSize
+     * - The time since the last chunk exceeds timeoutMs
+     *
+     * @param chunk - The chunk data to add to the buffer
+     * @returns The combined buffered chunk if flush conditions are met, null otherwise
+     *
+     * @example Progressive buffering
+     * ```typescript
+     * const buffer = new ChunkBuffer({ minThreshold: 1024 * 1024 }); // 1MB
+     *
+     * // First chunk doesn't meet threshold
+     * const result1 = buffer.add(new Uint8Array(512 * 1024)); // 512KB
+     * console.log(result1); // null
+     *
+     * // Second chunk triggers flush
+     * const result2 = buffer.add(new Uint8Array(512 * 1024)); // 512KB
+     * console.log(result2?.size); // 1048576 (1MB total)
+     * ```
+     */
+    add(chunk) {
+        this.buffer.push(chunk);
+        this.currentSize += chunk.length;
+        this.lastAddTime = Date.now();
+        if (this.shouldFlush()) {
+            return this.flush();
+        }
+        return null;
+    }
+    /**
+     * Forces the buffer to flush immediately, returning all accumulated data.
+     *
+     * This is typically called at the end of an upload to ensure any remaining
+     * buffered data is sent, even if it hasn't reached the minimum threshold.
+     *
+     * @returns The combined buffered chunk, or null if the buffer is empty
+     *
+     * @example Flushing at upload completion
+     * ```typescript
+     * const buffer = new ChunkBuffer({ minThreshold: 5 * 1024 * 1024 });
+     *
+     * // Upload file in chunks
+     * for (const chunk of fileChunks) {
+     *   const buffered = buffer.add(chunk);
+     *   if (buffered) await uploadChunk(buffered);
+     * }
+     *
+     * // Upload any remaining data
+     * const final = buffer.flush();
+     * if (final) await uploadChunk(final);
+     * ```
+     */
+    flush() {
+        if (this.buffer.length === 0) {
+            return null;
+        }
+        const combined = new Uint8Array(this.currentSize);
+        let offset = 0;
+        for (const chunk of this.buffer) {
+            combined.set(chunk, offset);
+            offset += chunk.length;
+        }
+        const result = {
+            data: combined,
+            size: this.currentSize,
+            timestamp: this.lastAddTime,
+        };
+        this.reset();
+        return result;
+    }
+    /**
+     * Checks if the buffer should be flushed based on size, max buffer, or timeout conditions.
+     *
+     * Returns true if any of these conditions are met:
+     * - Current size >= minThreshold
+     * - Current size >= maxBufferSize
+     * - Time since last add > timeoutMs
+     *
+     * @returns True if the buffer should be flushed
+     *
+     * @example Manual flush control
+     * ```typescript
+     * const buffer = new ChunkBuffer({ minThreshold: 1024 * 1024 });
+     *
+     * buffer.add(smallChunk);
+     *
+     * if (buffer.shouldFlush()) {
+     *   const data = buffer.flush();
+     *   await upload(data);
+     * }
+     * ```
+     */
+    shouldFlush() {
+        if (this.currentSize >= this.config.minThreshold) {
+            return true;
+        }
+        if (this.currentSize >= this.config.maxBufferSize) {
+            return true;
+        }
+        const timeSinceLastAdd = Date.now() - this.lastAddTime;
+        if (this.buffer.length > 0 && timeSinceLastAdd > this.config.timeoutMs) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Returns the current buffer state without flushing.
+     *
+     * Useful for monitoring buffer status and making informed decisions
+     * about when to manually flush or adjust upload strategies.
+     *
+     * @returns Object containing buffer metrics
+     *
+     * @example Monitoring buffer state
+     * ```typescript
+     * const buffer = new ChunkBuffer({ minThreshold: 1024 * 1024 });
+     * buffer.add(chunk);
+     *
+     * const info = buffer.getBufferInfo();
+     * console.log(`Buffered: ${info.size} bytes in ${info.chunkCount} chunks`);
+     * console.log(`Ready to flush: ${info.isReadyToFlush}`);
+     * console.log(`Time since last add: ${info.timeSinceLastAdd}ms`);
+     * ```
+     */
+    getBufferInfo() {
+        return {
+            size: this.currentSize,
+            chunkCount: this.buffer.length,
+            isReadyToFlush: this.shouldFlush(),
+            timeSinceLastAdd: Date.now() - this.lastAddTime,
+        };
+    }
+    /**
+     * Checks if the buffer has any pending data that hasn't been flushed.
+     *
+     * Useful for determining if a final flush is needed at upload completion.
+     *
+     * @returns True if there are chunks waiting in the buffer
+     *
+     * @example Ensuring complete upload
+     * ```typescript
+     * // Upload all chunks
+     * for (const chunk of chunks) {
+     *   const buffered = buffer.add(chunk);
+     *   if (buffered) await upload(buffered);
+     * }
+     *
+     * // Don't forget the last partial chunk!
+     * if (buffer.hasPendingData()) {
+     *   await upload(buffer.flush());
+     * }
+     * ```
+     */
+    hasPendingData() {
+        return this.buffer.length > 0;
+    }
+    /**
+     * Clears the buffer without returning data.
+     *
+     * This discards all buffered chunks and resets the buffer state.
+     * Use with caution as this will lose any pending data.
+     */
+    reset() {
+        this.buffer = [];
+        this.currentSize = 0;
+        this.lastAddTime = 0;
+    }
+    /**
+     * Returns the minimum threshold this buffer is configured for.
+     *
+     * @returns Minimum chunk size in bytes before flushing
+     */
+    getMinThreshold() {
+        return this.config.minThreshold;
+    }
+}

package/dist/client/create-uploadista-client.d.ts

@@ -0,0 +1,369 @@
+import type { DataStoreCapabilities } from "@uploadista/core/types";
+import type { AuthConfig } from "../auth";
+import type { Logger } from "../logger";
+import { type NetworkMonitorConfig } from "../network-monitor";
+import type { AbortControllerFactory } from "../services/abort-controller-service";
+import type { ChecksumService } from "../services/checksum-service";
+import type { FileReaderService } from "../services/file-reader-service";
+import type { FingerprintService } from "../services/fingerprint-service";
+import type { ConnectionPoolConfig, HttpClient } from "../services/http-client";
+import type { IdGenerationService } from "../services/id-generation-service";
+import type { PlatformService } from "../services/platform-service";
+import type { WebSocketFactory, WebSocketLike } from "../services/websocket-service";
+import { type SmartChunkerConfig } from "../smart-chunker";
+import type { ClientStorage } from "../storage/client-storage";
+import type { FlowUploadConfig } from "../types/flow-upload-config";
+import { type Callbacks } from "../upload/single-upload";
+import { abort } from "../upload/upload-manager";
+import { type UploadMetricsConfig } from "../upload/upload-metrics";
+import { type UploadStrategyConfig } from "../upload/upload-strategy";
+import { type UploadistaWebSocketEventHandler } from "./uploadista-websocket-manager";
+/**
+ * Options for individual upload operations.
+ *
+ * Extends the base upload callbacks with configuration for deferred length,
+ * size overrides, metadata, and checksum computation.
+ */
+export type UploadistaUploadOptions = {
+    /**
+     * Whether to defer specifying the upload size until later.
+     * Useful for streaming uploads where size isn't known upfront.
+     * Defaults to false.
+     */
+    uploadLengthDeferred?: boolean;
+    /**
+     * Manual override for upload size in bytes.
+     * If not provided, size is determined from the file/blob.
+     */
+    uploadSize?: number;
+    /**
+     * Custom metadata to attach to the upload.
+     * Stored as key-value pairs on the server.
+     */
+    metadata?: Record<string, string>;
+    /**
+     * Whether to compute checksums for uploaded chunks.
+     * Enables integrity verification but adds computational overhead.
+     * Defaults to false.
+     */
+    computeChecksum?: boolean;
+    /**
+     * Checksum algorithm to use (e.g., "sha256", "md5").
+     * Only relevant if computeChecksum is true.
+     */
+    checksumAlgorithm?: string;
+} & Callbacks;
+/**
+ * Configuration options for creating an Uploadista client.
+ *
+ * This comprehensive configuration object allows customization of all aspects
+ * of upload behavior including chunking, retries, authentication, storage,
+ * network monitoring, and platform-specific services.
+ *
+ * @template UploadInput - The platform-specific file/blob type (e.g., File, Blob, Buffer)
+ */
+export type UploadistaClientOptions<UploadInput> = {
+    /** Base URL of the Uploadista server (e.g., "https://upload.example.com") */
+    baseUrl: string;
+    /** Base path for Uploadista endpoints. Defaults to "uploadista" */
+    uploadistaBasePath?: string;
+    /** Storage backend identifier configured on the server */
+    storageId: string;
+    /** Retry delay intervals in milliseconds. Defaults to [1000, 3000, 5000] */
+    retryDelays?: number[];
+    /** Default chunk size in bytes for uploads */
+    chunkSize: number;
+    /** Number of parallel upload streams. Defaults to 1 (sequential) */
+    parallelUploads?: number;
+    /** Chunk size for parallel uploads. Required if parallelUploads > 1 */
+    parallelChunkSize?: number;
+    /** Service for computing checksums of uploaded chunks */
+    checksumService: ChecksumService;
+    /** Strategy configuration for determining upload approach (single/parallel/chunked) */
+    uploadStrategy?: UploadStrategyConfig;
+    /** Smart chunking configuration for adaptive chunk sizes based on network conditions */
+    smartChunking?: SmartChunkerConfig;
+    /** Network monitoring configuration for tracking upload performance */
+    networkMonitoring?: NetworkMonitorConfig;
+    /** Upload metrics configuration for performance insights */
+    uploadMetrics?: UploadMetricsConfig;
+    /** HTTP client with connection pooling support */
+    httpClient: HttpClient;
+    /** Service for generating unique IDs */
+    generateId: IdGenerationService;
+    /** Client-side storage for upload resumption data */
+    clientStorage: ClientStorage;
+    /** Platform-specific file reading service */
+    fileReader: FileReaderService<UploadInput>;
+    /** Logger for debugging and monitoring */
+    logger: Logger;
+    /** Service for computing file fingerprints for resumption */
+    fingerprintService: FingerprintService<UploadInput>;
+    /** Whether to store fingerprints for upload resumption. Defaults to true */
+    storeFingerprintForResuming: boolean;
+    /** Factory for creating WebSocket connections */
+    webSocketFactory: WebSocketFactory;
+    /** Factory for creating abort controllers */
+    abortControllerFactory: AbortControllerFactory;
+    /** Platform-specific service for timers and async operations */
+    platformService: PlatformService;
+    /** Global error handler for all upload operations */
+    onError?: (error: Error) => void;
+    /** WebSocket event handler for real-time upload/flow events */
+    onEvent?: UploadistaWebSocketEventHandler;
+    /**
+     * Optional authentication configuration.
+     * Supports two modes:
+     * - Direct: Bring your own auth (headers, cookies, custom tokens)
+     * - SaaS: Standard JWT token exchange with auth server
+     *
+     * If omitted, client operates in no-auth mode (backward compatible).
+     *
+     * @example Direct mode with Bearer token
+     * ```typescript
+     * auth: {
+     *   mode: 'direct',
+     *   getCredentials: () => ({
+     *     headers: { 'Authorization': 'Bearer token123' }
+     *   })
+     * }
+     * ```
+     *
+     * @example SaaS mode with auth server
+     * ```typescript
+     * auth: {
+     *   mode: 'saas',
+     *   authServerUrl: 'https://auth.myapp.com/token',
+     *   getCredentials: () => ({ username: 'user', password: 'pass' })
+     * }
+     * ```
+     */
+    auth?: AuthConfig;
+};
+/**
+ * Default connection pooling configuration with health monitoring.
+ *
+ * Optimized for typical upload scenarios with support for HTTP/2 multiplexing,
+ * connection reuse, and automatic retry on connection errors.
+ */
+export declare const defaultConnectionPoolingConfig: ConnectionPoolConfig;
+/**
+ * Creates a unified Uploadista client for file uploads and flow processing.
+ *
+ * This is the primary factory function for creating an Uploadista client instance.
+ * It configures all upload capabilities including:
+ * - Resumable chunked uploads with automatic retry
+ * - Parallel upload streams for large files
+ * - Smart chunking based on network conditions
+ * - Flow-based file processing pipelines
+ * - WebSocket support for real-time progress
+ * - Authentication (direct, SaaS, or no-auth modes)
+ *
+ * The client automatically:
+ * - Fetches server capabilities and adapts upload strategy
+ * - Monitors network performance for optimal chunking
+ * - Stores upload state for resumption across sessions
+ * - Manages WebSocket connections for progress tracking
+ *
+ * @template UploadInput - Platform-specific file type (File, Blob, Buffer, etc.)
+ * @param options - Comprehensive client configuration
+ * @returns Uploadista client instance with upload and flow methods
+ *
+ * @example Basic browser setup
+ * ```typescript
+ * import { createUploadistaClient } from '@uploadista/client-core';
+ * import { browserServices } from '@uploadista/client-browser';
+ *
+ * const client = createUploadistaClient({
+ *   baseUrl: 'https://upload.example.com',
+ *   storageId: 'my-storage',
+ *   chunkSize: 5 * 1024 * 1024, // 5MB chunks
+ *   ...browserServices,
+ * });
+ *
+ * // Upload a file
+ * const { abort } = await client.upload(file, {
+ *   onProgress: (progress) => console.log(`${progress}% complete`),
+ *   onSuccess: (result) => console.log('Upload complete:', result),
+ * });
+ * ```
+ *
+ * @example Upload with flow processing
+ * ```typescript
+ * const client = createUploadistaClient(config);
+ *
+ * // Upload and process through a flow
+ * const { abort, jobId } = await client.uploadWithFlow(file, {
+ *   flowId: 'image-optimization-flow',
+ *   storageId: 'images',
+ *   outputNodeId: 'optimized-output',
+ * }, {
+ *   onProgress: (progress) => console.log(`${progress}%`),
+ *   onSuccess: (result) => console.log('Processed:', result),
+ * });
+ *
+ * // Monitor job status
+ * const status = await client.getJobStatus(jobId);
+ * ```
+ *
+ * @example Parallel uploads for large files
+ * ```typescript
+ * const client = createUploadistaClient({
+ *   baseUrl: 'https://upload.example.com',
+ *   storageId: 'large-files',
+ *   chunkSize: 10 * 1024 * 1024, // 10MB
+ *   parallelUploads: 4, // 4 concurrent streams
+ *   parallelChunkSize: 5 * 1024 * 1024, // 5MB per stream
+ *   ...browserServices,
+ * });
+ *
+ * await client.upload(largeFile);
+ * ```
+ *
+ * @example With authentication
+ * ```typescript
+ * const client = createUploadistaClient({
+ *   baseUrl: 'https://upload.example.com',
+ *   storageId: 'protected',
+ *   chunkSize: 5 * 1024 * 1024,
+ *   auth: {
+ *     mode: 'direct',
+ *     getCredentials: async () => ({
+ *       headers: {
+ *         'Authorization': `Bearer ${await getToken()}`,
+ *       },
+ *     }),
+ *   },
+ *   ...browserServices,
+ * });
+ * ```
+ *
+ * @example Smart chunking with network monitoring
+ * ```typescript
+ * const client = createUploadistaClient({
+ *   baseUrl: 'https://upload.example.com',
+ *   storageId: 'adaptive',
+ *   chunkSize: 1 * 1024 * 1024, // Fallback: 1MB
+ *   smartChunking: {
+ *     enabled: true,
+ *     minChunkSize: 256 * 1024, // 256KB min
+ *     maxChunkSize: 10 * 1024 * 1024, // 10MB max
+ *   },
+ *   networkMonitoring: {
+ *     slowThreshold: 50 * 1024, // 50 KB/s
+ *     fastThreshold: 5 * 1024 * 1024, // 5 MB/s
+ *   },
+ *   ...browserServices,
+ * });
+ *
+ * // Monitor network conditions
+ * const condition = client.getNetworkCondition();
+ * console.log(`Network: ${condition.type} (confidence: ${condition.confidence})`);
+ * ```
+ *
+ * @see {@link UploadistaClientOptions} for full configuration options
+ * @see {@link UploadistaUploadOptions} for per-upload options
+ */
+export declare function createUploadistaClient<UploadInput>({ baseUrl: _baseUrl, uploadistaBasePath, storageId, retryDelays, chunkSize, parallelUploads, parallelChunkSize, uploadStrategy, smartChunking, networkMonitoring, uploadMetrics, checksumService, onEvent, generateId, httpClient, logger, fileReader, fingerprintService, clientStorage, storeFingerprintForResuming, webSocketFactory, abortControllerFactory, platformService, auth, }: UploadistaClientOptions<UploadInput>): {
+    upload: (file: UploadInput, { uploadLengthDeferred, uploadSize, onProgress, onChunkComplete, onSuccess, onShouldRetry, onError, }?: UploadistaUploadOptions) => Promise<{
+        abort: () => void;
+    }>;
+    uploadWithFlow: (file: UploadInput, flowConfig: FlowUploadConfig, { onProgress, onChunkComplete, onSuccess, onShouldRetry, onJobStart, onError, }?: Omit<UploadistaUploadOptions, "uploadLengthDeferred" | "uploadSize" | "metadata">) => Promise<{
+        abort: () => void;
+        jobId: string;
+    }>;
+    abort: (params: Parameters<typeof abort>[0]) => Promise<void>;
+    getFlow: (flowId: string) => Promise<{
+        status: number;
+        flow: import("@uploadista/core").FlowData;
+    }>;
+    runFlow: ({ flowId, inputs, storageId: flowStorageId, }: {
+        flowId: string;
+        inputs: Record<string, unknown>;
+        storageId?: string;
+    }) => Promise<{
+        status: number;
+        job: import("@uploadista/core").FlowJob;
+    }>;
+    continueFlow: ({ jobId, nodeId, newData, contentType, }: {
+        jobId: string;
+        nodeId: string;
+        newData: unknown;
+        contentType?: "application/json" | "application/octet-stream";
+    }) => Promise<import("@uploadista/core").FlowJob>;
+    getJobStatus: (jobId: string) => Promise<import("@uploadista/core").FlowJob>;
+    openUploadWebSocket: (uploadId: string) => Promise<WebSocketLike>;
+    openFlowWebSocket: (jobId: string) => Promise<WebSocketLike>;
+    openWebSocket: (id: string) => Promise<WebSocketLike>;
+    closeWebSocket: (id: string) => void;
+    closeAllWebSockets: () => void;
+    sendPing: (jobId: string) => boolean;
+    isWebSocketConnected: (id: string) => boolean;
+    getWebSocketConnectionCount: () => number;
+    getWebSocketConnectionCountByType: () => {
+        upload: number;
+        flow: number;
+        total: number;
+    };
+    getNetworkMetrics: () => import("..").NetworkMetrics;
+    getNetworkCondition: () => import("..").NetworkCondition;
+    getChunkingInsights: () => import("..").PerformanceInsights;
+    exportMetrics: () => {
+        session: Partial<import("..").UploadSessionMetrics>;
+        chunks: import("..").ChunkMetrics[];
+        insights: import("..").PerformanceInsights;
+    };
+    getConnectionMetrics: () => import("..").ConnectionMetrics;
+    getDetailedConnectionMetrics: () => import("..").DetailedConnectionMetrics;
+    warmupConnections: (urls: string[]) => Promise<void>;
+    getConnectionPoolingInsights: () => Promise<{
+        isOptimized: boolean;
+        reuseRate: number;
+        recommendedMinChunkSize: number;
+        connectionOverhead: number;
+    }>;
+    resetMetrics: () => Promise<void>;
+    validateConfiguration: (options: UploadistaClientOptions<UploadInput>) => {
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+    };
+    validateConfigurationAsync: (options: UploadistaClientOptions<UploadInput>) => Promise<{
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+        capabilities: DataStoreCapabilities;
+    }>;
+    getCapabilities: () => Promise<DataStoreCapabilities>;
+};
+/**
+ * Uploadista client instance type.
+ *
+ * The client provides methods for:
+ * - **Upload operations**: upload(), uploadWithFlow()
+ * - **Flow operations**: getFlow(), runFlow(), continueFlow()
+ * - **Job management**: getJobStatus()
+ * - **WebSocket management**: openUploadWebSocket(), openFlowWebSocket(), closeWebSocket()
+ * - **Metrics and diagnostics**: getNetworkMetrics(), getChunkingInsights(), exportMetrics()
+ * - **Connection pooling**: getConnectionMetrics(), warmupConnections()
+ * - **Configuration validation**: validateConfiguration(), validateConfigurationAsync()
+ *
+ * @example Basic usage
+ * ```typescript
+ * const client = createUploadistaClient(config);
+ *
+ * // Upload a file
+ * await client.upload(file, {
+ *   onProgress: (progress) => console.log(`${progress}%`),
+ *   onSuccess: (result) => console.log('Done:', result.id),
+ * });
+ *
+ * // Get network metrics
+ * const metrics = client.getNetworkMetrics();
+ * console.log(`Speed: ${metrics.averageSpeed / 1024} KB/s`);
+ * ```
+ *
+ * @see {@link createUploadistaClient} for creating an instance
+ */
+export type UploadistaClient = ReturnType<typeof createUploadistaClient>;
+//# sourceMappingURL=create-uploadista-client.d.ts.map

package/dist/client/create-uploadista-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-uploadista-client.d.ts","sourceRoot":"","sources":["../../src/client/create-uploadista-client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AACpE,OAAO,KAAK,EAAE,UAAU,EAAe,MAAM,SAAS,CAAC;AAEvD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGxC,OAAO,EAAkB,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC/E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,KAAK,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAChF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,KAAK,EAAE,eAAe,EAAW,MAAM,8BAA8B,CAAC;AAC7E,OAAO,KAAK,EACV,gBAAgB,EAChB,aAAa,EACd,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAgB,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAIpE,OAAO,EACL,KAAK,SAAS,EAGf,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,KAAK,EAAa,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,0BAA0B,CAAC;AAKlC,OAAO,EAEL,KAAK,oBAAoB,EAG1B,MAAM,2BAA2B,CAAC;AAGnC,OAAO,EACL,KAAK,+BAA+B,EAErC,MAAM,gCAAgC,CAAC;AAExC;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACpC;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAE/B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAElC;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,GAAG,SAAS,CAAC;AAEd;;;;;;;;GAQG;AACH,MAAM,MAAM,uBAAuB,CAAC,WAAW,IAAI;IACjD,6EAA6E;IAC7E,OAAO,EAAE,MAAM,CAAC;IAEhB,mEAAmE;IACnE,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE5B,0DAA0D;IAC1D,SAAS,EAAE,MAAM,CAAC;IAElB,4EAA4E;IAC5E,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IAEvB,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;IAElB,oEAAoE;IACpE,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,uEAAuE;IACvE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B,yDAAyD;IACzD,eAAe,EAAE,eAAe,CAAC;IAEjC,uFAAuF;IACvF,cAAc,CAAC,EAAE,oBAAoB,CAAC;IAEtC,wFAAwF;IACxF,aAAa,CAAC,EAAE,kBAAkB,CAAC;IAEnC,uEAAuE;IACvE,iBAAiB,CAAC,EAAE,oBAAoB,CAAC;IAEzC,4DAA4D;IAC5D,aAAa,CAAC,EAAE,mBAAmB,CAAC;IAEpC,kDAAkD;IAClD,UAAU,EAAE,UAAU,CAAC;IAEvB,wCAAwC;IACxC,UAAU,EAAE,mBAAmB,CAAC;IAEhC,qDAAqD;IACrD,aAAa,EAAE,aAAa,CAAC;IAE7B,6CAA6C;IAC7C,UAAU,EAAE,iBAAiB,CAAC,WAAW,CAAC,CAAC;IAE3C,0CAA0C;IAC1C,MAAM,EAAE,MAAM,CAAC;IAEf,6DAA6D;IAC7D,kBAAkB,EAAE,kBAAkB,CAAC,WAAW,CAAC,CAAC;IAEpD,4EAA4E;IAC5E,2BAA2B,EAAE,OAAO,CAAC;IAErC,iDAAiD;IACjD,gBAAgB,EAAE,gBAAgB,CAAC;IAEnC,6CAA6C;IAC7C,sBAAsB,EAAE,sBAAsB,CAAC;IAE/C,gEAAgE;IAChE,eAAe,EAAE,eAAe,CAAC;IAEjC,qDAAqD;IACrD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAEjC,+DAA+D;IAC/D,OAAO,CAAC,EAAE,+BAA+B,CAAC;IAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,EAAE,oBAW5C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoHG;AACH,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,EAClD,OAAO,EAAE,QAAQ,EACjB,kBAAiC,EACjC,SAAS,EACT,WAAgC,EAChC,SAAS,EACT,eAAmB,EACnB,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,OAAO,EACP,UAAU,EACV,UAAU,EACV,MAA2B,EAC3B,UAAU,EACV,kBAAkB,EAClB,aAAa,EACb,2BAAkC,EAClC,gBAAgB,EAChB,sBAAsB,EACtB,eAAe,EACf,IAAI,GACL,EAAE,uBAAuB,CAAC,WAAW,CAAC;mBAoF7B,WAAW,0GASd,uBAAuB,KACzB,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,IAAI,CAAA;KAAE,CAAC;2BAqMzB,WAAW,cACL,gBAAgB,oFAQzB,IAAI,CACL,uBAAuB,EACvB,sBAAsB,GAAG,YAAY,GAAG,UAAU,CACnD,KACA,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,IAAI,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;oBAsF9B,UAAU,CAAC,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;sBAGnB,MAAM;;;;6DAS3B;QACD,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAChC,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB;;;;6DAcE;QACD,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,OAAO,CAAC;QACjB,WAAW,CAAC,EAAE,kBAAkB,GAAG,0BAA0B,CAAC;KAC/D;0BAO2B,MAAM;oCAKF,MAAM;+BAEX,MAAM;wBACb,MAAM;yBACL,MAAM;;sBAET,MAAM;+BACG,MAAM;;;;;;;;;;;;;;;;;8BAeP,MAAM,EAAE;;;;;;;;qCAiBD,uBAAuB,CAAC,WAAW,CAAC;;;;;0CAK1D,uBAAuB,CAAC,WAAW,CAAC;;;;;;2BAjcf,OAAO,CAAC,qBAAqB,CAAC;EAydjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC"}