@lossless.org/nosqldb 8.0.0

package/dist_ts/ts_nosqldb/server/classes.nosqldbserver.js

@@ -0,0 +1,456 @@
+import { RustDbBridge, NoSqlDbManagementOperationTerminationError, } from '../rust-db-bridge.js';
+import { validateNoSqlDbManagementOperationOptions } from '../offline-inspection.js';
+import { validateNoSqlDbStorageRehearsalStartup } from '../storage-rehearsal.js';
+import { assertNoLocalNoSqlDbStorageRootRelocationWorkspace } from '../storage-root-relocation.js';
+import {} from '../file-storage-startup.js';
+import { normalizeNoSqlDbFileStorageOptions, } from '../file-storage-options.js';
+/**
+ * NoSqlDbServer - Wire protocol compatible database server backed by Rust
+ *
+ * This server implements the wire protocol to allow official drivers to
+ * connect and perform operations. The core engine runs as a Rust sidecar
+ * binary managed via @push.rocks/smartrust IPC.
+ *
+ * @example
+ * ```typescript
+ * import { NoSqlDbServer } from '@lossless.org/nosqldb';
+ * import { MongoClient } from 'mongodb';
+ *
+ * const server = new NoSqlDbServer({ port: 27017 });
+ * await server.start();
+ *
+ * const client = new MongoClient(server.getConnectionUri());
+ * await client.connect();
+ * ```
+ */
+export class NoSqlDbServer {
+    constructor(options = {}) {
+        this.bridgeOwned = false;
+        this.startInProgress = false;
+        this.startCompletionPromise = null;
+        this.isRunning = false;
+        this.resolvedConnectionUri = '';
+        validateNoSqlDbStorageRehearsalStartup(options);
+        const fileStorage = normalizeNoSqlDbFileStorageOptions(options);
+        this.options = {
+            binaryPath: options.binaryPath,
+            storageRehearsalId: options.storageRehearsalId,
+            ...fileStorage,
+            port: options.port ?? 27017,
+            host: options.host ?? '127.0.0.1',
+            socketPath: options.socketPath,
+            storage: options.storage ?? 'memory',
+            storagePath: options.storagePath ?? './data',
+            auth: options.auth,
+            tls: options.tls,
+            oplog: options.oplog,
+            query: options.query,
+        };
+        this.bridge = new RustDbBridge({ binaryPath: this.options.binaryPath });
+        this.bridge.on('exit', (code, signal) => {
+            const exitedUnexpectedly = this.isRunning;
+            this.isRunning = false;
+            this.bridgeOwned = false;
+            this.resolvedConnectionUri = '';
+            this.resolvedPort = undefined;
+            if (exitedUnexpectedly) {
+                console.error(`nosqldb Rust process exited unexpectedly (code=${code}, signal=${signal})`);
+            }
+        });
+    }
+    /**
+     * Start the server
+     */
+    async start(optionsArg) {
+        validateNoSqlDbManagementOperationOptions(optionsArg);
+        optionsArg?.signal?.throwIfAborted();
+        if (this.isRunning || this.startInProgress || this.bridgeOwned) {
+            throw new Error('Server is already running or still owns a Rust bridge');
+        }
+        const startupStartedAt = Date.now();
+        const startupDeadline = optionsArg?.timeoutMs === undefined
+            ? undefined
+            : startupStartedAt + optionsArg.timeoutMs;
+        const timeoutError = new DOMException(optionsArg?.timeoutMs === undefined
+            ? 'NoSQLDB startup timed out'
+            : `NoSQLDB startup timed out after ${optionsArg.timeoutMs}ms`, 'TimeoutError');
+        const startupAbortController = new AbortController();
+        let startupTimeout;
+        let externalAbortHandler;
+        if (optionsArg?.signal) {
+            externalAbortHandler = () => {
+                startupAbortController.abort(optionsArg.signal.reason);
+            };
+            optionsArg.signal.addEventListener('abort', externalAbortHandler, { once: true });
+        }
+        if (optionsArg?.timeoutMs !== undefined) {
+            startupTimeout = setTimeout(() => {
+                startupAbortController.abort(timeoutError);
+            }, optionsArg.timeoutMs);
+        }
+        const checkpoint = () => {
+            if (startupDeadline !== undefined
+                && Date.now() >= startupDeadline
+                && !startupAbortController.signal.aborted) {
+                startupAbortController.abort(timeoutError);
+            }
+            startupAbortController.signal.throwIfAborted();
+        };
+        const getBridgeOperationOptions = () => {
+            checkpoint();
+            const remainingTimeoutMs = startupDeadline === undefined
+                ? undefined
+                : startupDeadline - Date.now();
+            if (remainingTimeoutMs !== undefined && remainingTimeoutMs <= 0) {
+                startupAbortController.abort(timeoutError);
+                checkpoint();
+            }
+            if (!optionsArg?.signal && remainingTimeoutMs === undefined)
+                return undefined;
+            return {
+                ...(optionsArg?.signal ? { signal: optionsArg.signal } : {}),
+                ...(remainingTimeoutMs === undefined ? {} : { timeoutMs: remainingTimeoutMs }),
+            };
+        };
+        this.startInProgress = true;
+        let resolveStartCompletion;
+        const startCompletionPromise = new Promise((resolveArg) => {
+            resolveStartCompletion = resolveArg;
+        });
+        this.startCompletionPromise = startCompletionPromise;
+        try {
+            checkpoint();
+            // Relocation workspace admission is read-only; the native owner alone
+            // classifies and initializes storage after acquiring its root lease.
+            if (this.options.storage === 'file' && this.options.storagePath) {
+                await assertNoLocalNoSqlDbStorageRootRelocationWorkspace(this.options.storagePath);
+                checkpoint();
+            }
+            // Ownership starts before spawn because a rejected spawn can still have
+            // created a child whose termination must be confirmed.
+            this.bridgeOwned = true;
+            const spawned = await this.bridge.spawn(getBridgeOperationOptions());
+            checkpoint();
+            if (!spawned) {
+                throw new Error('nosqldb Rust binary not found. Set NOSQLDB_RUST_BINARY env var, ' +
+                    'install the platform package, or build locally with `tsrust`.');
+            }
+            // Send config, get back connectionUri
+            const result = await this.bridge.startDb({
+                port: this.options.port,
+                host: this.options.host,
+                socketPath: this.options.socketPath,
+                storage: this.options.storage ?? 'memory',
+                storagePath: this.options.storagePath,
+                storageRehearsalId: this.options.storageRehearsalId,
+                auth: this.options.auth,
+                tls: this.options.tls,
+                oplog: this.options.oplog,
+                query: this.options.query,
+            }, getBridgeOperationOptions());
+            checkpoint();
+            if (!this.bridgeOwned || !this.bridge.running) {
+                throw new Error('nosqldb Rust process exited during startup');
+            }
+            if (!this.options.socketPath) {
+                const connectionUrl = new URL(result.connectionUri);
+                const resolvedPort = Number(connectionUrl.port);
+                if (connectionUrl.protocol !== 'mongodb:'
+                    || !connectionUrl.hostname
+                    || !Number.isInteger(resolvedPort)
+                    || resolvedPort < 1
+                    || resolvedPort > 65_535) {
+                    throw new Error(`nosqldb returned an invalid TCP connection URI: ${result.connectionUri}`);
+                }
+                this.resolvedPort = resolvedPort;
+            }
+            this.resolvedConnectionUri = result.connectionUri;
+            checkpoint();
+            this.isRunning = true;
+        }
+        catch (error) {
+            const startupError = error instanceof NoSqlDbManagementOperationTerminationError
+                ? error
+                : optionsArg?.signal?.aborted
+                    ? optionsArg.signal.reason
+                    : startupAbortController.signal.aborted || (startupDeadline !== undefined && Date.now() >= startupDeadline)
+                        ? timeoutError
+                        : error;
+            this.isRunning = false;
+            this.resolvedConnectionUri = '';
+            this.resolvedPort = undefined;
+            if (this.bridgeOwned) {
+                try {
+                    await this.bridge.terminate();
+                    this.bridgeOwned = false;
+                }
+                catch (cleanupError) {
+                    throw new AggregateError([startupError, cleanupError], 'NoSQLDB startup failed and Rust bridge cleanup was incomplete', { cause: startupError });
+                }
+            }
+            throw startupError;
+        }
+        finally {
+            if (startupTimeout)
+                clearTimeout(startupTimeout);
+            if (externalAbortHandler && optionsArg?.signal) {
+                optionsArg.signal.removeEventListener('abort', externalAbortHandler);
+            }
+            this.startInProgress = false;
+            resolveStartCompletion();
+            if (this.startCompletionPromise === startCompletionPromise) {
+                this.startCompletionPromise = null;
+            }
+        }
+    }
+    /**
+     * Stop the server
+     */
+    async stop() {
+        const startCompletionPromise = this.startCompletionPromise;
+        if (startCompletionPromise) {
+            await startCompletionPromise;
+        }
+        if (!this.isRunning && !this.bridgeOwned) {
+            return;
+        }
+        const requestGracefulStop = this.isRunning && this.bridge.running;
+        this.isRunning = false;
+        this.resolvedConnectionUri = '';
+        this.resolvedPort = undefined;
+        if (requestGracefulStop) {
+            try {
+                await this.bridge.stopDb();
+            }
+            catch {
+                // Confirmed bridge termination below still releases the owned process.
+            }
+        }
+        await this.bridge.terminate();
+        this.bridgeOwned = false;
+    }
+    /**
+     * Get the connection URI for this server
+     */
+    getConnectionUri() {
+        if (this.resolvedConnectionUri) {
+            return this.resolvedConnectionUri;
+        }
+        // Fallback: compute from options
+        if (this.options.socketPath) {
+            const encodedPath = encodeURIComponent(this.options.socketPath);
+            return `mongodb://${encodedPath}`;
+        }
+        const baseUri = `mongodb://${this.options.host ?? '127.0.0.1'}:${this.options.port ?? 27017}`;
+        return this.options.tls?.enabled ? `${baseUri}/?tls=true` : baseUri;
+    }
+    /**
+     * Get the socket path (if using Unix socket mode)
+     */
+    get socketPath() {
+        return this.options.socketPath;
+    }
+    /**
+     * Check if the server is running
+     */
+    /** Process id of the spawned Rust engine, when it runs as a child process. */
+    get processId() {
+        return this.bridge.processId;
+    }
+    get running() {
+        return this.isRunning;
+    }
+    async runDatabaseManagementOperation(operationArg) {
+        try {
+            return await operationArg();
+        }
+        catch (error) {
+            if (!this.bridge.running
+                || error instanceof NoSqlDbManagementOperationTerminationError) {
+                this.isRunning = false;
+                this.resolvedConnectionUri = '';
+                this.resolvedPort = undefined;
+                if (this.bridge.ownershipReleased) {
+                    this.bridgeOwned = false;
+                }
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get the port the server is listening on
+     */
+    get port() {
+        return this.resolvedPort ?? this.options.port ?? 27017;
+    }
+    /**
+     * Get the host the server is bound to
+     */
+    get host() {
+        return this.options.host ?? '127.0.0.1';
+    }
+    /**
+     * Create an isolated database/user pair for an application tenant.
+     */
+    async createDatabaseTenant(params) {
+        const descriptor = await this.bridge.createDatabaseTenant(params);
+        return this.withTenantMongoUri(descriptor, params.password);
+    }
+    /** Authoritatively allocate an absent, fenced database tenant. */
+    async allocateDatabaseTenant(params, optionsArg) {
+        const descriptor = await this.runDatabaseManagementOperation(() => this.bridge.allocateDatabaseTenant(params, optionsArg));
+        return this.withTenantMongoUri(descriptor, params.password);
+    }
+    /**
+     * Idempotently provision or rotate one exclusively owned database tenant.
+     */
+    async ensureDatabaseTenant(params, optionsArg) {
+        const descriptor = await this.runDatabaseManagementOperation(() => this.bridge.ensureDatabaseTenant(params, optionsArg));
+        return this.withTenantMongoUri(descriptor, params.password);
+    }
+    /** Verify an exact tenant credential without changing provider state. */
+    async attestDatabaseTenant(params, optionsArg) {
+        return this.runDatabaseManagementOperation(() => this.bridge.attestDatabaseTenant(params, optionsArg));
+    }
+    /**
+     * Delete a tenant database and its tenant user(s).
+     */
+    async deleteDatabaseTenant(params, optionsArg) {
+        return this.runDatabaseManagementOperation(() => this.bridge.deleteDatabaseTenant(params, optionsArg));
+    }
+    /** Issue one fixed-expiry read grant bound to an exact active allocation. */
+    async issueDatabaseAllocationReadAccessGrant(params, optionsArg) {
+        const descriptor = await this.runDatabaseManagementOperation(() => this.bridge.issueDatabaseAllocationReadAccessGrant(params, optionsArg));
+        return this.withTenantMongoUri(descriptor, params.password);
+    }
+    /** Idempotently revoke one allocation read grant without returning a secret. */
+    async revokeDatabaseAllocationReadAccessGrant(params, optionsArg) {
+        return this.runDatabaseManagementOperation(() => this.bridge.revokeDatabaseAllocationReadAccessGrant(params, optionsArg));
+    }
+    /**
+     * Rotate a tenant user's password without restarting the server.
+     */
+    async rotateDatabaseTenantPassword(params) {
+        const descriptor = await this.bridge.rotateDatabaseTenantPassword(params);
+        return this.withTenantMongoUri(descriptor, params.password);
+    }
+    /**
+     * List known database tenants.
+     */
+    async listDatabaseTenants() {
+        return this.bridge.listDatabaseTenants();
+    }
+    /**
+     * Get a tenant descriptor without exposing a password.
+     */
+    async getDatabaseTenantDescriptor(params) {
+        return this.bridge.getDatabaseTenantDescriptor(params);
+    }
+    /** Inspect the durable high-water mark without exposing mutation receipts. */
+    async getDatabaseResourceFenceState(params, optionsArg) {
+        return this.runDatabaseManagementOperation(() => this.bridge.getDatabaseResourceFenceState(params, optionsArg));
+    }
+    /**
+     * Export one database as an Extended JSON snapshot.
+     */
+    async exportDatabase(params, optionsArg) {
+        return this.runDatabaseManagementOperation(() => this.bridge.exportDatabase(params, optionsArg));
+    }
+    /** Compute a bounded, database-name-independent digest of logical database content. */
+    async getDatabaseContentDigest(params, optionsArg) {
+        return this.runDatabaseManagementOperation(() => this.bridge.getDatabaseContentDigest(params, optionsArg));
+    }
+    /**
+     * Replace one database with a previously exported snapshot.
+     */
+    async importDatabase(params, optionsArg) {
+        return this.runDatabaseManagementOperation(() => this.bridge.importDatabase(params, optionsArg));
+    }
+    /** Release an exact held database publication after downstream fsync. */
+    async commitDatabasePublication(params, optionsArg) {
+        return this.runDatabaseManagementOperation(() => this.bridge.commitDatabasePublication(params, optionsArg));
+    }
+    /**
+     * Get readiness/health details for long-running service use.
+     */
+    async getHealth(optionsArg) {
+        if (!this.isRunning) {
+            return {
+                running: false,
+                storage: this.options.storage,
+                storagePath: this.options.storage === 'file' ? this.options.storagePath : undefined,
+                resourceFencingVersion: this.options.storage === 'file' ? 1 : undefined,
+                resourceFencingSupported: this.options.storage === 'file' ? false : undefined,
+                resourceFencingRequiresDrain: this.options.storage === 'file' ? true : undefined,
+                allocationFencingVersion: this.options.storage === 'file' ? 1 : undefined,
+                allocationFencingSupported: this.options.storage === 'file' ? false : undefined,
+                allocationFencingRequiresDrain: this.options.storage === 'file' ? true : undefined,
+                publicationHoldVersion: 1,
+                publicationHoldSupported: false,
+                publicationHoldRequiresExternalDrain: false,
+                authEnabled: Boolean(this.options.auth?.enabled),
+                authUsers: this.options.auth?.users?.length ?? 0,
+                usersPathConfigured: false,
+                databaseCount: 0,
+                collectionCount: 0,
+            };
+        }
+        return this.runDatabaseManagementOperation(() => this.bridge.getHealth(optionsArg));
+    }
+    // --- OpLog / Debug API ---
+    /**
+     * Get oplog entries, optionally filtered.
+     */
+    async getOpLog(params = {}) {
+        return this.bridge.getOpLog(params);
+    }
+    /**
+     * Get aggregate oplog statistics.
+     */
+    async getOpLogStats() {
+        return this.bridge.getOpLogStats();
+    }
+    /**
+     * Revert database state to a specific oplog sequence number.
+     * Use dryRun=true to preview which entries would be reverted.
+     */
+    async revertToSeq(seq, dryRun = false) {
+        return this.bridge.revertToSeq(seq, dryRun);
+    }
+    /**
+     * List all collections across all databases, with document counts.
+     */
+    async getCollections(db) {
+        return this.bridge.getCollections(db);
+    }
+    /**
+     * Get documents from a collection with pagination.
+     */
+    async getDocuments(db, collection, limit = 50, skip = 0) {
+        return this.bridge.getDocuments(db, collection, limit, skip);
+    }
+    /**
+     * Get server metrics including database/collection counts and oplog info.
+     */
+    async getMetrics() {
+        return this.bridge.getMetrics();
+    }
+    withTenantMongoUri(descriptor, password) {
+        return {
+            ...descriptor,
+            mongodbUri: this.buildTenantMongoUri(descriptor.databaseName, descriptor.username, password),
+        };
+    }
+    buildTenantMongoUri(databaseName, username, password) {
+        const host = this.options.socketPath
+            ? encodeURIComponent(this.options.socketPath)
+            : `${this.options.host ?? '127.0.0.1'}:${this.options.port ?? 27017}`;
+        const auth = `${encodeURIComponent(username)}:${encodeURIComponent(password)}@`;
+        const query = new URLSearchParams({ authSource: databaseName });
+        if (this.options.tls?.enabled) {
+            query.set('tls', 'true');
+        }
+        return `mongodb://${auth}${host}/${encodeURIComponent(databaseName)}?${query.toString()}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.nosqldbserver.js","sourceRoot":"","sources":["../../../ts/ts_nosqldb/server/classes.nosqldbserver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,0CAA0C,GAC3C,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,yCAAyC,EAAE,MAAM,0BAA0B,CAAC;AACrF,OAAO,EAAE,sCAAsC,EAAE,MAAM,yBAAyB,CAAC;AACjF,OAAO,EAAE,kDAAkD,EAAE,MAAM,+BAA+B,CAAC;AACnG,OAAO,EAEN,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,kCAAkC,GACnC,MAAM,4BAA4B,CAAC;AAkGpC;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,OAAO,aAAa;IAUxB,YAAY,UAAiC,EAAE;QAPvC,gBAAW,GAAG,KAAK,CAAC;QACpB,oBAAe,GAAG,KAAK,CAAC;QACxB,2BAAsB,GAAyB,IAAI,CAAC;QACpD,cAAS,GAAG,KAAK,CAAC;QAClB,0BAAqB,GAAG,EAAE,CAAC;QAIjC,sCAAsC,CAAC,OAAO,CAAC,CAAC;QAChD,MAAM,WAAW,GAAG,kCAAkC,CAAC,OAAO,CAAC,CAAC;QAChE,IAAI,CAAC,OAAO,GAAG;YACb,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,kBAAkB,EAAE,OAAO,CAAC,kBAAkB;YAC9C,GAAG,WAAW;YACd,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,KAAK;YAC3B,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,WAAW;YACjC,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,QAAQ;YACpC,WAAW,EAAE,OAAO,CAAC,WAAW,IAAI,QAAQ;YAC5C,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,GAAG,EAAE,OAAO,CAAC,GAAG;YAChB,KAAK,EAAE,OAAO,CAAC,KAAK;YACpB,KAAK,EAAE,OAAO,CAAC,KAAK;SACrB,CAAC;QACF,IAAI,CAAC,MAAM,GAAG,IAAI,YAAY,CAAC,EAAE,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;QACxE,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAmB,EAAE,MAAqB,EAAE,EAAE;YACpE,MAAM,kBAAkB,GAAG,IAAI,CAAC,SAAS,CAAC;YAC1C,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;YACvB,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;YACzB,IAAI,CAAC,qBAAqB,GAAG,EAAE,CAAC;YAChC,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;YAC9B,IAAI,kBAAkB,EAAE,CAAC;gBACvB,OAAO,CAAC,KAAK,CAAC,kDAAkD,IAAI,YAAY,MAAM,GAAG,CAAC,CAAC;YAC7F,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAK,CAAC,UAA+C;QACzD,yCAAyC,CAAC,UAAU,CAAC,CAAC;QACtD,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC;QACrC,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YAC/D,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;QAC3E,CAAC;QAED,MAAM,gBAAgB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACpC,MAAM,eAAe,GAAG,UAAU,EAAE,SAAS,KAAK,SAAS;YACzD,CAAC,CAAC,SAAS;YACX,CAAC,CAAC,gBAAgB,GAAG,UAAU,CAAC,SAAS,CAAC;QAC5C,MAAM,YAAY,GAAG,IAAI,YAAY,CACnC,UAAU,EAAE,SAAS,KAAK,SAAS;YACjC,CAAC,CAAC,2BAA2B;YAC7B,CAAC,CAAC,mCAAmC,UAAU,CAAC,SAAS,IAAI,EAC/D,cAAc,CACf,CAAC;QACF,MAAM,sBAAsB,GAAG,IAAI,eAAe,EAAE,CAAC;QACrD,IAAI,cAAyD,CAAC;QAC9D,IAAI,oBAA8C,CAAC;QACnD,IAAI,UAAU,EAAE,MAAM,EAAE,CAAC;YACvB,oBAAoB,GAAG,GAAG,EAAE;gBAC1B,sBAAsB,CAAC,KAAK,CAAC,UAAU,CAAC,MAAO,CAAC,MAAM,CAAC,CAAC;YAC1D,CAAC,CAAC;YACF,UAAU,CAAC,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QACpF,CAAC;QACD,IAAI,UAAU,EAAE,SAAS,KAAK,SAAS,EAAE,CAAC;YACxC,cAAc,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC/B,sBAAsB,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;YAC7C,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC;QAC3B,CAAC;QACD,MAAM,UAAU,GAAG,GAAG,EAAE;YACtB,IACE,eAAe,KAAK,SAAS;mBAC1B,IAAI,CAAC,GAAG,EAAE,IAAI,eAAe;mBAC7B,CAAC,sBAAsB,CAAC,MAAM,CAAC,OAAO,EACzC,CAAC;gBACD,sBAAsB,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;YAC7C,CAAC;YACD,sBAAsB,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC;QACjD,CAAC,CAAC;QACF,MAAM,yBAAyB,GAAG,GAAmD,EAAE;YACrF,UAAU,EAAE,CAAC;YACb,MAAM,kBAAkB,GAAG,eAAe,KAAK,SAAS;gBACtD,CAAC,CAAC,SAAS;gBACX,CAAC,CAAC,eAAe,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACjC,IAAI,kBAAkB,KAAK,SAAS,IAAI,kBAAkB,IAAI,CAAC,EAAE,CAAC;gBAChE,sBAAsB,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;gBAC3C,UAAU,EAAE,CAAC;YACf,CAAC;YACD,IAAI,CAAC,UAAU,EAAE,MAAM,IAAI,kBAAkB,KAAK,SAAS;gBAAE,OAAO,SAAS,CAAC;YAC9E,OAAO;gBACL,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC5D,GAAG,CAAC,kBAAkB,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,kBAAkB,EAAE,CAAC;aAC/E,CAAC;QACJ,CAAC,CAAC;QAEF,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC5B,IAAI,sBAAmC,CAAC;QACxC,MAAM,sBAAsB,GAAG,IAAI,OAAO,CAAO,CAAC,UAAU,EAAE,EAAE;YAC9D,sBAAsB,GAAG,UAAU,CAAC;QACtC,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,sBAAsB,GAAG,sBAAsB,CAAC;QACrD,IAAI,CAAC;YACH,UAAU,EAAE,CAAC;YACb,sEAAsE;YACtE,qEAAqE;YACrE,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,KAAK,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;gBAChE,MAAM,kDAAkD,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;gBACnF,UAAU,EAAE,CAAC;YACf,CAAC;YAED,wEAAwE;YACxE,uDAAuD;YACvD,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;YACxB,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,yBAAyB,EAAE,CAAC,CAAC;YACrE,UAAU,EAAE,CAAC;YACb,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,IAAI,KAAK,CACb,kEAAkE;oBAClE,+DAA+D,CAChE,CAAC;YACJ,CAAC;YAED,sCAAsC;YACtC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;gBACvC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;gBACvB,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;gBACvB,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU;gBACnC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,IAAI,QAAQ;gBACzC,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,WAAW;gBACrC,kBAAkB,EAAE,IAAI,CAAC,OAAO,CAAC,kBAAkB;gBACnD,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI;gBACvB,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG;gBACrB,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK;gBACzB,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,KAAK;aAC1B,EAAE,yBAAyB,EAAE,CAAC,CAAC;YAChC,UAAU,EAAE,CAAC;YACb,IAAI,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;gBAC9C,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;YAChE,CAAC;YAED,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;gBAC7B,MAAM,aAAa,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;gBACpD,MAAM,YAAY,GAAG,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;gBAChD,IACE,aAAa,CAAC,QAAQ,KAAK,UAAU;uBAClC,CAAC,aAAa,CAAC,QAAQ;uBACvB,CAAC,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC;uBAC/B,YAAY,GAAG,CAAC;uBAChB,YAAY,GAAG,MAAM,EACxB,CAAC;oBACD,MAAM,IAAI,KAAK,CAAC,mDAAmD,MAAM,CAAC,aAAa,EAAE,CAAC,CAAC;gBAC7F,CAAC;gBACD,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;YACnC,CAAC;YACD,IAAI,CAAC,qBAAqB,GAAG,MAAM,CAAC,aAAa,CAAC;YAClD,UAAU,EAAE,CAAC;YACb,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACxB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,YAAY,GAAG,KAAK,YAAY,0CAA0C;gBAC9E,CAAC,CAAC,KAAK;gBACP,CAAC,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO;oBAC3B,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM;oBAC1B,CAAC,CAAC,sBAAsB,CAAC,MAAM,CAAC,OAAO,IAAI,CACvC,eAAe,KAAK,SAAS,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,eAAe,CAC/D;wBACD,CAAC,CAAC,YAAY;wBACd,CAAC,CAAC,KAAK,CAAC;YACd,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;YACvB,IAAI,CAAC,qBAAqB,GAAG,EAAE,CAAC;YAChC,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;YAC9B,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;gBACrB,IAAI,CAAC;oBACH,MAAM,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;oBAC9B,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;gBAC3B,CAAC;gBAAC,OAAO,YAAY,EAAE,CAAC;oBACtB,MAAM,IAAI,cAAc,CACtB,CAAC,YAAY,EAAE,YAAY,CAAC,EAC5B,+DAA+D,EAC/D,EAAE,KAAK,EAAE,YAAY,EAAE,CACxB,CAAC;gBACJ,CAAC;YACH,CAAC;YACD,MAAM,YAAY,CAAC;QACrB,CAAC;gBAAS,CAAC;YACT,IAAI,cAAc;gBAAE,YAAY,CAAC,cAAc,CAAC,CAAC;YACjD,IAAI,oBAAoB,IAAI,UAAU,EAAE,MAAM,EAAE,CAAC;gBAC/C,UAAU,CAAC,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,CAAC,CAAC;YACvE,CAAC;YACD,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;YAC7B,sBAAsB,EAAE,CAAC;YACzB,IAAI,IAAI,CAAC,sBAAsB,KAAK,sBAAsB,EAAE,CAAC;gBAC3D,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;YACrC,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,IAAI;QACR,MAAM,sBAAsB,GAAG,IAAI,CAAC,sBAAsB,CAAC;QAC3D,IAAI,sBAAsB,EAAE,CAAC;YAC3B,MAAM,sBAAsB,CAAC;QAC/B,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YACzC,OAAO;QACT,CAAC;QAED,MAAM,mBAAmB,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;QAClE,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,IAAI,CAAC,qBAAqB,GAAG,EAAE,CAAC;QAChC,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;QAC9B,IAAI,mBAAmB,EAAE,CAAC;YACxB,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YAC7B,CAAC;YAAC,MAAM,CAAC;gBACP,uEAAuE;YACzE,CAAC;QACH,CAAC;QAED,MAAM,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;QAC9B,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,gBAAgB;QACd,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC/B,OAAO,IAAI,CAAC,qBAAqB,CAAC;QACpC,CAAC;QACD,iCAAiC;QACjC,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;YAC5B,MAAM,WAAW,GAAG,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YAChE,OAAO,aAAa,WAAW,EAAE,CAAC;QACpC,CAAC;QACD,MAAM,OAAO,GAAG,aAAa,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,WAAW,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,KAAK,EAAE,CAAC;QAC9F,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC;IACtE,CAAC;IAED;;OAEG;IACH,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,8EAA8E;IAC9E,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC;IAC/B,CAAC;IAED,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAEO,KAAK,CAAC,8BAA8B,CAC1C,YAAoC;QAEpC,IAAI,CAAC;YACH,OAAO,MAAM,YAAY,EAAE,CAAC;QAC9B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IACE,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO;mBACjB,KAAK,YAAY,0CAA0C,EAC9D,CAAC;gBACD,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;gBACvB,IAAI,CAAC,qBAAqB,GAAG,EAAE,CAAC;gBAChC,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;gBAC9B,IAAI,IAAI,CAAC,MAAM,CAAC,iBAAiB,EAAE,CAAC;oBAClC,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;gBAC3B,CAAC;YACH,CAAC;YACD,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACH,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,KAAK,CAAC;IACzD,CAAC;IAED;;OAEG;IACH,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,WAAW,CAAC;IAC1C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,oBAAoB,CACxB,MAAmC;QAEnC,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,MAAM,CAAC,CAAC;QAClE,OAAO,IAAI,CAAC,kBAAkB,CAAC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC9D,CAAC;IAED,kEAAkE;IAClE,KAAK,CAAC,sBAAsB,CAC1B,MAA2C,EAC3C,UAA+C;QAE/C,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,8BAA8B,CAC1D,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,sBAAsB,CAAC,MAAM,EAAE,UAAU,CAAC,CAC7D,CAAC;QACF,OAAO,IAAI,CAAC,kBAAkB,CAAC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC9D,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,oBAAoB,CACxB,MAAyC,EACzC,UAA+C;QAE/C,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,8BAA8B,CAC1D,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,MAAM,EAAE,UAAU,CAAC,CAC3D,CAAC;QACF,OAAO,IAAI,CAAC,kBAAkB,CAAC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC9D,CAAC;IAED,yEAAyE;IACzE,KAAK,CAAC,oBAAoB,CACxB,MAAyC,EACzC,UAA+C;QAE/C,OAAO,IAAI,CAAC,8BAA8B,CACxC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,MAAM,EAAE,UAAU,CAAC,CAC3D,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,oBAAoB,CACxB,MAAyC,EACzC,UAA+C;QAE/C,OAAO,IAAI,CAAC,8BAA8B,CACxC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,MAAM,EAAE,UAAU,CAAC,CAC3D,CAAC;IACJ,CAAC;IAED,6EAA6E;IAC7E,KAAK,CAAC,sCAAsC,CAC1C,MAA2D,EAC3D,UAA+C;QAE/C,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,8BAA8B,CAC1D,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,sCAAsC,CAAC,MAAM,EAAE,UAAU,CAAC,CAC7E,CAAC;QACF,OAAO,IAAI,CAAC,kBAAkB,CAAC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC9D,CAAC;IAED,gFAAgF;IAChF,KAAK,CAAC,uCAAuC,CAC3C,MAA4D,EAC5D,UAA+C;QAE/C,OAAO,IAAI,CAAC,8BAA8B,CACxC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,uCAAuC,CAAC,MAAM,EAAE,UAAU,CAAC,CAC9E,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,4BAA4B,CAChC,MAAiD;QAEjD,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,4BAA4B,CAAC,MAAM,CAAC,CAAC;QAC1E,OAAO,IAAI,CAAC,kBAAkB,CAAC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC9D,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,mBAAmB;QACvB,OAAO,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE,CAAC;IAC3C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,2BAA2B,CAAC,MAGjC;QACC,OAAO,IAAI,CAAC,MAAM,CAAC,2BAA2B,CAAC,MAAM,CAAC,CAAC;IACzD,CAAC;IAED,8EAA8E;IAC9E,KAAK,CAAC,6BAA6B,CACjC,MAAgC,EAChC,UAA+C;QAE/C,OAAO,IAAI,CAAC,8BAA8B,CACxC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,6BAA6B,CAAC,MAAM,EAAE,UAAU,CAAC,CACpE,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,cAAc,CAClB,MAAmC,EACnC,UAA+C;QAE/C,OAAO,IAAI,CAAC,8BAA8B,CACxC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,UAAU,CAAC,CACrD,CAAC;IACJ,CAAC;IAED,uFAAuF;IACvF,KAAK,CAAC,wBAAwB,CAC5B,MAA6C,EAC7C,UAA+C;QAE/C,OAAO,IAAI,CAAC,8BAA8B,CACxC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,wBAAwB,CAAC,MAAM,EAAE,UAAU,CAAC,CAC/D,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,cAAc,CAClB,MAAmC,EACnC,UAA+C;QAE/C,OAAO,IAAI,CAAC,8BAA8B,CACxC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,UAAU,CAAC,CACrD,CAAC;IACJ,CAAC;IAED,yEAAyE;IACzE,KAAK,CAAC,yBAAyB,CAC7B,MAA8C,EAC9C,UAA+C;QAE/C,OAAO,IAAI,CAAC,8BAA8B,CACxC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,yBAAyB,CAAC,MAAM,EAAE,UAAU,CAAC,CAChE,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,SAAS,CACb,UAA+C;QAE/C,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACpB,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO;gBAC7B,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS;gBACnF,sBAAsB,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS;gBACvE,wBAAwB,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,KAAK,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS;gBAC7E,4BAA4B,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;gBAChF,wBAAwB,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS;gBACzE,0BAA0B,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,KAAK,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS;gBAC/E,8BAA8B,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;gBAClF,sBAAsB,EAAE,CAAC;gBACzB,wBAAwB,EAAE,KAAK;gBAC/B,oCAAoC,EAAE,KAAK;gBAC3C,WAAW,EAAE,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC;gBAChD,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,IAAI,CAAC;gBAChD,mBAAmB,EAAE,KAAK;gBAC1B,aAAa,EAAE,CAAC;gBAChB,eAAe,EAAE,CAAC;aACnB,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC,8BAA8B,CACxC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,CACxC,CAAC;IACJ,CAAC;IAED,4BAA4B;IAE5B;;OAEG;IACH,KAAK,CAAC,QAAQ,CAAC,SAKX,EAAE;QACJ,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IACtC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,aAAa;QACjB,OAAO,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,CAAC;IACrC,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,WAAW,CAAC,GAAW,EAAE,MAAM,GAAG,KAAK;QAC3C,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IAC9C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,cAAc,CAAC,EAAW;QAC9B,OAAO,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;IACxC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,YAAY,CAChB,EAAU,EACV,UAAkB,EAClB,KAAK,GAAG,EAAE,EACV,IAAI,GAAG,CAAC;QAER,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;IAC/D,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,UAAU;QACd,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;IAClC,CAAC;IAEO,kBAAkB,CACxB,UAAuB,EACvB,QAAgB;QAEhB,OAAO;YACL,GAAG,UAAU;YACb,UAAU,EAAE,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC,YAAY,EAAE,UAAU,CAAC,QAAQ,EAAE,QAAQ,CAAC;SAC7F,CAAC;IACJ,CAAC;IAEO,mBAAmB,CAAC,YAAoB,EAAE,QAAgB,EAAE,QAAgB;QAClF,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU;YAClC,CAAC,CAAC,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;YAC7C,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,WAAW,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,KAAK,EAAE,CAAC;QACxE,MAAM,IAAI,GAAG,GAAG,kBAAkB,CAAC,QAAQ,CAAC,IAAI,kBAAkB,CAAC,QAAQ,CAAC,GAAG,CAAC;QAChF,MAAM,KAAK,GAAG,IAAI,eAAe,CAAC,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC,CAAC;QAChE,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,EAAE,CAAC;YAC9B,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAC3B,CAAC;QACD,OAAO,aAAa,IAAI,GAAG,IAAI,IAAI,kBAAkB,CAAC,YAAY,CAAC,IAAI,KAAK,CAAC,QAAQ,EAAE,EAAE,CAAC;IAC5F,CAAC;CACF"}

package/dist_ts/ts_nosqldb/server/index.d.ts

@@ -0,0 +1,3 @@
+export { NoSqlDbServer } from './classes.nosqldbserver.js';
+export type { INoSqlDbServerOptions } from './classes.nosqldbserver.js';
+export type { INoSqlDbQueryOptions } from '../rust-db-bridge.js';

package/dist_ts/ts_nosqldb/server/index.js

@@ -0,0 +1,3 @@
+// Server module exports
+export { NoSqlDbServer } from './classes.nosqldbserver.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy90c19ub3NxbGRiL3NlcnZlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSx3QkFBd0I7QUFDeEIsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLDRCQUE0QixDQUFDIn0=