@capgo/capacitor-fast-sql 7.0.1

package/dist/esm/helpers.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Helper classes for easier SQL operations
+ * Import these separately: import { NativeSQL, SQLConnection } from '@capgo/capacitor-native-sql/helpers';
+ */
+export { NativeSQL } from './native-sql';
+export { SQLConnection } from './sql-connection';
+//# sourceMappingURL=helpers.d.ts.map

package/dist/esm/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/helpers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/esm/helpers.js

@@ -0,0 +1,6 @@
+/**
+ * Helper classes for easier SQL operations
+ * Import these separately: import { NativeSQL, SQLConnection } from '@capgo/capacitor-native-sql/helpers';
+ */
+export { NativeSQL } from './native-sql';
+export { SQLConnection } from './sql-connection';

package/dist/esm/index.d.ts

@@ -0,0 +1,5 @@
+export * from './definitions';
+export { CapgoCapacitorNativeSql } from './plugin';
+export { NativeSQL } from './native-sql';
+export { SQLConnection } from './sql-connection';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAGnD,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+export * from './definitions';
+export { CapgoCapacitorNativeSql } from './plugin';
+// Re-export helper classes for convenience
+export { NativeSQL } from './native-sql';
+export { SQLConnection } from './sql-connection';

package/dist/esm/native-sql.d.ts

@@ -0,0 +1,42 @@
+import type { SQLConnectionOptions } from './definitions';
+import { SQLConnection } from './sql-connection';
+/**
+ * NativeSQL - High-level API for managing SQL connections
+ *
+ * This class provides a convenient interface for opening/closing database connections
+ * and managing multiple databases simultaneously.
+ */
+export declare class NativeSQL {
+    private static connections;
+    /**
+     * Open a database connection
+     *
+     * @param options - Connection options
+     * @returns SQLConnection instance for executing queries
+     */
+    static connect(options: SQLConnectionOptions): Promise<SQLConnection>;
+    /**
+     * Close a database connection
+     *
+     * @param database - Database name to close
+     */
+    static disconnect(database: string): Promise<void>;
+    /**
+     * Get an existing connection
+     *
+     * @param database - Database name
+     * @returns SQLConnection instance or null if not connected
+     */
+    static getConnection(database: string): SQLConnection | null;
+    /**
+     * Close all open connections
+     */
+    static disconnectAll(): Promise<void>;
+    /**
+     * Get list of all open database connections
+     *
+     * @returns Array of database names
+     */
+    static getOpenDatabases(): string[];
+}
+//# sourceMappingURL=native-sql.d.ts.map

package/dist/esm/native-sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-sql.d.ts","sourceRoot":"","sources":["../../src/native-sql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAE1D,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD;;;;;GAKG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAC,WAAW,CAAyC;IAEnE;;;;;OAKG;WACU,OAAO,CAClB,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,aAAa,CAAC;IAsBzB;;;;OAIG;WACU,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAaxD;;;;;OAKG;IACH,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;IAI5D;;OAEG;WACU,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAK3C;;;;OAIG;IACH,MAAM,CAAC,gBAAgB,IAAI,MAAM,EAAE;CAGpC"}

package/dist/esm/native-sql.js

