juxscript 1.1.159 → 1.1.161

package/lib/storage/FileStorage.ts

@@ -0,0 +1,95 @@
+import { State } from '../reactivity/state.js';
+import { IndexedDBDriver, StoredFile, FileQuery } from './IndexedDBDriver.js';
+
+/**
+ * Reactive file storage — wraps IndexedDBDriver with a State<StoredFile[]>
+ * so components can subscribe to file list changes.
+ */
+export class FileStorage {
+    private _driver: IndexedDBDriver;
+    private _state: State<StoredFile[]>;
+
+    constructor(dbName?: string, storeName?: string) {
+        this._driver = new IndexedDBDriver(dbName, storeName);
+        this._state = new State<StoredFile[]>([]);
+    }
+
+    /** Reactive state — subscribe to file list changes */
+    get state(): State<StoredFile[]> {
+        return this._state;
+    }
+
+    /** Current file list */
+    get files(): StoredFile[] {
+        return this._state.value;
+    }
+
+    /** The underlying driver for advanced operations */
+    get driver(): IndexedDBDriver {
+        return this._driver;
+    }
+
+    /**
+     * Load file list from IndexedDB and update state
+     */
+    async refresh(query?: FileQuery): Promise<StoredFile[]> {
+        const files = await this._driver.list(query);
+        this._state.set(files);
+        return files;
+    }
+
+    /**
+     * Store a file and update state
+     */
+    async store(file: File, metadata?: Record<string, any>): Promise<StoredFile> {
+        const stored = await this._driver.store(file, metadata);
+        await this.refresh();
+        return stored;
+    }
+
+    /**
+     * Store multiple files and update state
+     */
+    async storeAll(files: File[], metadata?: Record<string, any>): Promise<StoredFile[]> {
+        const stored = await this._driver.storeAll(files, metadata);
+        await this.refresh();
+        return stored;
+    }
+
+    /**
+     * Delete a file and update state
+     */
+    async delete(id: string): Promise<void> {
+        await this._driver.delete(id);
+        await this.refresh();
+    }
+
+    /**
+     * Clear all files and update state
+     */
+    async clear(): Promise<void> {
+        await this._driver.clear();
+        this._state.set([]);
+    }
+
+    /**
+     * Get a stored file by ID (does not affect state)
+     */
+    async get(id: string): Promise<StoredFile | null> {
+        return this._driver.get(id);
+    }
+
+    /**
+     * Get storage usage
+     */
+    async usage(): Promise<{ count: number; bytes: number }> {
+        return this._driver.usage();
+    }
+}
+
+/**
+ * Factory function
+ */
+export function fileStorage(dbName?: string, storeName?: string): FileStorage {
+    return new FileStorage(dbName, storeName);
+}

package/lib/storage/IndexedDBDriver.d.ts

@@ -0,0 +1,75 @@
+export interface StoredFile {
+    id: string;
+    name: string;
+    size: number;
+    type: string;
+    data: ArrayBuffer;
+    timestamp: number;
+    metadata?: Record<string, any>;
+}
+export interface FileQuery {
+    type?: string;
+    minSize?: number;
+    maxSize?: number;
+    since?: number;
+    limit?: number;
+}
+export declare class IndexedDBDriver {
+    private _dbName;
+    private _storeName;
+    private _version;
+    private _db;
+    constructor(dbName?: string, storeName?: string, version?: number);
+    /**
+     * Open the database connection
+     */
+    open(): Promise<IDBDatabase>;
+    /**
+     * Store a File object
+     */
+    store(file: File, metadata?: Record<string, any>): Promise<StoredFile>;
+    /**
+     * Store multiple files
+     */
+    storeAll(files: File[], metadata?: Record<string, any>): Promise<StoredFile[]>;
+    /**
+     * Retrieve a stored file by ID
+     */
+    get(id: string): Promise<StoredFile | null>;
+    /**
+     * Get all stored files (metadata only, no data by default)
+     */
+    list(query?: FileQuery): Promise<StoredFile[]>;
+    /**
+     * Delete a stored file by ID
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * Delete all stored files
+     */
+    clear(): Promise<void>;
+    /**
+     * Get total storage usage in bytes
+     */
+    usage(): Promise<{
+        count: number;
+        bytes: number;
+    }>;
+    /**
+     * Convert a StoredFile back to a File object
+     */
+    toFile(stored: StoredFile): File;
+    /**
+     * Convert a StoredFile to a blob URL for display/download
+     */
+    toBlobUrl(stored: StoredFile): string;
+    /**
+     * Close the database connection
+     */
+    close(): void;
+}
+/**
+ * Factory function
+ */
+export declare function indexedDBDriver(dbName?: string, storeName?: string): IndexedDBDriver;
+//# sourceMappingURL=IndexedDBDriver.d.ts.map

