@uploadista/client-browser 0.0.3

package/SMART_CHUNKING.md

@@ -0,0 +1,140 @@
+# Smart Chunking Feature
+
+The smart chunking feature provides adaptive chunk size optimization for file uploads based on network conditions and performance metrics.
+
+## Overview
+
+Instead of using fixed chunk sizes, smart chunking dynamically adjusts chunk sizes based on:
+- Network speed and latency
+- Upload success rates
+- Bandwidth utilization
+- Connection stability
+
+## Configuration
+
+Smart chunking works out of the box without any configuration:
+
+```typescript
+// Smart chunking is enabled by default
+const client = createUploadClient({
+  baseUrl: 'https://your-api.com',
+  storageId: 'your-storage-id',
+  chunkSize: 1024 * 1024, // Fallback size if smart chunking needs to be disabled
+});
+```
+
+For advanced configuration, you can customize the behavior:
+
+```typescript
+import { createUploadClient } from '@uploadista/client/create-upload-client';
+
+const client = createUploadClient({
+  baseUrl: 'https://your-api.com',
+  storageId: 'your-storage-id',
+  chunkSize: 1024 * 1024, // Fallback chunk size (1MB)
+  smartChunking: {
+    enabled: true, // Enable smart chunking (enabled by default)
+    minChunkSize: 64 * 1024, // 64KB minimum
+    maxChunkSize: 32 * 1024 * 1024, // 32MB maximum
+    initialChunkSize: 512 * 1024, // 512KB initial size
+    targetUtilization: 0.85, // Target 85% bandwidth utilization
+    conservativeMode: false, // Use aggressive chunking when possible
+  },
+  networkMonitoring: {
+    maxSamples: 100, // Keep last 100 upload samples
+    slowThreshold: 50 * 1024, // 50 KB/s considered slow
+    fastThreshold: 5 * 1024 * 1024, // 5 MB/s considered fast
+  },
+  uploadMetrics: {
+    enableDetailedMetrics: true, // Track detailed performance data
+  },
+});
+```
+
+## Network Conditions
+
+The system automatically detects and adapts to different network conditions:
+
+### Slow Networks
+- **Threshold**: < 50 KB/s average speed
+- **Strategy**: Conservative chunking with smaller, more reliable chunks
+- **Chunk Range**: 64KB - 2MB
+
+### Fast Networks  
+- **Threshold**: > 5 MB/s average speed
+- **Strategy**: Aggressive chunking with larger chunks for efficiency
+- **Chunk Range**: 256KB - 32MB
+
+### Unstable Networks
+- **Detection**: High variability in upload speeds (coefficient of variation > 50%)
+- **Strategy**: Conservative chunking with quick recovery on failures
+- **Chunk Range**: 64KB - 2MB
+
+## Adaptive Behavior
+
+### Success-Based Adaptation
+- **Consecutive Successes**: Gradually increase chunk size to improve efficiency
+- **Consecutive Failures**: Immediately reduce chunk size for reliability
+
+### Throughput Optimization
+- **Target Duration**: Aims for 2-5 seconds per chunk based on network condition
+- **Bandwidth Utilization**: Targets 85% bandwidth usage for optimal performance
+- **Real-time Adjustment**: Adapts chunk size based on actual vs. expected throughput
+
+## Performance Monitoring
+
+Access performance insights and metrics:
+
+```typescript
+// Get current network metrics
+const networkMetrics = client.getNetworkMetrics();
+console.log(`Average speed: ${networkMetrics.averageSpeed / 1024} KB/s`);
+console.log(`Success rate: ${networkMetrics.successRate * 100}%`);
+
+// Get network condition assessment
+const condition = client.getNetworkCondition();
+console.log(`Network type: ${condition.type}, confidence: ${condition.confidence}`);
+
+// Get performance insights and recommendations
+const insights = client.getChunkingInsights();
+console.log('Recommendations:', insights.recommendations);
+console.log('Optimal chunk size range:', insights.optimalChunkSizeRange);
+
+// Export detailed metrics for analysis
+const metrics = client.exportMetrics();
+```
+
+## Backwards Compatibility
+
+Smart chunking is fully backwards compatible:
+
+- **Default Behavior**: Smart chunking is enabled by default with sensible defaults
+- **Disable Option**: Set `smartChunking.enabled: false` to use fixed chunking
+- **Fallback Support**: If smart chunking fails, automatically falls back to the configured `chunkSize`
+- **No Config Required**: Works out of the box without any configuration
+
+## Benefits
+
+1. **Improved Performance**: Optimizes chunk sizes for network conditions
+2. **Better Reliability**: Reduces failures on unstable connections  
+3. **Bandwidth Efficiency**: Maximizes upload throughput while maintaining stability
+4. **Adaptive Recovery**: Quickly adjusts to changing network conditions
+5. **Detailed Analytics**: Provides insights for performance optimization
+
+## Algorithm Details
+
+### Chunk Size Calculation
+```
+targetSize = currentSize * (1 - adaptationRate) + theoreticalOptimalSize * adaptationRate
+finalSize = clamp(targetSize, minChunkSize, maxChunkSize)
+```
+
+### Network Condition Detection
+- **Speed Classification**: Based on average throughput over recent samples
+- **Stability Assessment**: Using coefficient of variation of upload speeds
+- **Confidence Scoring**: Based on sample size and consistency
+
+### Performance Metrics
+- **Efficiency Score**: Combination of speed and success rate
+- **Chunking Effectiveness**: How well chunk sizes correlate with performance
+- **Network Stability**: Inverse of upload speed variability

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