@@ -0,0 +1,69 @@
+import { CapgoCapacitorNativeSql } from './plugin';
+import { SQLConnection } from './sql-connection';
+/**
+ * NativeSQL - High-level API for managing SQL connections
+ *
+ * This class provides a convenient interface for opening/closing database connections
+ * and managing multiple databases simultaneously.
+ */
+export class NativeSQL {
+    /**
+     * Open a database connection
+     *
+     * @param options - Connection options
+     * @returns SQLConnection instance for executing queries
+     */
+    static async connect(options) {
+        // Check if already connected
+        if (this.connections.has(options.database)) {
+            return this.connections.get(options.database);
+        }
+        // Connect via native plugin
+        const info = await CapgoCapacitorNativeSql.connect(options);
+        // Create connection instance
+        const connection = new SQLConnection(info.database, info.port, info.token);
+        // Store connection
+        this.connections.set(options.database, connection);
+        return connection;
+    }
+    /**
+     * Close a database connection
+     *
+     * @param database - Database name to close
+     */
+    static async disconnect(database) {
+        const connection = this.connections.get(database);
+        if (!connection) {
+            throw new Error(`Database '${database}' is not connected`);
+        }
+        // Disconnect via native plugin
+        await CapgoCapacitorNativeSql.disconnect({ database });
+        // Remove connection
+        this.connections.delete(database);
+    }
+    /**
+     * Get an existing connection
+     *
+     * @param database - Database name
+     * @returns SQLConnection instance or null if not connected
+     */
+    static getConnection(database) {
+        return this.connections.get(database) || null;
+    }
+    /**
+     * Close all open connections
+     */
+    static async disconnectAll() {
+        const databases = Array.from(this.connections.keys());
+        await Promise.all(databases.map((db) => this.disconnect(db)));
+    }
+    /**
+     * Get list of all open database connections
+     *
+     * @returns Array of database names
+     */
+    static getOpenDatabases() {
+        return Array.from(this.connections.keys());
+    }
+}
+NativeSQL.connections = new Map();

package/dist/esm/plugin.d.ts

@@ -0,0 +1,3 @@
+import type { CapgoCapacitorNativeSqlPlugin } from './definitions';
+export declare const CapgoCapacitorNativeSql: CapgoCapacitorNativeSqlPlugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/esm/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,eAAe,CAAC;AAEnE,eAAO,MAAM,uBAAuB,+BAGhC,CAAC"}

package/dist/esm/plugin.js

@@ -0,0 +1,4 @@
+import { registerPlugin } from '@capacitor/core';
+export const CapgoCapacitorNativeSql = registerPlugin('CapgoCapacitorNativeSql', {
+    web: () => import('./web').then((m) => new m.CapgoCapacitorNativeSqlWeb()),
+});

package/dist/esm/sql-connection.d.ts

@@ -0,0 +1,94 @@
+import type { SQLValue, SQLRow, SQLResult, SQLBatchOperation } from './definitions';
+import { IsolationLevel } from './definitions';
+/**
+ * SQL Connection class that uses HTTP protocol for efficient communication
+ * with native SQLite databases, bypassing Capacitor's standard bridge.
+ *
+ * Inspired by capacitor-blob-writer's approach to avoid serialization overhead.
+ */
+export declare class SQLConnection {
+    private port;
+    private token;
+    private database;
+    private baseUrl;
+    private inTransaction;
+    constructor(database: string, port: number, token: string);
+    /**
+     * Get the database name
+     */
+    getDatabaseName(): string;
+    /**
+     * Execute a SQL query via HTTP protocol for optimal performance
+     *
+     * @param statement - SQL statement to execute
+     * @param params - Parameters to bind to the statement
+     * @returns Query results
+     */
+    execute(statement: string, params?: SQLValue[]): Promise<SQLResult>;
+    /**
+     * Execute multiple SQL statements in a batch for better performance
+     *
+     * @param operations - Array of SQL operations to execute
+     * @returns Array of results for each operation
+     */
+    executeBatch(operations: SQLBatchOperation[]): Promise<SQLResult[]>;
+    /**
+     * Begin a transaction
+     *
+     * @param isolationLevel - Optional isolation level
+     */
+    beginTransaction(isolationLevel?: IsolationLevel): Promise<void>;
+    /**
+     * Commit the current transaction
+     */
+    commit(): Promise<void>;
+    /**
+     * Rollback the current transaction
+     */
+    rollback(): Promise<void>;
+    /**
+     * Execute operations within a transaction automatically
+     *
+     * @param callback - Function containing operations to execute
+     * @param isolationLevel - Optional isolation level
+     */
+    transaction<T>(callback: (conn: SQLConnection) => Promise<T>, isolationLevel?: IsolationLevel): Promise<T>;
+    /**
+     * Query helper for SELECT statements
+     *
+     * @param statement - SELECT statement
+     * @param params - Query parameters
+     * @returns Array of rows
+     */
+    query(statement: string, params?: SQLValue[]): Promise<SQLRow[]>;
+    /**
+     * Execute helper for INSERT/UPDATE/DELETE statements
+     *
+     * @param statement - SQL statement
+     * @param params - Statement parameters
+     * @returns Number of affected rows and insert ID if applicable
+     */
+    run(statement: string, params?: SQLValue[]): Promise<{
+        rowsAffected: number;
+        insertId?: number;
+    }>;
+    /**
+     * Serialize parameters for transmission
+     * Binary data (Uint8Array) is converted to base64 for JSON transport
+     */
+    private serializeParams;
+    /**
+     * Deserialize result from server
+     * Base64-encoded binary data is converted back to Uint8Array
+     */
+    private deserializeResult;
+    /**
+     * Convert Uint8Array to base64 string
+     */
+    private uint8ArrayToBase64;
+    /**
+     * Convert base64 string to Uint8Array
+     */
+    private base64ToUint8Array;
+}
+//# sourceMappingURL=sql-connection.d.ts.map