package/lib/storage/IndexedDBDriver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IndexedDBDriver.d.ts","sourceRoot":"","sources":["IndexedDBDriver.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,WAAW,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,SAAS;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,eAAe;IACxB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,GAAG,CAA4B;gBAE3B,MAAM,GAAE,MAAoB,EAAE,SAAS,GAAE,MAAgB,EAAE,OAAO,GAAE,MAAU;IAM1F;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC;IA0BlC;;OAEG;IACG,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC;IAuB5E;;OAEG;IACG,QAAQ,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAQpF;;OAEG;IACG,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAYjD;;OAEG;IACG,IAAI,CAAC,KAAK,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAuCpD;;OAEG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYvC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAY5B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAQxD;;OAEG;IACH,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAIhC;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM;IAKrC;;OAEG;IACH,KAAK,IAAI,IAAI;CAMhB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,eAAe,CAEpF"}

package/lib/storage/IndexedDBDriver.js

@@ -0,0 +1,177 @@
+export class IndexedDBDriver {
+    constructor(dbName = 'jux-files', storeName = 'files', version = 1) {
+        this._db = null;
+        this._dbName = dbName;
+        this._storeName = storeName;
+        this._version = version;
+    }
+    /**
+     * Open the database connection
+     */
+    async open() {
+        if (this._db)
+            return this._db;
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(this._dbName, this._version);
+            request.onupgradeneeded = (e) => {
+                const db = e.target.result;
+                if (!db.objectStoreNames.contains(this._storeName)) {
+                    const store = db.createObjectStore(this._storeName, { keyPath: 'id' });
+                    store.createIndex('name', 'name', { unique: false });
+                    store.createIndex('type', 'type', { unique: false });
+                    store.createIndex('timestamp', 'timestamp', { unique: false });
+                }
+            };
+            request.onsuccess = (e) => {
+                this._db = e.target.result;
+                resolve(this._db);
+            };
+            request.onerror = () => reject(request.error);
+        });
+    }
+    /**
+     * Store a File object
+     */
+    async store(file, metadata) {
+        const db = await this.open();
+        const data = await file.arrayBuffer();
+        const stored = {
+            id: `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+            name: file.name,
+            size: file.size,
+            type: file.type,
+            data,
+            timestamp: Date.now(),
+            metadata
+        };
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(this._storeName, 'readwrite');
+            const store = tx.objectStore(this._storeName);
+            const request = store.put(stored);
+            request.onsuccess = () => resolve(stored);
+            request.onerror = () => reject(request.error);
+        });
+    }
+    /**
+     * Store multiple files
+     */
+    async storeAll(files, metadata) {
+        const results = [];
+        for (const file of files) {
+            results.push(await this.store(file, metadata));
+        }
+        return results;
+    }
+    /**
+     * Retrieve a stored file by ID
+     */
+    async get(id) {
+        const db = await this.open();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(this._storeName, 'readonly');
+            const store = tx.objectStore(this._storeName);
+            const request = store.get(id);
+            request.onsuccess = () => resolve(request.result || null);
+            request.onerror = () => reject(request.error);
+        });
+    }
+    /**
+     * Get all stored files (metadata only, no data by default)
+     */
+    async list(query) {
+        const db = await this.open();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(this._storeName, 'readonly');
+            const store = tx.objectStore(this._storeName);
+            const request = store.getAll();
+            request.onsuccess = () => {
+                let results = request.result || [];
+                if (query) {
+                    if (query.type) {
+                        results = results.filter(f => f.type.startsWith(query.type));
+                    }
+                    if (query.minSize !== undefined) {
+                        results = results.filter(f => f.size >= query.minSize);
+                    }
+                    if (query.maxSize !== undefined) {
+                        results = results.filter(f => f.size <= query.maxSize);
+                    }
+                    if (query.since !== undefined) {
+                        results = results.filter(f => f.timestamp >= query.since);
+                    }
+                    // Sort by timestamp descending
+                    results.sort((a, b) => b.timestamp - a.timestamp);
+                    if (query.limit !== undefined) {
+                        results = results.slice(0, query.limit);
+                    }
+                }
+                resolve(results);
+            };
+            request.onerror = () => reject(request.error);
+        });
+    }
+    /**
+     * Delete a stored file by ID
+     */
+    async delete(id) {
+        const db = await this.open();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(this._storeName, 'readwrite');
+            const store = tx.objectStore(this._storeName);
+            const request = store.delete(id);
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        });
+    }
+    /**
+     * Delete all stored files
+     */
+    async clear() {
+        const db = await this.open();
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(this._storeName, 'readwrite');
+            const store = tx.objectStore(this._storeName);
+            const request = store.clear();
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        });
+    }
+    /**
+     * Get total storage usage in bytes
+     */
+    async usage() {
+        const files = await this.list();
+        return {
+            count: files.length,
+            bytes: files.reduce((sum, f) => sum + f.size, 0)
+        };
+    }
+    /**
+     * Convert a StoredFile back to a File object
+     */
+    toFile(stored) {
+        return new File([stored.data], stored.name, { type: stored.type });
+    }
+    /**
+     * Convert a StoredFile to a blob URL for display/download
+     */
+    toBlobUrl(stored) {
+        const blob = new Blob([stored.data], { type: stored.type });
+        return URL.createObjectURL(blob);
+    }
+    /**
+     * Close the database connection
+     */
+    close() {
+        if (this._db) {
+            this._db.close();
+            this._db = null;
+        }
+    }
+}
+/**
+ * Factory function
+ */
+export function indexedDBDriver(dbName, storeName) {
+    return new IndexedDBDriver(dbName, storeName);
+}

package/lib/storage/IndexedDBDriver.ts

@@ -0,0 +1,226 @@
+export interface StoredFile {
+    id: string;
+    name: string;
+    size: number;
+    type: string;
+    data: ArrayBuffer;
+    timestamp: number;
+    metadata?: Record<string, any>;
+}
+
+export interface FileQuery {
+    type?: string;
+    minSize?: number;
+    maxSize?: number;
+    since?: number;
+    limit?: number;
+}
+
+export class IndexedDBDriver {
+    private _dbName: string;
+    private _storeName: string;
+    private _version: number;
+    private _db: IDBDatabase | null = null;
+
+    constructor(dbName: string = 'jux-files', storeName: string = 'files', version: number = 1) {
+        this._dbName = dbName;
+        this._storeName = storeName;
+        this._version = version;
+    }
+
+    /**
+     * Open the database connection
+     */
+    async open(): Promise<IDBDatabase> {
+        if (this._db) return this._db;
+
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(this._dbName, this._version);
+
+            request.onupgradeneeded = (e) => {
+                const db = (e.target as IDBOpenDBRequest).result;
+
+                if (!db.objectStoreNames.contains(this._storeName)) {
+                    const store = db.createObjectStore(this._storeName, { keyPath: 'id' });
+                    store.createIndex('name', 'name', { unique: false });
+                    store.createIndex('type', 'type', { unique: false });
+                    store.createIndex('timestamp', 'timestamp', { unique: false });
+                }
+            };
+
+            request.onsuccess = (e) => {
+                this._db = (e.target as IDBOpenDBRequest).result;
+                resolve(this._db);
+            };
+
+            request.onerror = () => reject(request.error);
+        });
+    }
+
+    /**
+     * Store a File object
+     */
+    async store(file: File, metadata?: Record<string, any>): Promise<StoredFile> {
+        const db = await this.open();
+        const data = await file.arrayBuffer();
+
+        const stored: StoredFile = {
+            id: `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+            name: file.name,
+            size: file.size,
+            type: file.type,
+            data,
+            timestamp: Date.now(),
+            metadata
+        };
+
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(this._storeName, 'readwrite');
+            const store = tx.objectStore(this._storeName);
+            const request = store.put(stored);
+            request.onsuccess = () => resolve(stored);
+            request.onerror = () => reject(request.error);
+        });
+    }
+
+    /**
+     * Store multiple files
+     */
+    async storeAll(files: File[], metadata?: Record<string, any>): Promise<StoredFile[]> {
+        const results: StoredFile[] = [];
+        for (const file of files) {
+            results.push(await this.store(file, metadata));
+        }
+        return results;
+    }
+
+    /**
+     * Retrieve a stored file by ID
+     */
+    async get(id: string): Promise<StoredFile | null> {
+        const db = await this.open();
+
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(this._storeName, 'readonly');
+            const store = tx.objectStore(this._storeName);
+            const request = store.get(id);
+            request.onsuccess = () => resolve(request.result || null);
+            request.onerror = () => reject(request.error);
+        });
+    }
+
+    /**
+     * Get all stored files (metadata only, no data by default)
+     */
+    async list(query?: FileQuery): Promise<StoredFile[]> {
+        const db = await this.open();
+
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(this._storeName, 'readonly');
+            const store = tx.objectStore(this._storeName);
+            const request = store.getAll();
+
+            request.onsuccess = () => {
+                let results: StoredFile[] = request.result || [];
+
+                if (query) {
+                    if (query.type) {
+                        results = results.filter(f => f.type.startsWith(query.type!));
+                    }
+                    if (query.minSize !== undefined) {
+                        results = results.filter(f => f.size >= query.minSize!);
+                    }
+                    if (query.maxSize !== undefined) {
+                        results = results.filter(f => f.size <= query.maxSize!);
+                    }
+                    if (query.since !== undefined) {
+                        results = results.filter(f => f.timestamp >= query.since!);
+                    }
+
+                    // Sort by timestamp descending
+                    results.sort((a, b) => b.timestamp - a.timestamp);
+
+                    if (query.limit !== undefined) {
+                        results = results.slice(0, query.limit);
+                    }
+                }
+
+                resolve(results);
+            };
+            request.onerror = () => reject(request.error);
+        });
+    }
+
+    /**
+     * Delete a stored file by ID
+     */
+    async delete(id: string): Promise<void> {
+        const db = await this.open();
+
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(this._storeName, 'readwrite');
+            const store = tx.objectStore(this._storeName);
+            const request = store.delete(id);
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        });
+    }
+
+    /**
+     * Delete all stored files
+     */
+    async clear(): Promise<void> {
+        const db = await this.open();
+
+        return new Promise((resolve, reject) => {
+            const tx = db.transaction(this._storeName, 'readwrite');
+            const store = tx.objectStore(this._storeName);
+            const request = store.clear();
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        });
+    }
+
+    /**
+     * Get total storage usage in bytes
+     */
+    async usage(): Promise<{ count: number; bytes: number }> {
+        const files = await this.list();
+        return {
+            count: files.length,
+            bytes: files.reduce((sum, f) => sum + f.size, 0)
+        };
+    }
+
+    /**
+     * Convert a StoredFile back to a File object
+     */
+    toFile(stored: StoredFile): File {
+        return new File([stored.data], stored.name, { type: stored.type });
+    }
+
+    /**
+     * Convert a StoredFile to a blob URL for display/download
+     */
+    toBlobUrl(stored: StoredFile): string {
+        const blob = new Blob([stored.data], { type: stored.type });
+        return URL.createObjectURL(blob);
+    }
+
+    /**
+     * Close the database connection
+     */
+    close(): void {
+        if (this._db) {
+            this._db.close();
+            this._db = null;
+        }
+    }
+}
+
+/**
+ * Factory function
+ */
+export function indexedDBDriver(dbName?: string, storeName?: string): IndexedDBDriver {
+    return new IndexedDBDriver(dbName, storeName);
+}