@@ -0,0 +1,182 @@
+import { type ConnectionPoolConfig, type UploadistaClientOptions as UploadistaClientOptionsCore } from "@uploadista/client-core";
+import type { BrowserUploadInput } from "../types/upload-input";
+/**
+ * Configuration options for creating a browser-specific Uploadista client.
+ *
+ * This interface extends the core client options but omits browser-specific
+ * services that are automatically provided by the browser environment.
+ * These services include WebSocket factory, AbortController, ID generation,
+ * storage, logging, platform detection, fingerprinting, HTTP client, file reader,
+ * and checksum calculation.
+ *
+ * @example
+ * ```typescript
+ * import { createUploadistaClient } from '@uploadista/client-browser';
+ *
+ * const client = createUploadistaClient({
+ *   endpoint: 'https://api.uploadista.com/upload',
+ *   connectionPooling: {
+ *     maxConnectionsPerHost: 6,
+ *     enableHttp2: true
+ *   }
+ * });
+ * ```
+ */
+export interface UploadistaClientOptions extends Omit<UploadistaClientOptionsCore<BrowserUploadInput>, "webSocketFactory" | "abortControllerFactory" | "generateId" | "clientStorage" | "logger" | "platformService" | "fingerprintService" | "httpClient" | "fileReader" | "checksumService"> {
+    /**
+     * Connection pooling configuration for the HTTP client.
+     *
+     * Controls how the browser manages HTTP connections for optimal performance.
+     * The browser's native fetch API with keep-alive headers is used under the hood.
+     *
+     * @default
+     * ```typescript
+     * {
+     *   maxConnectionsPerHost: 6,
+     *   connectionTimeout: 30000,
+     *   keepAliveTimeout: 60000,
+     *   enableHttp2: true,
+     *   retryOnConnectionError: true
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * connectionPooling: {
+     *   maxConnectionsPerHost: 10,
+     *   enableHttp2: true,
+     *   keepAliveTimeout: 120000
+     * }
+     * ```
+     */
+    connectionPooling?: ConnectionPoolConfig;
+}
+/**
+ * Creates a browser-optimized Uploadista client for file uploads and flow processing.
+ *
+ * This factory function automatically configures all browser-specific services including:
+ * - Fetch-based HTTP client with connection pooling
+ * - Native WebSocket support for real-time progress
+ * - localStorage for upload state persistence
+ * - Web Crypto API for checksums and fingerprints
+ * - File API for reading and chunking files
+ * - Browser platform detection and capabilities
+ *
+ * The created client can handle File and Blob objects from file inputs, drag-and-drop,
+ * or programmatically created content. It supports resumable uploads, progress tracking,
+ * and flow-based file processing.
+ *
+ * @param options - Configuration options for the browser client
+ * @returns A fully configured Uploadista client ready for browser use
+ *
+ * @example
+ * ```typescript
+ * import { createUploadistaClient } from '@uploadista/client-browser';
+ *
+ * // Basic usage
+ * const client = createUploadistaClient({
+ *   endpoint: 'https://api.uploadista.com/upload'
+ * });
+ *
+ * // With custom configuration
+ * const client = createUploadistaClient({
+ *   endpoint: 'https://api.uploadista.com/upload',
+ *   connectionPooling: {
+ *     maxConnectionsPerHost: 6,
+ *     enableHttp2: true,
+ *     keepAliveTimeout: 60000
+ *   },
+ *   chunkSize: 5 * 1024 * 1024, // 5MB chunks
+ *   retryDelays: [1000, 3000, 5000],
+ *   allowedMetaFields: ['userId', 'projectId']
+ * });
+ *
+ * // Upload a file
+ * const fileInput = document.querySelector('input[type="file"]');
+ * const file = fileInput.files[0];
+ *
+ * const upload = await client.upload(file, {
+ *   onProgress: (event) => {
+ *     console.log(`Progress: ${event.progress}%`);
+ *   }
+ * });
+ *
+ * console.log('Upload complete:', upload.id);
+ * ```
+ *
+ * @see {@link UploadistaClientOptions} for available configuration options
+ * @see {@link BrowserUploadInput} for supported file input types
+ */
+export declare function createUploadistaClient(options: UploadistaClientOptions): {
+    upload: (file: BrowserUploadInput, { uploadLengthDeferred, uploadSize, onProgress, onChunkComplete, onSuccess, onShouldRetry, onError, }?: import("@uploadista/client-core").UploadistaUploadOptions) => Promise<{
+        abort: () => void;
+    }>;
+    uploadWithFlow: (file: BrowserUploadInput, flowConfig: import("@uploadista/client-core").FlowUploadConfig, { onProgress, onChunkComplete, onSuccess, onShouldRetry, onJobStart, onError, }?: Omit<import("@uploadista/client-core").UploadistaUploadOptions, "uploadLengthDeferred" | "uploadSize" | "metadata">) => Promise<{
+        abort: () => void;
+        jobId: string;
+    }>;
+    abort: (params: Parameters<typeof import("node_modules/@uploadista/client-core/src/upload/upload-manager").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<import("@uploadista/client-core").WebSocketLike>;
+    openFlowWebSocket: (jobId: string) => Promise<import("@uploadista/client-core").WebSocketLike>;
+    openWebSocket: (id: string) => Promise<import("@uploadista/client-core").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("@uploadista/client-core").NetworkMetrics;
+    getNetworkCondition: () => import("@uploadista/client-core").NetworkCondition;
+    getChunkingInsights: () => import("@uploadista/client-core").PerformanceInsights;
+    exportMetrics: () => {
+        session: Partial<import("@uploadista/client-core").UploadSessionMetrics>;
+        chunks: import("@uploadista/client-core").ChunkMetrics[];
+        insights: import("@uploadista/client-core").PerformanceInsights;
+    };
+    getConnectionMetrics: () => import("@uploadista/client-core").ConnectionMetrics;
+    getDetailedConnectionMetrics: () => import("@uploadista/client-core").DetailedConnectionMetrics;
+    warmupConnections: (urls: string[]) => Promise<void>;
+    getConnectionPoolingInsights: () => Promise<{
+        isOptimized: boolean;
+        reuseRate: number;
+        recommendedMinChunkSize: number;
+        connectionOverhead: number;
+    }>;
+    resetMetrics: () => Promise<void>;
+    validateConfiguration: (options: UploadistaClientOptionsCore<BrowserUploadInput>) => {
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+    };
+    validateConfigurationAsync: (options: UploadistaClientOptionsCore<BrowserUploadInput>) => Promise<{
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+        capabilities: import("@uploadista/core").DataStoreCapabilities;
+    }>;
+    getCapabilities: () => Promise<import("@uploadista/core").DataStoreCapabilities>;
+};
+//# 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,EACL,KAAK,oBAAoB,EAIzB,KAAK,uBAAuB,IAAI,2BAA2B,EAC5D,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,uBACf,SAAQ,IAAI,CACV,2BAA2B,CAAC,kBAAkB,CAAC,EAC7C,kBAAkB,GAClB,wBAAwB,GACxB,YAAY,GACZ,eAAe,GACf,QAAQ,GACR,iBAAiB,GACjB,oBAAoB,GACpB,YAAY,GACZ,YAAY,GACZ,iBAAiB,CACpB;IACD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,iBAAiB,CAAC,EAAE,oBAAoB,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBtE"}

package/dist/client/create-uploadista-client.js

@@ -0,0 +1,76 @@
+import { createClientStorage, createLogger, createUploadistaClient as createUploadistaClientCore, } from "@uploadista/client-core";
+import { createBrowserServices } from "../services/create-browser-services";
+/**
+ * Creates a browser-optimized Uploadista client for file uploads and flow processing.
+ *
+ * This factory function automatically configures all browser-specific services including:
+ * - Fetch-based HTTP client with connection pooling
+ * - Native WebSocket support for real-time progress
+ * - localStorage for upload state persistence
+ * - Web Crypto API for checksums and fingerprints
+ * - File API for reading and chunking files
+ * - Browser platform detection and capabilities
+ *
+ * The created client can handle File and Blob objects from file inputs, drag-and-drop,
+ * or programmatically created content. It supports resumable uploads, progress tracking,
+ * and flow-based file processing.
+ *
+ * @param options - Configuration options for the browser client
+ * @returns A fully configured Uploadista client ready for browser use
+ *
+ * @example
+ * ```typescript
+ * import { createUploadistaClient } from '@uploadista/client-browser';
+ *
+ * // Basic usage
+ * const client = createUploadistaClient({
+ *   endpoint: 'https://api.uploadista.com/upload'
+ * });
+ *
+ * // With custom configuration
+ * const client = createUploadistaClient({
+ *   endpoint: 'https://api.uploadista.com/upload',
+ *   connectionPooling: {
+ *     maxConnectionsPerHost: 6,
+ *     enableHttp2: true,
+ *     keepAliveTimeout: 60000
+ *   },
+ *   chunkSize: 5 * 1024 * 1024, // 5MB chunks
+ *   retryDelays: [1000, 3000, 5000],
+ *   allowedMetaFields: ['userId', 'projectId']
+ * });
+ *
+ * // Upload a file
+ * const fileInput = document.querySelector('input[type="file"]');
+ * const file = fileInput.files[0];
+ *
+ * const upload = await client.upload(file, {
+ *   onProgress: (event) => {
+ *     console.log(`Progress: ${event.progress}%`);
+ *   }
+ * });
+ *
+ * console.log('Upload complete:', upload.id);
+ * ```
+ *
+ * @see {@link UploadistaClientOptions} for available configuration options
+ * @see {@link BrowserUploadInput} for supported file input types
+ */
+export function createUploadistaClient(options) {
+    const services = createBrowserServices({
+        connectionPooling: options.connectionPooling,
+    });
+    return createUploadistaClientCore({
+        ...options,
+        webSocketFactory: services.websocket,
+        abortControllerFactory: services.abortController,
+        platformService: services.platform,
+        httpClient: services.httpClient,
+        fileReader: services.fileReader,
+        generateId: services.idGeneration,
+        fingerprintService: services.fingerprintService,
+        checksumService: services.checksumService,
+        logger: createLogger(false, () => { }),
+        clientStorage: createClientStorage(services.storage),
+    });
+}

package/dist/client/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./create-uploadista-client";
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC"}

package/dist/client/index.js

@@ -0,0 +1 @@
+export * from "./create-uploadista-client";

package/dist/framework-utils.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Framework Integration Utilities
+ *
+ * This module provides TypeScript utilities and helper types for building
+ * framework-specific wrappers around the Uploadista client.
+ *
+ * @module framework-utils
+ */
+import type { FlowResult, UploadResult } from "@uploadista/client-core";
+import type { FlowEvent } from "@uploadista/core/flow";
+import type { UploadEvent, UploadFile } from "@uploadista/core/types";
+/**
+ * Base upload state that framework wrappers should implement
+ */
+export interface BaseUploadState {
+    status: "idle" | "uploading" | "success" | "error" | "aborted";
+    progress: number;
+    bytesUploaded: number;
+    totalBytes: number;
+    error?: Error;
+    result?: UploadResult<UploadFile>;
+}
+/**
+ * Base flow upload state
+ */
+export interface BaseFlowUploadState extends BaseUploadState {
+    jobId?: string;
+    flowStatus?: "pending" | "processing" | "completed" | "failed";
+    flowResult?: FlowResult<unknown>;
+}
+/**
+ * Progress callback signature
+ */
+export type ProgressCallback = (uploadId: string, bytesUploaded: number, totalBytes: number) => void;
+/**
+ * Complete callback signature
+ */
+export type CompleteCallback = (uploadId: string, result: UploadResult) => void;
+/**
+ * Error callback signature
+ */
+export type ErrorCallback = (uploadId: string, error: Error) => void;
+/**
+ * Abort callback signature
+ */
+export type AbortCallback = (uploadId: string) => void;
+/**
+ * Event handler signature for framework wrappers
+ */
+export type EventHandler<T = unknown> = (event: T) => void;
+/**
+ * WebSocket event handler signature
+ */
+export type WebSocketEventHandler = (event: UploadEvent | FlowEvent) => void;
+/**
+ * Framework state updater function signature
+ * @template T - The state type
+ */
+export type StateUpdater<T> = (updater: (prevState: T) => T) => void;
+/**
+ * Cleanup function returned by setup functions
+ */
+export type CleanupFunction = () => void;
+/**
+ * Upload item for multi-upload tracking
+ */
+export interface UploadItem {
+    id: string;
+    file: File;
+    status: BaseUploadState["status"];
+    progress: number;
+    bytesUploaded: number;
+    totalBytes: number;
+    error?: Error;
+    result?: UploadResult;
+}
+/**
+ * Multi-upload aggregate statistics
+ */
+export interface MultiUploadStats {
+    totalFiles: number;
+    completedFiles: number;
+    failedFiles: number;
+    totalBytes: number;
+    uploadedBytes: number;
+    totalProgress: number;
+    allComplete: boolean;
+    hasErrors: boolean;
+}
+/**
+ * Drag and drop state
+ */
+export interface DragDropState {
+    isDragging: boolean;
+    isOver: boolean;
+    files: File[];
+}
+/**
+ * File validation result
+ */
+export interface FileValidationResult {
+    valid: boolean;
+    error?: string;
+}
+/**
+ * File validation function signature
+ */
+export type FileValidator = (file: File) => FileValidationResult;
+/**
+ * Utility: Calculate aggregate upload statistics
+ */
+export declare function calculateMultiUploadStats(uploads: UploadItem[]): MultiUploadStats;
+/**
+ * Utility: Format file size for display
+ */
+export declare function formatFileSize(bytes: number): string;
+/**
+ * Utility: Format progress percentage
+ */
+export declare function formatProgress(progress: number): string;
+/**
+ * Utility: Get file extension
+ */
+export declare function getFileExtension(filename: string): string;
+/**
+ * Utility: Check if file is an image
+ */
+export declare function isImageFile(file: File): boolean;
+/**
+ * Utility: Check if file is a video
+ */
+export declare function isVideoFile(file: File): boolean;
+/**
+ * Utility: Create file size validator
+ */
+export declare function createFileSizeValidator(maxSizeBytes: number): FileValidator;
+/**
+ * Utility: Create file type validator
+ */
+export declare function createFileTypeValidator(allowedTypes: string[]): FileValidator;
+/**
+ * Utility: Compose multiple validators
+ */
+export declare function composeValidators(...validators: FileValidator[]): FileValidator;
+/**
+ * Utility: Generate unique upload ID
+ */
+export declare function generateUploadId(): string;
+/**
+ * Utility: Create delay promise for retry logic
+ */
+export declare function delay(ms: number): Promise<void>;
+/**
+ * Utility: Calculate exponential backoff delay
+ */
+export declare function calculateBackoff(attempt: number, baseDelay?: number, maxDelay?: number): number;
+/**
+ * Utility: Create retry wrapper for upload function
+ */
+export declare function createRetryWrapper<T>(fn: () => Promise<T>, maxAttempts?: number, shouldRetry?: (error: unknown) => boolean): () => Promise<T>;
+/**
+ * Type guard: Check if error is network-related (should retry)
+ */
+export declare function isNetworkError(error: unknown): boolean;
+/**
+ * Type guard: Check if error is abort-related (should not retry)
+ */
+export declare function isAbortError(error: unknown): boolean;
+/**
+ * Format upload speed in human-readable format
+ */
+export declare function formatSpeed(bytesPerSecond: number): string;
+/**
+ * Format duration in human-readable format
+ */
+export declare function formatDuration(milliseconds: number): string;
+/**
+ * Validate file type against accepted types
+ */
+export declare function validateFileType(file: File, accept: string[]): boolean;
+/**
+ * Check if a file is an audio file
+ */
+export declare function isAudioFile(file: File): boolean;
+/**
+ * Check if a file is a document
+ */
+export declare function isDocumentFile(file: File): boolean;
+/**
+ * Create a preview URL for a file (if supported)
+ */
+export declare function createFilePreview(file: File): string | null;
+/**
+ * Clean up a preview URL created with createFilePreview
+ */
+export declare function revokeFilePreview(previewUrl: string): void;
+/**
+ * Calculate progress percentage
+ */
+export declare function calculateProgress(current: number, total: number): number;
+//# sourceMappingURL=framework-utils.d.ts.map

package/dist/framework-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework-utils.d.ts","sourceRoot":"","sources":["../src/framework-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEtE;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;IAC/D,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,MAAM,CAAC,EAAE,YAAY,CAAC,UAAU,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,eAAe;IAC1D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,SAAS,GAAG,YAAY,GAAG,WAAW,GAAG,QAAQ,CAAC;IAC/D,UAAU,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAC7B,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,MAAM,KACf,IAAI,CAAC;AAEV;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;AAEhF;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;AAErE;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;AAEvD;;GAEG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,GAAG,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,KAAK,IAAI,CAAC;AAE7E;;;GAGG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;AAErE;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC;AAEzC;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,IAAI,CAAC;IACX,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,OAAO,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,IAAI,EAAE,IAAI,KAAK,oBAAoB,CAAC;AAEjE;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,UAAU,EAAE,GACpB,gBAAgB,CAoBlB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQpD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGzD;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAE/C;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAE/C;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,aAAa,CAU3E;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,aAAa,CAwB7E;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,UAAU,EAAE,aAAa,EAAE,GAC7B,aAAa,CAUf;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,SAAS,SAAO,EAChB,QAAQ,SAAQ,GACf,MAAM,CAIR;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,WAAW,SAAI,EACf,WAAW,GAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAoB,GACpD,MAAM,OAAO,CAAC,CAAC,CAAC,CAkBlB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAWtD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAKpD;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAM1D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAkB3D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAiBtE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAE/C;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAelD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAK3D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAE1D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAGxE"}