package/dist/esm/sql-connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-connection.d.ts","sourceRoot":"","sources":["../../src/sql-connection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,MAAM,EACN,SAAS,EACT,iBAAiB,EAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C;;;;;GAKG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,aAAa,CAAS;gBAElB,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAOzD;;OAEG;IACH,eAAe,IAAI,MAAM;IAIzB;;;;;;OAMG;IACG,OAAO,CACX,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,QAAQ,EAAE,GAClB,OAAO,CAAC,SAAS,CAAC;IAuBrB;;;;;OAKG;IACG,YAAY,CAChB,UAAU,EAAE,iBAAiB,EAAE,GAC9B,OAAO,CAAC,SAAS,EAAE,CAAC;IAyBvB;;;;OAIG;IACG,gBAAgB,CACpB,cAAc,CAAC,EAAE,cAAc,GAC9B,OAAO,CAAC,IAAI,CAAC;IAyBhB;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAqB7B;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAqB/B;;;;;OAKG;IACG,WAAW,CAAC,CAAC,EACjB,QAAQ,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC,CAAC,CAAC,EAC7C,cAAc,CAAC,EAAE,cAAc,GAC9B,OAAO,CAAC,CAAC,CAAC;IAYb;;;;;;OAMG;IACG,KAAK,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAKtE;;;;;;OAMG;IACG,GAAG,CACP,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,QAAQ,EAAE,GAClB,OAAO,CAAC;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAQvD;;;OAGG;IACH,OAAO,CAAC,eAAe;IAYvB;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAwBzB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAQ1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;CAQ3B"}

package/dist/esm/sql-connection.js