package/lib/storage/TabularDriver.d.ts

@@ -0,0 +1,75 @@
+import { DataFrame } from './DataFrame.js';
+export interface StoredTable {
+    id: string;
+    name: string;
+    columns: string[];
+    rows: any[][];
+    rowCount: number;
+    delimiter: string;
+    timestamp: number;
+    metadata?: Record<string, any>;
+}
+export interface ParseOptions {
+    delimiter?: string;
+    hasHeader?: boolean;
+    chunkSize?: number;
+    onProgress?: (parsed: number, total: number | null) => void;
+    maxRows?: number;
+    skipRows?: number;
+    columns?: string[];
+}
+export declare class TabularDriver {
+    private _dbName;
+    private _storeName;
+    private _db;
+    constructor(dbName?: string, storeName?: string);
+    open(): Promise<IDBDatabase>;
+    /**
+     * Parse a CSV/TSV string into a DataFrame
+     */
+    parseCSV(text: string, options?: ParseOptions): DataFrame;
+    /**
+     * Stream-parse a File into a DataFrame, with progress callback
+     */
+    streamFile(file: File, options?: ParseOptions): Promise<DataFrame>;
+    /**
+     * Store a DataFrame to IndexedDB
+     */
+    store(name: string, df: DataFrame, metadata?: Record<string, any>): Promise<string>;
+    /**
+     * Load a DataFrame from IndexedDB by ID
+     */
+    load(id: string): Promise<DataFrame | null>;
+    /**
+     * Load the most recent table by name
+     */
+    loadByName(name: string): Promise<DataFrame | null>;
+    /**
+     * List all stored tables (metadata only)
+     */
+    list(): Promise<Array<{
+        id: string;
+        name: string;
+        columns: string[];
+        rowCount: number;
+        timestamp: number;
+    }>>;
+    /**
+     * Delete a stored table
+     */
+    delete(id: string): Promise<void>;
+    clear(): Promise<void>;
+    /**
+     * Fetch and stream-parse a remote CSV/TSV file
+     */
+    fetch(url: string, options?: ParseOptions): Promise<DataFrame>;
+    private _splitLines;
+    private _parseLine;
+    private _autoType;
+    close(): void;
+}
+/**
+ * Factory
+ */
+export declare function tabularDriver(dbName?: string, storeName?: string): TabularDriver;
+//# sourceMappingURL=TabularDriver.d.ts.map

package/lib/storage/TabularDriver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TabularDriver.d.ts","sourceRoot":"","sources":["TabularDriver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,MAAM,WAAW,WAAW;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,YAAY;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,qBAAa,aAAa;IACtB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,GAAG,CAA4B;gBAE3B,MAAM,GAAE,MAAsB,EAAE,SAAS,GAAE,MAAiB;IAKlE,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC;IA4BlC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,SAAS;IA6C7D;;OAEG;IACG,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,SAAS,CAAC;IA8F5E;;OAEG;IACG,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAuBzF;;OAEG;IACG,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAwBjD;;OAEG;IACG,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IA4BzD;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAqBlH;;OAEG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYjC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB5B;;OAEG;IACG,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,SAAS,CAAC;IA8ExE,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,UAAU;IAmClB,OAAO,CAAC,SAAS;IAYjB,KAAK,IAAI,IAAI;CAMhB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,aAAa,CAEhF"}