@@ -0,0 +1,246 @@
+import { IsolationLevel } from './definitions';
+/**
+ * SQL Connection class that uses HTTP protocol for efficient communication
+ * with native SQLite databases, bypassing Capacitor's standard bridge.
+ *
+ * Inspired by capacitor-blob-writer's approach to avoid serialization overhead.
+ */
+export class SQLConnection {
+    constructor(database, port, token) {
+        this.inTransaction = false;
+        this.database = database;
+        this.port = port;
+        this.token = token;
+        this.baseUrl = `http://localhost:${port}`;
+    }
+    /**
+     * Get the database name
+     */
+    getDatabaseName() {
+        return this.database;
+    }
+    /**
+     * Execute a SQL query via HTTP protocol for optimal performance
+     *
+     * @param statement - SQL statement to execute
+     * @param params - Parameters to bind to the statement
+     * @returns Query results
+     */
+    async execute(statement, params) {
+        const response = await fetch(`${this.baseUrl}/execute`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.token}`,
+                'X-Database': this.database,
+            },
+            body: JSON.stringify({
+                statement,
+                params: params ? this.serializeParams(params) : [],
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`SQL execution failed: ${error}`);
+        }
+        const result = await response.json();
+        return this.deserializeResult(result);
+    }
+    /**
+     * Execute multiple SQL statements in a batch for better performance
+     *
+     * @param operations - Array of SQL operations to execute
+     * @returns Array of results for each operation
+     */
+    async executeBatch(operations) {
+        const response = await fetch(`${this.baseUrl}/batch`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.token}`,
+                'X-Database': this.database,
+            },
+            body: JSON.stringify({
+                operations: operations.map((op) => ({
+                    statement: op.statement,
+                    params: op.params ? this.serializeParams(op.params) : [],
+                })),
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`SQL batch execution failed: ${error}`);
+        }
+        const results = await response.json();
+        return results.map((r) => this.deserializeResult(r));
+    }
+    /**
+     * Begin a transaction
+     *
+     * @param isolationLevel - Optional isolation level
+     */
+    async beginTransaction(isolationLevel) {
+        if (this.inTransaction) {
+            throw new Error('Transaction already in progress');
+        }
+        const response = await fetch(`${this.baseUrl}/transaction/begin`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.token}`,
+                'X-Database': this.database,
+            },
+            body: JSON.stringify({
+                isolationLevel: isolationLevel || IsolationLevel.Serializable,
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Failed to begin transaction: ${error}`);
+        }
+        this.inTransaction = true;
+    }
+    /**
+     * Commit the current transaction
+     */
+    async commit() {
+        if (!this.inTransaction) {
+            throw new Error('No transaction in progress');
+        }
+        const response = await fetch(`${this.baseUrl}/transaction/commit`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+                'X-Database': this.database,
+            },
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Failed to commit transaction: ${error}`);
+        }
+        this.inTransaction = false;
+    }
+    /**
+     * Rollback the current transaction
+     */
+    async rollback() {
+        if (!this.inTransaction) {
+            throw new Error('No transaction in progress');
+        }
+        const response = await fetch(`${this.baseUrl}/transaction/rollback`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+                'X-Database': this.database,
+            },
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Failed to rollback transaction: ${error}`);
+        }
+        this.inTransaction = false;
+    }
+    /**
+     * Execute operations within a transaction automatically
+     *
+     * @param callback - Function containing operations to execute
+     * @param isolationLevel - Optional isolation level
+     */
+    async transaction(callback, isolationLevel) {
+        await this.beginTransaction(isolationLevel);
+        try {
+            const result = await callback(this);
+            await this.commit();
+            return result;
+        }
+        catch (error) {
+            await this.rollback();
+            throw error;
+        }
+    }
+    /**
+     * Query helper for SELECT statements
+     *
+     * @param statement - SELECT statement
+     * @param params - Query parameters
+     * @returns Array of rows
+     */
+    async query(statement, params) {
+        const result = await this.execute(statement, params);
+        return result.rows;
+    }
+    /**
+     * Execute helper for INSERT/UPDATE/DELETE statements
+     *
+     * @param statement - SQL statement
+     * @param params - Statement parameters
+     * @returns Number of affected rows and insert ID if applicable
+     */
+    async run(statement, params) {
+        const result = await this.execute(statement, params);
+        return {
+            rowsAffected: result.rowsAffected,
+            insertId: result.insertId,
+        };
+    }
+    /**
+     * Serialize parameters for transmission
+     * Binary data (Uint8Array) is converted to base64 for JSON transport
+     */
+    serializeParams(params) {
+        return params.map((param) => {
+            if (param instanceof Uint8Array) {
+                return {
+                    _type: 'binary',
+                    _data: this.uint8ArrayToBase64(param),
+                };
+            }
+            return param;
+        });
+    }
+    /**
+     * Deserialize result from server
+     * Base64-encoded binary data is converted back to Uint8Array
+     */
+    deserializeResult(result) {
+        return {
+            rows: result.rows.map((row) => {
+                const deserializedRow = {};
+                for (const [key, value] of Object.entries(row)) {
+                    if (value &&
+                        typeof value === 'object' &&
+                        value._type === 'binary') {
+                        deserializedRow[key] = this.base64ToUint8Array(value._data);
+                    }
+                    else {
+                        deserializedRow[key] = value;
+                    }
+                }
+                return deserializedRow;
+            }),
+            rowsAffected: result.rowsAffected || 0,
+            insertId: result.insertId,
+        };
+    }
+    /**
+     * Convert Uint8Array to base64 string
+     */
+    uint8ArrayToBase64(bytes) {
+        let binary = '';
+        for (let i = 0; i < bytes.byteLength; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+    }
+    /**
+     * Convert base64 string to Uint8Array
+     */
+    base64ToUint8Array(base64) {
+        const binary = atob(base64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes;
+    }
+}

package/dist/esm/web.d.ts

@@ -0,0 +1,67 @@
+import { WebPlugin } from '@capacitor/core';
+import type { CapgoCapacitorNativeSqlPlugin, SQLConnectionOptions, SQLResult, SQLValue, IsolationLevel } from './definitions';
+/**
+ * Web implementation using sql.js (SQLite compiled to WebAssembly)
+ *
+ * This provides a compatible API on the web platform, storing databases
+ * in IndexedDB for persistence.
+ */
+export declare class CapgoCapacitorNativeSqlWeb extends WebPlugin implements CapgoCapacitorNativeSqlPlugin {
+    private databases;
+    private sqlPromise;
+    private nextPort;
+    constructor();
+    /**
+     * Load sql.js library
+     */
+    private loadSqlJs;
+    connect(options: SQLConnectionOptions): Promise<{
+        port: number;
+        token: string;
+        database: string;
+    }>;
+    disconnect(options: {
+        database: string;
+    }): Promise<void>;
+    getServerInfo(options: {
+        database: string;
+    }): Promise<{
+        port: number;
+        token: string;
+    }>;
+    execute(options: {
+        database: string;
+        statement: string;
+        params?: SQLValue[];
+    }): Promise<SQLResult>;
+    beginTransaction(options: {
+        database: string;
+        isolationLevel?: IsolationLevel;
+    }): Promise<void>;
+    commitTransaction(options: {
+        database: string;
+    }): Promise<void>;
+    rollbackTransaction(options: {
+        database: string;
+    }): Promise<void>;
+    /**
+     * Generate a random authentication token
+     */
+    private generateToken;
+    /**
+     * Get last insert row ID
+     */
+    private getLastInsertId;
+    /**
+     * Save database to IndexedDB
+     */
+    private saveToIndexedDB;
+    /**
+     * Load database from IndexedDB
+     */
+    private loadFromIndexedDB;
+    getPluginVersion(): Promise<{
+        version: string;
+    }>;
+}
+//# sourceMappingURL=web.d.ts.map

package/dist/esm/web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,KAAK,EACV,6BAA6B,EAC7B,oBAAoB,EACpB,SAAS,EACT,QAAQ,EACR,cAAc,EACf,MAAM,eAAe,CAAC;AAEvB;;;;;GAKG;AACH,qBAAa,0BACX,SAAQ,SACR,YAAW,6BAA6B;IAExC,OAAO,CAAC,SAAS,CAGH;IACd,OAAO,CAAC,UAAU,CAA6B;IAC/C,OAAO,CAAC,QAAQ,CAAQ;;IAOxB;;OAEG;YACW,SAAS;IAyBjB,OAAO,CACX,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAyBvD,UAAU,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAcxD,aAAa,CAAC,OAAO,EAAE;QAC3B,QAAQ,EAAE,MAAM,CAAC;KAClB,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAYtC,OAAO,CAAC,OAAO,EAAE;QACrB,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC;KACrB,GAAG,OAAO,CAAC,SAAS,CAAC;IAiChB,gBAAgB,CAAC,OAAO,EAAE;QAC9B,QAAQ,EAAE,MAAM,CAAC;QACjB,cAAc,CAAC,EAAE,cAAc,CAAC;KACjC,GAAG,OAAO,CAAC,IAAI,CAAC;IAOX,iBAAiB,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAO/D,mBAAmB,CAAC,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAOvE;;OAEG;IACH,OAAO,CAAC,aAAa;IAMrB;;OAEG;IACH,OAAO,CAAC,eAAe;IAYvB;;OAEG;YACW,eAAe;IAmC7B;;OAEG;YACW,iBAAiB;IAkCzB,gBAAgB,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CAGvD"}